PageRenderTime 91ms CodeModel.GetById 25ms RepoModel.GetById 0ms app.codeStats 1ms

/dist/jasmine/blanket_jasmine.js

https://github.com/geekdave/blanket
JavaScript | 5442 lines | 4485 code | 731 blank | 226 comment | 811 complexity | e48ea7fe662ee563a53e84a29ac6d7c2 MD5 | raw file
Possible License(s): MIT 
    

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

  2. 

  3. (function(define){
    4. 

  4. 

  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 += '\v';
    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 (classMarker) {
    976. 

  976.                 if (ch === ']') {
    977. 

  977.                     classMarker = false;
    978. 

  978.                 }
    979. 

  979.             } else {
    980. 

  980.                 if (ch === '\\') {
    981. 

  981.                     ch = source[index++];
    982. 

  982.                     // ECMA-262 7.8.5
    983. 

  983.                     if (isLineTerminator(ch)) {
    984. 

  984.                         throwError({}, Messages.UnterminatedRegExp);
    985. 

  985.                     }
    986. 

  986.                     str += ch;
    987. 

  987.                 } else 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.                     throwUnexpected(lex());
    1407. 

  1407.                 }
    1408. 

  1408.                 param = [ parseVariableIdentifier() ];
    1409. 

  1409.                 expect(')');
    1410. 

  1410.                 return {
    1411. 

  1411.                     type: Syntax.Property,
    1412. 

  1412.                     key: key,
    1413. 

  1413.                     value: parsePropertyFunction(param, token),
    1414. 

  1414.                     kind: 'set'
    1415. 

  1415.                 };
    1416. 

  1416.             } else {
    1417. 

  1417.                 expect(':');
    1418. 

  1418.                 return {
    1419. 

  1419.                     type: Syntax.Property,
    1420. 

  1420.                     key: id,
    1421. 

  1421.                     value: parseAssignmentExpression(),
    1422. 

  1422.                     kind: 'init'
    1423. 

  1423.                 };
    1424. 

  1424.             }
    1425. 

  1425.         } else if (token.type === Token.EOF || token.type === Token.Punctuator) {
    1426. 

  1426.             throwUnexpected(token);
    1427. 

  1427.         } else {
    1428. 

  1428.             key = parseObjectPropertyKey();
    1429. 

  1429.             expect(':');
    1430. 

  1430.             return {
    1431. 

  1431.                 type: Syntax.Property,
    1432. 

  1432.                 key: key,
    1433. 

  1433.                 value: parseAssignmentExpression(),
    1434. 

  1434.                 kind: 'init'
    1435. 

  1435.             };
    1436. 

  1436.         }
    1437. 

  1437.     }
    1438. 

  1438. 

  1439.     function parseObjectInitialiser() {
    1440. 

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

  1441. 

  1442.         expect('{');
    1443. 

  1443. 

  1444.         while (!match('}')) {
    1445. 

  1445.             property = parseObjectProperty();
    1446. 

  1446. 

  1447.             if (property.key.type === Syntax.Identifier) {
    1448. 

  1448.                 name = property.key.name;
    1449. 

  1449.             } else {
    1450. 

  1450.                 name = toString(property.key.value);
    1451. 

  1451.             }
    1452. 

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

  1453.             if (Object.prototype.hasOwnProperty.call(map, name)) {
    1454. 

  1454.                 if (map[name] === PropertyKind.Data) {
    1455. 

  1455.                     if (strict && kind === PropertyKind.Data) {
    1456. 

  1456.                         throwErrorTolerant({}, Messages.StrictDuplicateProperty);
    1457. 

  1457.                     } else if (kind !== PropertyKind.Data) {
    1458. 

  1458.                         throwErrorTolerant({}, Messages.AccessorDataProperty);
    1459. 

  1459.                     }
    1460. 

  1460.                 } else {
    1461. 

  1461.                     if (kind === PropertyKind.Data) {
    1462. 

  1462.                         throwErrorTolerant({}, Messages.AccessorDataProperty);
    1463. 

  1463.                     } else if (map[name] & kind) {
    1464. 

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

  1465.                     }
    1466. 

  1466.                 }
    1467. 

  1467.                 map[name] |= kind;
    1468. 

  1468.             } else {
    1469. 

  1469.                 map[name] = kind;
    1470. 

  1470.             }
    1471. 

  1471. 

  1472.             properties.push(property);
    1473. 

  1473. 

  1474.             if (!match('}')) {
    1475. 

  1475.                 expect(',');
    1476. 

  1476.             }
    1477. 

  1477.         }
    1478. 

  1478. 

  1479.         expect('}');
    1480. 

  1480. 

  1481.         return {
    1482. 

  1482.             type: Syntax.ObjectExpression,
    1483. 

  1483.             properties: properties
    1484. 

  1484.         };
    1485. 

  1485.     }
    1486. 

  1486. 

  1487.     // 11.1.6 The Grouping Operator
    1488. 

  1488. 

  1489.     function parseGroupExpression() {
    1490. 

  1490.         var expr;
    1491. 

  1491. 

  1492.         expect('(');
    1493. 

  1493. 

  1494.         expr = parseExpression();
    1495. 

  1495. 

  1496.         expect(')');
    1497. 

  1497. 

  1498.         return expr;
    1499. 

  1499.     }
    1500. 

  1500. 

  1501. 

  1502.     // 11.1 Primary Expressions
    1503. 

  1503. 

  1504.     function parsePrimaryExpression() {
    1505. 

  1505.         var token = lookahead(),
    1506. 

  1506.             type = token.type;
    1507. 

  1507. 

  1508.         if (type === Token.Identifier) {
    1509. 

  1509.             return {
    1510. 

  1510.                 type: Syntax.Identifier,
    1511. 

  1511.                 name: lex().value
    1512. 

  1512.             };
    1513. 

  1513.         }
    1514. 

  1514. 

  1515.         if (type === Token.StringLiteral || type === Token.NumericLiteral) {
    1516. 

  1516.             if (strict && token.octal) {
    1517. 

  1517.                 throwErrorTolerant(token, Messages.StrictOctalLiteral);
    1518. 

  1518.             }
    1519. 

  1519.             return createLiteral(lex());
    1520. 

  1520.         }
    1521. 

  1521. 

  1522.         if (type === Token.Keyword) {
    1523. 

  1523.             if (matchKeyword('this')) {
    1524. 

  1524.                 lex();
    1525. 

  1525.                 return {
    1526. 

  1526.                     type: Syntax.ThisExpression
    1527. 

  1527.                 };
    1528. 

  1528.             }
    1529. 

  1529. 

  1530.             if (matchKeyword('function')) {
    1531. 

  1531.                 return parseFunctionExpression();
    1532. 

  1532.             }
    1533. 

  1533.         }
    1534. 

  1534. 

  1535.         if (type === Token.BooleanLiteral) {
    1536. 

  1536.             lex();
    1537. 

  1537.             token.value = (token.value === 'true');
    1538. 

  1538.             return createLiteral(token);
    1539. 

  1539.         }
    1540. 

  1540. 

  1541.         if (type === Token.NullLiteral) {
    1542. 

  1542.             lex();
    1543. 

  1543.             token.value = null;
    1544. 

  1544.             return createLiteral(token);
    1545. 

  1545.         }
    1546. 

  1546. 

  1547.         if (match('[')) {
    1548. 

  1548.             return parseArrayInitialiser();
    1549. 

  1549.         }
    1550. 

  1550. 

  1551.         if (match('{')) {
    1552. 

  1552.             return parseObjectInitialiser();
    1553. 

  1553.         }
    1554. 

  1554. 

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

  1556.             return parseGroupExpression();
    1557. 

  1557.         }
    1558. 

  1558. 

  1559.         if (match('/') || match('/=')) {
    1560. 

  1560.             return createLiteral(scanRegExp());
    1561. 

  1561.         }
    1562. 

  1562. 

  1563.         return throwUnexpected(lex());
    1564. 

  1564.     }
    1565. 

  1565. 

  1566.     // 11.2 Left-Hand-Side Expressions
    1567. 

  1567. 

  1568.     function parseArguments() {
    1569. 

  1569.         var args = [];
    1570. 

  1570. 

  1571.         expect('(');
    1572. 

  1572. 

  1573.         if (!match(')')) {
    1574. 

  1574.             while (index < length) {
    1575. 

  1575.                 args.push(parseAssignmentExpression());
    1576. 

  1576.                 if (match(')')) {
    1577. 

  1577.                     break;
    1578. 

  1578.                 }
    1579. 

  1579.                 expect(',');
    1580. 

  1580.             }
    1581. 

  1581.         }
    1582. 

  1582. 

  1583.         expect(')');
    1584. 

  1584. 

  1585.         return args;
    1586. 

  1586.     }
    1587. 

  1587. 

  1588.     function parseNonComputedProperty() {
    1589. 

  1589.         var token = lex();
    1590. 

  1590. 

  1591.         if (!isIdentifierName(token)) {
    1592. 

  1592.             throwUnexpected(token);
    1593. 

  1593.         }
    1594. 

  1594. 

  1595.         return {
    1596. 

  1596.             type: Syntax.Identifier,
    1597. 

  1597.             name: token.value
    1598. 

  1598.         };
    1599. 

  1599.     }
    1600. 

  1600. 

  1601.     function parseNonComputedMember() {
    1602. 

  1602.         expect('.');
    1603. 

  1603. 

  1604.         return parseNonComputedProperty();
    1605. 

  1605.     }
    1606. 

  1606. 

  1607.     function parseComputedMember() {
    1608. 

  1608.         var expr;
    1609. 

  1609. 

  1610.         expect('[');
    1611. 

  1611. 

  1612.         expr = parseExpression();
    1613. 

  1613. 

  1614.         expect(']');
    1615. 

  1615. 

  1616.         return expr;
    1617. 

  1617.     }
    1618. 

  1618. 

  1619.     function parseNewExpression() {
    1620. 

  1620.         var expr;
    1621. 

  1621. 

  1622.         expectKeyword('new');
    1623. 

  1623. 

  1624.         expr = {
    1625. 

  1625.             type: Syntax.NewExpression,
    1626. 

  1626.             callee: parseLeftHandSideExpression(),
    1627. 

  1627.             'arguments': []
    1628. 

  1628.         };
    1629. 

  1629. 

  1630.         if (match('(')) {
    1631. 

  1631.             expr['arguments'] = parseArguments();
    1632. 

  1632.         }
    1633. 

  1633. 

  1634.         return expr;
    1635. 

  1635.     }
    1636. 

  1636. 

  1637.     function parseLeftHandSideExpressionAllowCall() {
    1638. 

  1638.         var expr;
    1639. 

  1639. 

  1640.         expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();
    1641. 

  1641. 

  1642.         while (match('.') || match('[') || match('(')) {
    1643. 

  1643.             if (match('(')) {
    1644. 

  1644.                 expr = {
    1645. 

  1645.                     type: Syntax.CallExpression,
    1646. 

  1646.                     callee: expr,
    1647. 

  1647.                     'arguments': parseArguments()
    1648. 

  1648.                 };
    1649. 

  1649.             } else if (match('[')) {
    1650. 

  1650.                 expr = {
    1651. 

  1651.                     type: Syntax.MemberExpression,
    1652. 

  1652.                     computed: true,
    1653. 

  1653.                     object: expr,
    1654. 

  1654.                     property: parseComputedMember()
    1655. 

  1655.                 };
    1656. 

  1656.             } else {
    1657. 

  1657.                 expr = {
    1658. 

  1658.                     type: Syntax.MemberExpression,
    1659. 

  1659.                     computed: false,
    1660. 

  1660.                     object: expr,
    1661. 

  1661.                     property: parseNonComputedMember()
    1662. 

  1662.                 };
    1663. 

  1663.             }
    1664. 

  1664.         }
    1665. 

  1665. 

  1666.         return expr;
    1667. 

  1667.     }
    1668. 

  1668. 

  1669. 

  1670.     function parseLeftHandSideExpression() {
    1671. 

  1671.         var expr;
    1672. 

  1672. 

  1673.         expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();
    1674. 

  1674. 

  1675.         while (match('.') || match('[')) {
    1676. 

  1676.             if (match('[')) {
    1677. 

  1677.                 expr = {
    1678. 

  1678.                     type: Syntax.MemberExpression,
    1679. 

  1679.                     computed: true,
    1680. 

  1680.                     object: expr,
    1681. 

  1681.                     property: parseComputedMember()
    1682. 

  1682.                 };
    1683. 

  1683.             } else {
    1684. 

  1684.                 expr = {
    1685. 

  1685.                     type: Syntax.MemberExpression,
    1686. 

  1686.                     computed: false,
    1687. 

  1687.                     object: expr,
    1688. 

  1688.                     property: parseNonComputedMember()
    1689. 

  1689.                 };
    1690. 

  1690.             }
    1691. 

  1691.         }
    1692. 

  1692. 

  1693.         return expr;
    1694. 

  1694.     }
    1695. 

  1695. 

  1696.     // 11.3 Postfix Expressions
    1697. 

  1697. 

  1698.     function parsePostfixExpression() {
    1699. 

  1699.         var expr = parseLeftHandSideExpressionAllowCall(), token;
    1700. 

  1700. 

  1701.         token = lookahead();
    1702. 

  1702.         if (token.type !== Token.Punctuator) {
    1703. 

  1703.             return expr;
    1704. 

  1704.         }
    1705. 

  1705. 

  1706.         if ((match('++') || match('--')) && !peekLineTerminator()) {
    1707. 

  1707.             // 11.3.1, 11.3.2
    1708. 

  1708.             if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {
    1709. 

  1709.                 throwErrorTolerant({}, Messages.StrictLHSPostfix);
    1710. 

  1710.             }
    1711. 

  1711. 

  1712.             if (!isLeftHandSide(expr)) {
    1713. 

  1713.                 throwError({}, Messages.InvalidLHSInAssignment);
    1714. 

  1714.             }
    1715. 

  1715. 

  1716.             expr = {
    1717. 

  1717.                 type: Syntax.UpdateExpression,
    1718. 

  1718.                 operator: lex().value,
    1719. 

  1719.                 argument: expr,
    1720. 

  1720.                 prefix: false
    1721. 

  1721.             };
    1722. 

  1722.         }
    1723. 

  1723. 

  1724.         return expr;
    1725. 

  1725.     }
    1726. 

  1726. 

  1727.     // 11.4 Unary Operators
    1728. 

  1728. 

  1729.     function parseUnaryExpression() {
    1730. 

  1730.         var token, expr;
    1731. 

  1731. 

  1732.         token = lookahead();
    1733. 

  1733.         if (token.type !== Token.Punctuator && token.type !== Token.Keyword) {
    1734. 

  1734.             return parsePostfixExpression();
    1735. 

  1735.         }
    1736. 

  1736. 

  1737.         if (match('++') || match('--')) {
    1738. 

  1738.             token = lex();
    1739. 

  1739.             expr = parseUnaryExpression();
    1740. 

  1740.             // 11.4.4, 11.4.5
    1741. 

  1741.             if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {
    1742. 

  1742.                 throwErrorTolerant({}, Messages.StrictLHSPrefix);
    1743. 

  1743.             }
    1744. 

  1744. 

  1745.             if (!isLeftHandSide(expr)) {
    1746. 

  1746.                 throwError({}, Messages.InvalidLHSInAssignment);
    1747. 

  1747.             }
    1748. 

  1748. 

  1749.             expr = {
    1750. 

  1750.                 type: Syntax.UpdateExpression,
    1751. 

  1751.                 operator: token.value,
    1752. 

  1752.                 argument: expr,
    1753. 

  1753.                 prefix: true
    1754. 

  1754.             };
    1755. 

  1755.             return expr;
    1756. 

  1756.         }
    1757. 

  1757. 

  1758.         if (match('+') || match('-') || match('~') || match('!')) {
    1759. 

  1759.             expr = {
    1760. 

  1760.                 type: Syntax.UnaryExpression,
    1761. 

  1761.                 operator: lex().value,
    1762. 

  1762.                 argument: parseUnaryExpression()
    1763. 

  1763.             };
    1764. 

  1764.             return expr;
    1765. 

  1765.         }
    1766. 

  1766. 

  1767.         if (matchKeyword('delete') || matchKeyword('void') || matchKeyword('typeof')) {
    1768. 

  1768.             expr = {
    1769. 

  1769.                 type: Syntax.UnaryExpression,
    1770. 

  1770.                 operator: lex().value,
    1771. 

  1771.                 argument: parseUnaryExpression()
    1772. 

  1772.             };
    1773. 

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

  1774.                 throwErrorTolerant({}, Messages.StrictDelete);
    1775. 

  1775.             }
    1776. 

  1776.             return expr;
    1777. 

  1777.         }
    1778. 

  1778. 

  1779.         return parsePostfixExpression();
    1780. 

  1780.     }
    1781. 

  1781. 

  1782.     // 11.5 Multiplicative Operators
    1783. 

  1783. 

  1784.     function parseMultiplicativeExpression() {
    1785. 

  1785.         var expr = parseUnaryExpression();
    1786. 

  1786. 

  1787.         while (match('*') || match('/') || match('%')) {
    1788. 

  1788.             expr = {
    1789. 

  1789.                 type: Syntax.BinaryExpression,
    1790. 

  1790.                 operator: lex().value,
    1791. 

  1791.                 left: expr,
    1792. 

  1792.                 right: parseUnaryExpression()
    1793. 

  1793.             };
    1794. 

  1794.         }
    1795. 

  1795. 

  1796.         return expr;
    1797. 

  1797.     }
    1798. 

  1798. 

  1799.     // 11.6 Additive Operators
    1800. 

  1800. 

  1801.     function parseAdditiveExpression() {
    1802. 

  1802.         var expr = parseMultiplicativeExpression();
    1803. 

  1803. 

  1804.         while (match('+') || match('-')) {
    1805. 

  1805.             expr = {
    1806. 

  1806.                 type: Syntax.BinaryExpression,
    1807. 

  1807.                 operator: lex().value,
    1808. 

  1808.                 left: expr,
    1809. 

  1809.                 right: parseMultiplicativeExpression()
    1810. 

  1810.             };
    1811. 

  1811.         }
    1812. 

  1812. 

  1813.         return expr;
    1814. 

  1814.     }
    1815. 

  1815. 

  1816.     // 11.7 Bitwise Shift Operators
    1817. 

  1817. 

  1818.     function parseShiftExpression() {
    1819. 

  1819.         var expr = parseAdditiveExpression();
    1820. 

  1820. 

  1821.         while (match('<<') || match('>>') || match('>>>')) {
    1822. 

  1822.             expr = {
    1823. 

  1823.                 type: Syntax.BinaryExpression,
    1824. 

  1824.                 operator: lex().value,
    1825. 

  1825.                 left: expr,
    1826. 

  1826.                 right: parseAdditiveExpression()
    1827. 

  1827.             };
    1828. 

  1828.         }
    1829. 

  1829. 

  1830.         return expr;
    1831. 

  1831.     }
    1832. 

  1832.     // 11.8 Relational Operators
    1833. 

  1833. 

  1834.     function parseRelationalExpression() {
    1835. 

  1835.         var expr, previousAllowIn;
    1836. 

  1836. 

  1837.         previousAllowIn = state.allowIn;
    1838. 

  1838.         state.allowIn = true;
    1839. 

  1839. 

  1840.         expr = parseShiftExpression();
    1841. 

  1841. 

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

  1843.             expr = {
    1844. 

  1844.                 type: Syntax.BinaryExpression,
    1845. 

  1845.                 operator: lex().value,
    1846. 

  1846.                 left: expr,
    1847. 

  1847.                 right: parseShiftExpression()
    1848. 

  1848.             };
    1849. 

  1849.         }
    1850. 

  1850. 

  1851.         state.allowIn = previousAllowIn;
    1852. 

  1852.         return expr;
    1853. 

  1853.     }
    1854. 

  1854. 

  1855.     // 11.9 Equality Operators
    1856. 

  1856. 

  1857.     function parseEqualityExpression() {
    1858. 

  1858.         var expr = parseRelationalExpression();
    1859. 

  1859. 

  1860.         while (match('==') || match('!=') || match('===') || match('!==')) {
    1861. 

  1861.             expr = {
    1862. 

  1862.                 type: Syntax.BinaryExpression,
    1863. 

  1863.                 operator: lex().value,
    1864. 

  1864.                 left: expr,
    1865. 

  1865.                 right: parseRelationalExpression()
    1866. 

  1866.             };
    1867. 

  1867.         }
    1868. 

  1868. 

  1869.         return expr;
    1870. 

  1870.     }
    1871. 

  1871. 

  1872.     // 11.10 Binary Bitwise Operators
    1873. 

  1873. 

  1874.     function parseBitwiseANDExpression() {
    1875. 

  1875.         var expr = parseEqualityExpression();
    1876. 

  1876. 

  1877.         while (match('&')) {
    1878. 

  1878.             lex();
    1879. 

  1879.             expr = {
    1880. 

  1880.                 type: Syntax.BinaryExpression,
    1881. 

  1881.                 operator: '&',
    1882. 

  1882.                 left: expr,
    1883. 

  1883.                 right: parseEqualityExpression()
    1884. 

  1884.             };
    1885. 

  1885.         }
    1886. 

  1886. 

  1887.         return expr;
    1888. 

  1888.     }
    1889. 

  1889. 

  1890.     function parseBitwiseXORExpression() {
    1891. 

  1891.         var expr = parseBitwiseANDExpression();
    1892. 

  1892. 

  1893.         while (match('^')) {
    1894. 

  1894.             lex();
    1895. 

  1895.             expr = {
    1896. 

  1896.                 type: Syntax.BinaryExpression,
    1897. 

  1897.                 operator: '^',
    1898. 

  1898.                 left: expr,
    1899. 

  1899.                 right: parseBitwiseANDExpression()
    1900. 

  1900.             };
    1901. 

  1901.         }
    1902. 

  1902. 

  1903.         return expr;
    1904. 

  1904.     }
    1905. 

  1905. 

  1906.     function parseBitwiseORExpression() {
    1907. 

  1907.         var expr = parseBitwiseXORExpression();
    1908. 

  1908. 

  1909.         while (match('|')) {
    1910. 

  1910.             lex();
    1911. 

  1911.             expr = {
    1912. 

  1912.                 type: Syntax.BinaryExpression,
    1913. 

  1913.                 operator: '|',
    1914. 

  1914.                 left: expr,
    1915. 

  1915.                 right: parseBitwiseXORExpression()
    1916. 

  1916.             };
    1917. 

  1917.         }
    1918. 

  1918. 

  1919.         return expr;
    1920. 

  1920.     }
    1921. 

  1921. 

  1922.     // 11.11 Binary Logical Operators
    1923. 

  1923. 

  1924.     function parseLogicalANDExpression() {
    1925. 

  1925.         var expr = parseBitwiseORExpression();
    1926. 

  1926. 

  1927.         while (match('&&')) {
    1928. 

  1928.             lex();
    1929. 

  1929.             expr = {
    1930. 

  1930.                 type: Syntax.LogicalExpression,
    1931. 

  1931.                 operator: '&&',
    1932. 

  1932.                 left: expr,
    1933. 

  1933.                 right: parseBitwiseORExpression()
    1934. 

  1934.             };
    1935. 

  1935.         }
    1936. 

  1936. 

  1937.         return expr;
    1938. 

  1938.     }
    1939. 

  1939. 

  1940.     function parseLogicalORExpression() {
    1941. 

  1941.         var expr = parseLogicalANDExpression();
    1942. 

  1942. 

  1943.         while (match('||')) {
    1944. 

  1944.             lex();
    1945. 

  1945.             expr = {
    1946. 

  1946.                 type: Syntax.LogicalExpression,
    1947. 

  1947.                 operator: '||',
    1948. 

  1948.                 left: expr,
    1949. 

  1949.                 right: parseLogicalANDExpression()
    1950. 

  1950.             };
    1951. 

  1951.         }
    1952. 

  1952. 

  1953.         return expr;
    1954. 

  1954.     }
    1955. 

  1955. 

  1956.     // 11.12 Conditional Operator
    1957. 

  1957. 

  1958.     function parseConditionalExpression() {
    1959. 

  1959.         var expr, previousAllowIn, consequent;
    1960. 

  1960. 

  1961.         expr = parseLogicalORExpression();
    1962. 

  1962. 

  1963.         if (match('?')) {
    1964. 

  1964.             lex();
    1965. 

  1965.             previousAllowIn = state.allowIn;
    1966. 

  1966.             state.allowIn = true;
    1967. 

  1967.             consequent = parseAssignmentExpression();
    1968. 

  1968.             state.allowIn = previousAllowIn;
    1969. 

  1969.             expect(':');
    1970. 

  1970. 

  1971.             expr = {
    1972. 

  1972.                 type: Syntax.ConditionalExpression,
    1973. 

  1973.                 test: expr,
    1974. 

  1974.                 consequent: consequent,
    1975. 

  1975.                 alternate: parseAssignmentExpression()
    1976. 

  1976.             };
    1977. 

  1977.         }
    1978. 

  1978. 

  1979.         return expr;
    1980. 

  1980.     }
    1981. 

  1981. 

  1982.     // 11.13 Assignment Operators
    1983. 

  1983. 

  1984.     function parseAssignmentExpression() {
    1985. 

  1985.         var token, expr;
    1986. 

  1986. 

  1987.         token = lookahead();
    1988. 

  1988.         expr = parseConditionalExpression();
    1989. 

  1989. 

  1990.         if (matchAssign()) {
    1991. 

  1991.             // LeftHandSideExpression
    1992. 

  1992.             if (!isLeftHandSide(expr)) {
    1993. 

  1993.                 throwError({}, Messages.InvalidLHSInAssignment);
    1994. 

  1994.             }
    1995. 

  1995. 

  1996.             // 11.13.1
    1997. 

  1997.             if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {
    1998. 

  1998.                 throwErrorTolerant(token, Messages.StrictLHSAssignment);
    1999. 

  1999.             }
    2000. 

  2000. 

  2001.             expr = {
    2002. 

  2002.                 type: Syntax.AssignmentExpression,
    2003. 

  2003.                 operator: lex().value,
    2004. 

  2004.                 left: expr,
    2005. 

  2005.                 right: parseAssignmentExpression()
    2006. 

  2006.             };
    2007. 

  2007.         }
    2008. 

  2008. 

  2009.         return expr;
    2010. 

  2010.     }
    2011. 

  2011. 

  2012.     // 11.14 Comma Operator
    2013. 

  2013. 

  2014.     function parseExpression() {
    2015. 

  2015.         var expr = parseAssignmentExpression();
    2016. 

  2016. 

  2017.         if (match(',')) {
    2018. 

  2018.             expr = {
    2019. 

  2019.                 type: Syntax.SequenceExpression,
    2020. 

  2020.                 expressions: [ expr ]
    2021. 

  2021.             };
    2022. 

  2022. 

  2023.             while (index < length) {
    2024. 

  2024.                 if (!match(',')) {
    2025. 

  2025.                     break;
    2026. 

  2026.                 }
    2027. 

  2027.                 lex();
    2028. 

  2028.                 expr.expressions.push(parseAssignmentExpression());
    2029. 

  2029.             }
    2030. 

  2030. 

  2031.         }
    2032. 

  2032.         return expr;
    2033. 

  2033.     }
    2034. 

  2034. 

  2035.     // 12.1 Block
    2036. 

  2036. 

  2037.     function parseStatementList() {
    2038. 

  2038.         var list = [],
    2039. 

  2039.             statement;
    2040. 

  2040. 

  2041.         while (index < length) {
    2042. 

  2042.             if (match('}')) {
    2043. 

  2043.                 break;
    2044. 

  2044.             }
    2045. 

  2045.             statement = parseSourceElement();
    2046. 

  2046.             if (typeof statement === 'undefined') {
    2047. 

  2047.                 break;
    2048. 

  2048.             }
    2049. 

  2049.             list.push(statement);
    2050. 

  2050.         }
    2051. 

  2051. 

  2052.         return list;
    2053. 

  2053.     }
    2054. 

  2054. 

  2055.     function parseBlock() {
    2056. 

  2056.         var block;
    2057. 

  2057. 

  2058.         expect('{');
    2059. 

  2059. 

  2060.         block = parseStatementList();
    2061. 

  2061. 

  2062.         expect('}');
    2063. 

  2063. 

  2064.         return {
    2065. 

  2065.             type: Syntax.BlockStatement,
    2066. 

  2066.             body: block
    2067. 

  2067.         };
    2068. 

  2068.     }
    2069. 

  2069. 

  2070.     // 12.2 Variable Statement
    2071. 

  2071. 

  2072.     function parseVariableIdentifier() {
    2073. 

  2073.         var token = lex();
    2074. 

  2074. 

  2075.         if (token.type !== Token.Identifier) {
    2076. 

  2076.             throwUnexpected(token);
    2077. 

  2077.         }
    2078. 

  2078. 

  2079.         return {
    2080. 

  2080.             type: Syntax.Identifier,
    2081. 

  2081.             name: token.value
    2082. 

  2082.         };
    2083. 

  2083.     }
    2084. 

  2084. 

  2085.     function parseVariableDeclaration(kind) {
    2086. 

  2086.         var id = parseVariableIdentifier(),
    2087. 

  2087.             init = null;
    2088. 

  2088. 

  2089.         // 12.2.1
    2090. 

  2090.         if (strict && isRestrictedWord(id.name)) {
    2091. 

  2091.             throwErrorTolerant({}, Messages.StrictVarName);
    2092. 

  2092.         }
    2093. 

  2093. 

  2094.         if (kind === 'const') {
    2095. 

  2095.             expect('=');
    2096. 

  2096.             init = parseAssignmentExpression();
    2097. 

  2097.         } else if (match('=')) {
    2098. 

  2098.             lex();
    2099. 

  2099.             init = parseAssignmentExpression();
    2100. 

  2100.         }
    2101. 

  2101. 

  2102.         return {
    2103. 

  2103.             type: Syntax.VariableDeclarator,
    2104. 

  2104.             id: id,
    2105. 

  2105.             init: init
    2106. 

  2106.         };
    2107. 

  2107.     }
    2108. 

  2108. 

  2109.     function parseVariableDeclarationList(kind) {
    2110. 

  2110.         var list = [];
    2111. 

  2111. 

  2112.         while (index < length) {
    2113. 

  2113.             list.push(parseVariableDeclaration(kind));
    2114. 

  2114.             if (!match(',')) {
    2115. 

  2115.                 break;
    2116. 

  2116.             }
    2117. 

  2117.             lex();
    2118. 

  2118.         }
    2119. 

  2119. 

  2120.         return list;
    2121. 

  2121.     }
    2122. 

  2122. 

  2123.     function parseVariableStatement() {
    2124. 

  2124.         var declarations;
    2125. 

  2125. 

  2126.         expectKeyword('var');
    2127. 

  2127. 

  2128.         declarations = parseVariableDeclarationList();
    2129. 

  2129. 

  2130.         consumeSemicolon();
    2131. 

  2131. 

  2132.         return {
    2133. 

  2133.             type: Syntax.VariableDeclaration,
    2134. 

  2134.             declarations: declarations,
    2135. 

  2135.             kind: 'var'
    2136. 

  2136.         };
    2137. 

  2137.     }
    2138. 

  2138. 

  2139.     // kind may be `const` or `let`
    2140. 

  2140.     // Both are experimental and not in the specification yet.
    2141. 

  2141.     // see http://wiki.ecmascript.org/doku.php?id=harmony:const
    2142. 

  2142.     // and http://wiki.ecmascript.org/doku.php?id=harmony:let
    2143. 

  2143.     function parseConstLetDeclaration(kind) {
    2144. 

  2144.         var declarations;
    2145. 

  2145. 

  2146.         expectKeyword(kind);
    2147. 

  2147. 

  2148.         declarations = parseVariableDeclarationList(kind);
    2149. 

  2149. 

  2150.         consumeSemicolon();
    2151. 

  2151. 

  2152.         return {
    2153. 

  2153.             type: Syntax.VariableDeclaration,
    2154. 

  2154.             declarations: declarations,
    2155. 

  2155.             kind: kind
    2156. 

  2156.         };
    2157. 

  2157.     }
    2158. 

  2158. 

  2159.     // 12.3 Empty Statement
    2160. 

  2160. 

  2161.     function parseEmptyStatement() {
    2162. 

  2162.         expect(';');
    2163. 

  2163. 

  2164.         return {
    2165. 

  2165.             type: Syntax.EmptyStatement
    2166. 

  2166.         };
    2167. 

  2167.     }
    2168. 

  2168. 

  2169.     // 12.4 Expression Statement
    2170. 

  2170. 

  2171.     function parseExpressionStatement() {
    2172. 

  2172.         var expr = parseExpression();
    2173. 

  2173. 

  2174.         consumeSemicolon();
    2175. 

  2175. 

  2176.         return {
    2177. 

  2177.             type: Syntax.ExpressionStatement,
    2178. 

  2178.             expression: expr
    2179. 

  2179.         };
    2180. 

  2180.     }
    2181. 

  2181. 

  2182.     // 12.5 If statement
    2183. 

  2183. 

  2184.     function parseIfStatement() {
    2185. 

  2185.         var test, consequent, alternate;
    2186. 

  2186. 

  2187.         expectKeyword('if');
    2188. 

  2188. 

  2189.         expect('(');
    2190. 

  2190. 

  2191.         test = parseExpression();
    2192. 

  2192. 

  2193.         expect(')');
    2194. 

  2194. 

  2195.         consequent = parseStatement();
    2196. 

  2196. 

  2197.         if (matchKeyword('else')) {
    2198. 

  2198.             lex();
    2199. 

  2199.             alternate = parseStatement();
    2200. 

  2200.         } else {
    2201. 

  2201.             alternate = null;
    2202. 

  2202.         }
    2203. 

  2203. 

  2204.         return {
    2205. 

  2205.             type: Syntax.IfStatement,
    2206. 

  2206.             test: test,
    2207. 

  2207.             consequent: consequent,
    2208. 

  2208.             alternate: alternate
    2209. 

  2209.         };
    2210. 

  2210.     }
    2211. 

  2211. 

  2212.     // 12.6 Iteration Statements
    2213. 

  2213. 

  2214.     function parseDoWhileStatement() {
    2215. 

  2215.         var body, test, oldInIteration;
    2216. 

  2216. 

  2217.         expectKeyword('do');
    2218. 

  2218. 

  2219.         oldInIteration = state.inIteration;
    2220. 

  2220.         state.inIteration = true;
    2221. 

  2221. 

  2222.         body = parseStatement();
    2223. 

  2223. 

  2224.         state.inIteration = oldInIteration;
    2225. 

  2225. 

  2226.         expectKeyword('while');
    2227. 

  2227. 

  2228.         expect('(');
    2229. 

  2229. 

  2230.         test = parseExpression();
    2231. 

  2231. 

  2232.         expect(')');
    2233. 

  2233. 

  2234.         if (match(';')) {
    2235. 

  2235.             lex();
    2236. 

  2236.         }
    2237. 

  2237. 

  2238.         return {
    2239. 

  2239.             type: Syntax.DoWhileStatement,
    2240. 

  2240.             body: body,
    2241. 

  2241.             test: test
    2242. 

  2242.         };
    2243. 

  2243.     }
    2244. 

  2244. 

  2245.     function parseWhileStatement() {
    2246. 

  2246.         var test, body, oldInIteration;
    2247. 

  2247. 

  2248.         expectKeyword('while');
    2249. 

  2249. 

  2250.         expect('(');
    2251. 

  2251. 

  2252.         test = parseExpression();
    2253. 

  2253. 

  2254.         expect(')');
    2255. 

  2255. 

  2256.         oldInIteration = state.inIteration;
    2257. 

  2257.         state.inIteration = true;
    2258. 

  2258. 

  2259.         body = parseStatement();
    2260. 

  2260. 

  2261.         state.inIteration = oldInIteration;
    2262. 

  2262. 

  2263.         return {
    2264. 

  2264.             type: Syntax.WhileStatement,
    2265. 

  2265.             test: test,
    2266. 

  2266.             body: body
    2267. 

  2267.         };
    2268. 

  2268.     }
    2269. 

  2269. 

  2270.     function parseForVariableDeclaration() {
    2271. 

  2271.         var token = lex();
    2272. 

  2272. 

  2273.         return {
    2274. 

  2274.             type: Syntax.VariableDeclaration,
    2275. 

  2275.             declarations: parseVariableDeclarationList(),
    2276. 

  2276.             kind: token.value
    2277. 

  2277.         };
    2278. 

  2278.     }
    2279. 

  2279. 

  2280.     function parseForStatement() {
    2281. 

  2281.         var init, test, update, left, right, body, oldInIteration;
    2282. 

  2282. 

  2283.         init = test = update = null;
    2284. 

  2284. 

  2285.         expectKeyword('for');
    2286. 

  2286. 

  2287.         expect('(');
    2288. 

  2288. 

  2289.         if (match(';')) {
    2290. 

  2290.             lex();
    2291. 

  2291.         } else {
    2292. 

  2292.             if (matchKeyword('var') || matchKeyword('let')) {
    2293. 

  2293.                 state.allowIn = false;
    2294. 

  2294.                 init = parseForVariableDeclaration();
    2295. 

  2295.                 state.allowIn = true;
    2296. 

  2296. 

  2297.                 if (init.declarations.length === 1 && matchKeyword('in')) {
    2298. 

  2298.                     lex();
    2299. 

  2299.                     left = init;
    2300. 

  2300.                     right = parseExpression();
    2301. 

  2301.                     init = null;
    2302. 

  2302.                 }
    2303. 

  2303.             } else {
    2304. 

  2304.                 state.allowIn = false;
    2305. 

  2305.                 init = parseExpression();
    2306. 

  2306.                 state.allowIn = true;
    2307. 

  2307. 

  2308.                 if (matchKeyword('in')) {
    2309. 

  2309.                     // LeftHandSideExpression
    2310. 

  2310.                     if (!isLeftHandSide(init)) {
    2311. 

  2311.                         throwError({}, Messages.InvalidLHSInForIn);
    2312. 

  2312.                     }
    2313. 

  2313. 

  2314.                     lex();
    2315. 

  2315.                     left = init;
    2316. 

  2316.                     right = parseExpression();
    2317. 

  2317.                     init = null;
    2318. 

  2318.                 }
    2319. 

  2319.             }
    2320. 

  2320. 

  2321.             if (typeof left === 'undefined') {
    2322. 

  2322.                 expect(';');
    2323. 

  2323.             }
    2324. 

  2324.         }
    2325. 

  2325. 

  2326.         if (typeof left === 'undefined') {
    2327. 

  2327. 

  2328.             if (!match(';')) {
    2329. 

  2329.                 test = parseExpression();
    2330. 

  2330.             }
    2331. 

  2331.             expect(';');
    2332. 

  2332. 

  2333.             if (!match(')')) {
    2334. 

  2334.                 update = parseExpression();
    2335. 

  2335.             }
    2336. 

  2336.         }
    2337. 

  2337. 

  2338.         expect(')');
    2339. 

  2339. 

  2340.         oldInIteration = state.inIteration;
    2341. 

  2341.         state.inIteration = true;
    2342. 

  2342. 

  2343.         body = parseStatement();
    2344. 

  2344. 

  2345.         state.inIteration = oldInIteration;
    2346. 

  2346. 

  2347.         if (typeof left === 'undefined') {
    2348. 

  2348.             return {
    2349. 

  2349.                 type: Syntax.ForStatement,
    2350. 

  2350.                 init: init,
    2351. 

  2351.                 test: test,
    2352. 

  2352.                 update: update,
    2353. 

  2353.                 body: body
    2354. 

  2354.             };
    2355. 

  2355.         }
    2356. 

  2356. 

  2357.         return {
    2358. 

  2358.             type: Syntax.ForInStatement,
    2359. 

  2359.             left: left,
    2360. 

  2360.             right: right,
    2361. 

  2361.             body: body,
    2362. 

  2362.             each: false
    2363. 

  2363.         };
    2364. 

  2364.     }
    2365. 

  2365. 

  2366.     // 12.7 The continue statement
    2367. 

  2367. 

  2368.     function parseContinueStatement() {
    2369. 

  2369.         var token, label = null;
    2370. 

  2370. 

  2371.         expectKeyword('continue');
    2372. 

  2372. 

  2373.         // Optimize the most common form: 'continue;'.
    2374. 

  2374.         if (source[index] === ';') {
    2375. 

  2375.             lex();
    2376. 

  2376. 

  2377.             if (!state.inIteration) {
    2378. 

  2378.                 throwError({}, Messages.IllegalContinue);
    2379. 

  2379.             }
    2380. 

  2380. 

  2381.             return {
    2382. 

  2382.                 type: Syntax.ContinueStatement,
    2383. 

  2383.                 label: null
    2384. 

  2384.             };
    2385. 

  2385.         }
    2386. 

  2386. 

  2387.         if (peekLineTerminator()) {
    2388. 

  2388.             if (!state.inIteration) {
    2389. 

  2389.                 throwError({}, Messages.IllegalContinue);
    2390. 

  2390.             }
    2391. 

  2391. 

  2392.             return {
    2393. 

  2393.                 type: Syntax.ContinueStatement,
    2394. 

  2394.                 label: null
    2395. 

  2395.             };
    2396. 

  2396.         }
    2397. 

  2397. 

  2398.         token = lookahead();
    2399. 

  2399.         if (token.type === Token.Identifier) {
    2400. 

  2400.             label = parseVariableIdentifier();
    2401. 

  2401. 

  2402.             if (!Object.prototype.hasOwnProperty.call(state.labelSet, label.name)) {
    2403. 

  2403.                 throwError({}, Messages.UnknownLabel, label.name);
    2404. 

  2404.             }
    2405. 

  2405.         }
    2406. 

  2406. 

  2407.         consumeSemicolon();
    2408. 

  2408. 

  2409.         if (label === null && !state.inIteration) {
    2410. 

  2410.             throwError({}, Messages.IllegalContinue);
    2411. 

  2411.         }
    2412. 

  2412. 

  2413.         return {
    2414. 

  2414.             type: Syntax.ContinueStatement,
    2415. 

  2415.             label: label
    2416. 

  2416.         };
    2417. 

  2417.     }
    2418. 

  2418. 

  2419.     // 12.8 The break statement
    2420. 

  2420. 

  2421.     function parseBreakStatement() {
    2422. 

  2422.         var token, label = null;
    2423. 

  2423. 

  2424.         expectKeyword('break');
    2425. 

  2425. 

  2426.         // Optimize the most common form: 'break;'.
    2427. 

  2427.         if (source[index] === ';') {
    2428. 

  2428.             lex();
    2429. 

  2429. 

  2430.             if (!(state.inIteration || state.inSwitch)) {
    2431. 

  2431.                 throwError({}, Messages.IllegalBreak);
    2432. 

  2432.             }
    2433. 

  2433. 

  2434.             return {
    2435. 

  2435.                 type: Syntax.BreakStatement,
    2436. 

  2436.                 label: null
    2437. 

  2437.             };
    2438. 

  2438.         }
    2439. 

  2439. 

  2440.         if (peekLineTerminator()) {
    2441. 

  2441.             if (!(state.inIteration || state.inSwitch)) {
    2442. 

  2442.                 throwError({}, Messages.IllegalBreak);
    2443. 

  2443.             }
    2444. 

  2444. 

  2445.             return {
    2446. 

  2446.                 type: Syntax.BreakStatement,
    2447. 

  2447.                 label: null
    2448. 

  2448.             };
    2449. 

  2449.         }
    2450. 

  2450. 

  2451.         token = lookahead();
    2452. 

  2452.         if (token.type === Token.Identifier) {
    2453. 

  2453.             label = parseVariableIdentifier();
    2454. 

  2454. 

  2455.             if (!Object.prototype.hasOwnProperty.call(state.labelSet, label.name)) {
    2456. 

  2456.                 throwError({}, Messages.UnknownLabel, label.name);
    2457. 

  2457.             }
    2458. 

  2458.         }
    2459. 

  2459. 

  2460.         consumeSemicolon();
    2461. 

  2461. 

  2462.         if (label === null && !(state.inIteration || state.inSwitch)) {
    2463. 

  2463.             throwError({}, Messages.IllegalBreak);
    2464. 

  2464.         }
    2465. 

  2465. 

  2466.         return {
    2467. 

  2467.             type: Syntax.BreakStatement,
    2468. 

  2468.             label: label
    2469. 

  2469.         };
    2470. 

  2470.     }
    2471. 

  2471. 

  2472.     // 12.9 The return statement
    2473. 

  2473. 

  2474.     function parseReturnStatement() {
    2475. 

  2475.         var token, argument = null;
    2476. 

  2476. 

  2477.         expectKeyword('return');
    2478. 

  2478. 

  2479.         if (!state.inFunctionBody) {
    2480. 

  2480.             throwErrorTolerant({}, Messages.IllegalReturn);
    2481. 

  2481.         }
    2482. 

  2482. 

  2483.         // 'return' followed by a space and an identifier is very common.
    2484. 

  2484.         if (source[index] === ' ') {
    2485. 

  2485.             if (isIdentifierStart(source[index + 1])) {
    2486. 

  2486.                 argument = parseExpression();
    2487. 

  2487.                 consumeSemicolon();
    2488. 

  2488.                 return {
    2489. 

  2489.                     type: Syntax.ReturnStatement,
    2490. 

  2490.                     argument: argument
    2491. 

  2491.                 };
    2492. 

  2492.             }
    2493. 

  2493.         }
    2494. 

  2494. 

  2495.         if (peekLineTerminator()) {
    2496. 

  2496.             return {
    2497. 

  2497.                 type: Syntax.ReturnStatement,
    2498. 

  2498.                 argument: null
    2499. 

  2499.             };
    2500. 

  2500.         }
    2501. 

  2501. 

  2502.         if (!match(';')) {
    2503. 

  2503.             token = lookahead();
    2504. 

  2504.             if (!match('}') && token.type !== Token.EOF) {
    2505. 

  2505.                 argument = parseExpression();
    2506. 

  2506.             }
    2507. 

  2507.         }
    2508. 

  2508. 

  2509.         consumeSemicolon();
    2510. 

  2510. 

  2511.         return {
    2512. 

  2512.             type: Syntax.ReturnStatement,
    2513. 

  2513.             argument: argument
    2514. 

  2514.         };
    2515. 

  2515.     }
    2516. 

  2516. 

  2517.     // 12.10 The with statement
    2518. 

  2518. 

  2519.     function parseWithStatement() {
    2520. 

  2520.         var object, body;
    2521. 

  2521. 

  2522.         if (strict) {
    2523. 

  2523.             throwErrorTolerant({}, Messages.StrictModeWith);
    2524. 

  2524.         }
    2525. 

  2525. 

  2526.         expectKeyword('with');
    2527. 

  2527. 

  2528.         expect('(');
    2529. 

  2529. 

  2530.         object = parseExpression();
    2531. 

  2531. 

  2532.         expect(')');
    2533. 

  2533. 

  2534.         body = parseStatement();
    2535. 

  2535. 

  2536.         return {
    2537. 

  2537.             type: Syntax.WithStatement,
    2538. 

  2538.             object: object,
    2539. 

  2539.             body: body
    2540. 

  2540.         };
    2541. 

  2541.     }
    2542. 

  2542. 

  2543.     // 12.10 The swith statement
    2544. 

  2544. 

  2545.     function parseSwitchCase() {
    2546. 

  2546.         var test,
    2547. 

  2547.             consequent = [],
    2548. 

  2548.             statement;
    2549. 

  2549. 

  2550.         if (matchKeyword('default')) {
    2551. 

  2551.             lex();
    2552. 

  2552.             test = null;
    2553. 

  2553.         } else {
    2554. 

  2554.             expectKeyword('case');
    2555. 

  2555.             test = parseExpression();
    2556. 

  2556.         }
    2557. 

  2557.         expect(':');
    2558. 

  2558. 

  2559.         while (index < length) {
    2560. 

  2560.             if (match('}') || matchKeyword('default') || matchKeyword('case')) {
    2561. 

  2561.                 break;
    2562. 

  2562.             }
    2563. 

  2563.             statement = parseStatement();
    2564. 

  2564.             if (typeof statement === 'undefined') {
    2565. 

  2565.                 break;
    2566. 

  2566.             }
    2567. 

  2567.             consequent.push(statement);
    2568. 

  2568.         }
    2569. 

  2569. 

  2570.         return {
    2571. 

  2571.             type: Syntax.SwitchCase,
    2572. 

  2572.             test: test,
    2573. 

  2573.             consequent: consequent
    2574. 

  2574.         };
    2575. 

  2575.     }
    2576. 

  2576. 

  2577.     function parseSwitchStatement() {
    2578. 

  2578.         var discriminant, cases, clause, oldInSwitch, defaultFound;
    2579. 

  2579. 

  2580.         expectKeyword('switch');
    2581. 

  2581. 

  2582.         expect('(');
    2583. 

  2583. 

  2584.         discriminant = parseExpression();
    2585. 

  2585. 

  2586.         expect(')');
    2587. 

  2587. 

  2588.         expect('{');
    2589. 

  2589. 

  2590.         if (match('}')) {
    2591. 

  2591.             lex();
    2592. 

  2592.             return {
    2593. 

  2593.                 type: Syntax.SwitchStatement,
    2594. 

  2594.                 discriminant: discriminant
    2595. 

  2595.             };
    2596. 

  2596.         }
    2597. 

  2597. 

  2598.         cases = [];
    2599. 

  2599. 

  2600.         oldInSwitch = state.inSwitch;
    2601. 

  2601.         state.inSwitch = true;
    2602. 

  2602.         defaultFound = false;
    2603. 

  2603. 

  2604.         while (index < length) {
    2605. 

  2605.             if (match('}')) {
    2606. 

  2606.                 break;
    2607. 

  2607.             }
    2608. 

  2608.             clause = parseSwitchCase();
    2609. 

  2609.             if (clause.test === null) {
    2610. 

  2610.                 if (defaultFound) {
    2611. 

  2611.                     throwError({}, Messages.MultipleDefaultsInSwitch);
    2612. 

  2612.                 }
    2613. 

  2613.                 defaultFound = true;
    2614. 

  2614.             }
    2615. 

  2615.             cases.push(clause);
    2616. 

  2616.         }
    2617. 

  2617. 

  2618.         state.inSwitch = oldInSwitch;
    2619. 

  2619. 

  2620.         expect('}');
    2621. 

  2621. 

  2622.         return {
    2623. 

  2623.             type: Syntax.SwitchStatement,
    2624. 

  2624.             discriminant: discriminant,
    2625. 

  2625.             cases: cases
    2626. 

  2626.         };
    2627. 

  2627.     }
    2628. 

  2628. 

  2629.     // 12.13 The throw statement
    2630. 

  2630. 

  2631.     function parseThrowStatement() {
    2632. 

  2632.         var argument;
    2633. 

  2633. 

  2634.         expectKeyword('throw');
    2635. 

  2635. 

  2636.         if (peekLineTerminator()) {
    2637. 

  2637.             throwError({}, Messages.NewlineAfterThrow);
    2638. 

  2638.         }
    2639. 

  2639. 

  2640.         argument = parseExpression();
    2641. 

  2641. 

  2642.         consumeSemicolon();
    2643. 

  2643. 

  2644.         return {
    2645. 

  2645.             type: Syntax.ThrowStatement,
    2646. 

  2646.             argument: argument
    2647. 

  2647.         };
    2648. 

  2648.     }
    2649. 

  2649. 

  2650.     // 12.14 The try statement
    2651. 

  2651. 

  2652.     function parseCatchClause() {
    2653. 

  2653.         var param;
    2654. 

  2654. 

  2655.         expectKeyword('catch');
    2656. 

  2656. 

  2657.         expect('(');
    2658. 

  2658.         if (!match(')')) {
    2659. 

  2659.             param = parseExpression();
    2660. 

  2660.             // 12.14.1
    2661. 

  2661.             if (strict && param.type === Syntax.Identifier && isRestrictedWord(param.name)) {
    2662. 

  2662.                 throwErrorTolerant({}, Messages.StrictCatchVariable);
    2663. 

  2663.             }
    2664. 

  2664.         }
    2665. 

  2665.         expect(')');
    2666. 

  2666. 

  2667.         return {
    2668. 

  2668.             type: Syntax.CatchClause,
    2669. 

  2669.             param: param,
    2670. 

  2670.             body: parseBlock()
    2671. 

  2671.         };
    2672. 

  2672.     }
    2673. 

  2673. 

  2674.     function parseTryStatement() {
    2675. 

  2675.         var block, handlers = [], finalizer = null;
    2676. 

  2676. 

  2677.         expectKeyword('try');
    2678. 

  2678. 

  2679.         block = parseBlock();
    2680. 

  2680. 

  2681.         if (matchKeyword('catch')) {
    2682. 

  2682.             handlers.push(parseCatchClause());
    2683. 

  2683.         }
    2684. 

  2684. 

  2685.         if (matchKeyword('finally')) {
    2686. 

  2686.             lex();
    2687. 

  2687.             finalizer = parseBlock();
    2688. 

  2688.         }
    2689. 

  2689. 

  2690.         if (handlers.length === 0 && !finalizer) {
    2691. 

  2691.             throwError({}, Messages.NoCatchOrFinally);
    2692. 

  2692.         }
    2693. 

  2693. 

  2694.         return {
    2695. 

  2695.             type: Syntax.TryStatement,
    2696. 

  2696.             block: block,
    2697. 

  2697.             guardedHandlers: [],
    2698. 

  2698.             handlers: handlers,
    2699. 

  2699.             finalizer: finalizer
    2700. 

  2700.         };
    2701. 

  2701.     }
    2702. 

  2702. 

  2703.     // 12.15 The debugger statement
    2704. 

  2704. 

  2705.     function parseDebuggerStatement() {
    2706. 

  2706.         expectKeyword('debugger');
    2707. 

  2707. 

  2708.         consumeSemicolon();
    2709. 

  2709. 

  2710.         return {
    2711. 

  2711.             type: Syntax.DebuggerStatement
    2712. 

  2712.         };
    2713. 

  2713.     }
    2714. 

  2714. 

  2715.     // 12 Statements
    2716. 

  2716. 

  2717.     function parseStatement() {
    2718. 

  2718.         var token = lookahead(),
    2719. 

  2719.             expr,
    2720. 

  2720.             labeledBody;
    2721. 

  2721. 

  2722.         if (token.type === Token.EOF) {
    2723. 

  2723.             throwUnexpected(token);
    2724. 

  2724.         }
    2725. 

  2725. 

  2726.         if (token.type === Token.Punctuator) {
    2727. 

  2727.             switch (token.value) {
    2728. 

  2728.             case ';':
    2729. 

  2729.                 return parseEmptyStatement();
    2730. 

  2730.             case '{':
    2731. 

  2731.                 return parseBlock();
    2732. 

  2732.             case '(':
    2733. 

  2733.                 return parseExpressionStatement();
    2734. 

  2734.             default:
    2735. 

  2735.                 break;
    2736. 

  2736.             }
    2737. 

  2737.         }
    2738. 

  2738. 

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

  2740.             switch (token.value) {
    2741. 

  2741.             case 'break':
    2742. 

  2742.                 return parseBreakStatement();
    2743. 

  2743.             case 'continue':
    2744. 

  2744.                 return parseContinueStatement();
    2745. 

  2745.             case 'debugger':
    2746. 

  2746.                 return parseDebuggerStatement();
    2747. 

  2747.             case 'do':
    2748. 

  2748.                 return parseDoWhileStatement();
    2749. 

  2749.             case 'for':
    2750. 

  2750.                 return parseForStatement();
    2751. 

  2751.             case 'function':
    2752. 

  2752.                 return parseFunctionDeclaration();
    2753. 

  2753.             case 'if':
    2754. 

  2754.                 return parseIfStatement();
    2755. 

  2755.             case 'return':
    2756. 

  2756.                 return parseReturnStatement();
    2757. 

  2757.             case 'switch':
    2758. 

  2758.                 return parseSwitchStatement();
    2759. 

  2759.             case 'throw':
    2760. 

  2760.                 return parseThrowStatement();
    2761. 

  2761.             case 'try':
    2762. 

  2762.                 return parseTryStatement();
    2763. 

  2763.             case 'var':
    2764. 

  2764.                 return parseVariableStatement();
    2765. 

  2765.             case 'while':
    2766. 

  2766.                 return parseWhileStatement();
    2767. 

  2767.             case 'with':
    2768. 

  2768.                 return parseWithStatement();
    2769. 

  2769.             default:
    2770. 

  2770.                 break;
    2771. 

  2771.             }
    2772. 

  2772.         }
    2773. 

  2773. 

  2774.         expr = parseExpression();
    2775. 

  2775. 

  2776.         // 12.12 Labelled Statements
    2777. 

  2777.         if ((expr.type === Syntax.Identifier) && match(':')) {
    2778. 

  2778.             lex();
    2779. 

  2779. 

  2780.             if (Object.prototype.hasOwnProperty.call(state.labelSet, expr.name)) {
    2781. 

  2781.                 throwError({}, Messages.Redeclaration, 'Label', expr.name);
    2782. 

  2782.             }
    2783. 

  2783. 

  2784.             state.labelSet[expr.name] = true;
    2785. 

  2785.             labeledBody = parseStatement();
    2786. 

  2786.             delete state.labelSet[expr.name];
    2787. 

  2787. 

  2788.             return {
    2789. 

  2789.                 type: Syntax.LabeledStatement,
    2790. 

  2790.                 label: expr,
    2791. 

  2791.                 body: labeledBody
    2792. 

  2792.             };
    2793. 

  2793.         }
    2794. 

  2794. 

  2795.         consumeSemicolon();
    2796. 

  2796. 

  2797.         return {
    2798. 

  2798.             type: Syntax.ExpressionStatement,
    2799. 

  2799.             expression: expr
    2800. 

  2800.         };
    2801. 

  2801.     }
    2802. 

  2802. 

  2803.     // 13 Function Definition
    2804. 

  2804. 

  2805.     function parseFunctionSourceElements() {
    2806. 

  2806.         var sourceElement, sourceElements = [], token, directive, firstRestricted,
    2807. 

  2807.             oldLabelSet, oldInIteration, oldInSwitch, oldInFunctionBody;
    2808. 

  2808. 

  2809.         expect('{');
    2810. 

  2810. 

  2811.         while (index < length) {
    2812. 

  2812.             token = lookahead();
    2813. 

  2813.             if (token.type !== Token.StringLiteral) {
    2814. 

  2814.                 break;
    2815. 

  2815.             }
    2816. 

  2816. 

  2817.             sourceElement = parseSourceElement();
    2818. 

  2818.             sourceElements.push(sourceElement);
    2819. 

  2819.             if (sourceElement.expression.type !== Syntax.Literal) {
    2820. 

  2820.                 // this is not directive
    2821. 

  2821.                 break;
    2822. 

  2822.             }
    2823. 

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

  2824.             if (directive === 'use strict') {
    2825. 

  2825.                 strict = true;
    2826. 

  2826.                 if (firstRestricted) {
    2827. 

  2827.                     throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral);
    2828. 

  2828.                 }
    2829. 

  2829.             } else {
    2830. 

  2830.                 if (!firstRestricted && token.octal) {
    2831. 

  2831.                     firstRestricted = token;
    2832. 

  2832.                 }
    2833. 

  2833.             }
    2834. 

  2834.         }
    2835. 

  2835. 

  2836.         oldLabelSet = state.labelSet;
    2837. 

  2837.         oldInIteration = state.inIteration;
    2838. 

  2838.         oldInSwitch = state.inSwitch;
    2839. 

  2839.         oldInFunctionBody = state.inFunctionBody;
    2840. 

  2840. 

  2841.         state.labelSet = {};
    2842. 

  2842.         state.inIteration = false;
    2843. 

  2843.         state.inSwitch = false;
    2844. 

  2844.         state.inFunctionBody = true;
    2845. 

  2845. 

  2846.         while (index < length) {
    2847. 

  2847.             if (match('}')) {
    2848. 

  2848.                 break;
    2849. 

  2849.             }
    2850. 

  2850.             sourceElement = parseSourceElement();
    2851. 

  2851.             if (typeof sourceElement === 'undefined') {
    2852. 

  2852.                 break;
    2853. 

  2853.             }
    2854. 

  2854.             sourceElements.push(sourceElement);
    2855. 

  2855.         }
    2856. 

  2856. 

  2857.         expect('}');
    2858. 

  2858. 

  2859.         state.labelSet = oldLabelSet;
    2860. 

  2860.         state.inIteration = oldInIteration;
    2861. 

  2861.         state.inSwitch = oldInSwitch;
    2862. 

  2862.         state.inFunctionBody = oldInFunctionBody;
    2863. 

  2863. 

  2864.         return {
    2865. 

  2865.             type: Syntax.BlockStatement,
    2866. 

  2866.             body: sourceElements
    2867. 

  2867.         };
    2868. 

  2868.     }
    2869. 

  2869. 

  2870.     function parseFunctionDeclaration() {
    2871. 

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

  2872. 

  2873.         expectKeyword('function');
    2874. 

  2874.         token = lookahead();
    2875. 

  2875.         id = parseVariableIdentifier();
    2876. 

  2876.         if (strict) {
    2877. 

  2877.             if (isRestrictedWord(token.value)) {
    2878. 

  2878.                 throwErrorTolerant(token, Messages.StrictFunctionName);
    2879. 

  2879.             }
    2880. 

  2880.         } else {
    2881. 

  2881.             if (isRestrictedWord(token.value)) {
    2882. 

  2882.                 firstRestricted = token;
    2883. 

  2883.                 message = Messages.StrictFunctionName;
    2884. 

  2884.             } else if (isStrictModeReservedWord(token.value)) {
    2885. 

  2885.                 firstRestricted = token;
    2886. 

  2886.                 message = Messages.StrictReservedWord;
    2887. 

  2887.             }
    2888. 

  2888.         }
    2889. 

  2889. 

  2890.         expect('(');
    2891. 

  2891. 

  2892.         if (!match(')')) {
    2893. 

  2893.             paramSet = {};
    2894. 

  2894.             while (index < length) {
    2895. 

  2895.                 token = lookahead();
    2896. 

  2896.                 param = parseVariableIdentifier();
    2897. 

  2897.                 if (strict) {
    2898. 

  2898.                     if (isRestrictedWord(token.value)) {
    2899. 

  2899.                         stricted = token;
    2900. 

  2900.                         message = Messages.StrictParamName;
    2901. 

  2901.                     }
    2902. 

  2902.                     if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {
    2903. 

  2903.                         stricted = token;
    2904. 

  2904.                         message = Messages.StrictParamDupe;
    2905. 

  2905.                     }
    2906. 

  2906.                 } else if (!firstRestricted) {
    2907. 

  2907.                     if (isRestrictedWord(token.value)) {
    2908. 

  2908.                         firstRestricted = token;
    2909. 

  2909.                         message = Messages.StrictParamName;
    2910. 

  2910.                     } else if (isStrictModeReservedWord(token.value)) {
    2911. 

  2911.                         firstRestricted = token;
    2912. 

  2912.                         message = Messages.StrictReservedWord;
    2913. 

  2913.                     } else if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {
    2914. 

  2914.                         firstRestricted = token;
    2915. 

  2915.                         message = Messages.StrictParamDupe;
    2916. 

  2916.                     }
    2917. 

  2917.                 }
    2918. 

  2918.                 params.push(param);
    2919. 

  2919.                 paramSet[param.name] = true;
    2920. 

  2920.                 if (match(')')) {
    2921. 

  2921.                     break;
    2922. 

  2922.                 }
    2923. 

  2923.                 expect(',');
    2924. 

  2924.             }
    2925. 

  2925.         }
    2926. 

  2926. 

  2927.         expect(')');
    2928. 

  2928. 

  2929.         previousStrict = strict;
    2930. 

  2930.         body = parseFunctionSourceElements();
    2931. 

  2931.         if (strict && firstRestricted) {
    2932. 

  2932.             throwError(firstRestricted, message);
    2933. 

  2933.         }
    2934. 

  2934.         if (strict && stricted) {
    2935. 

  2935.             throwErrorTolerant(stricted, message);
    2936. 

  2936.         }
    2937. 

  2937.         strict = previousStrict;
    2938. 

  2938. 

  2939.         return {
    2940. 

  2940.             type: Syntax.FunctionDeclaration,
    2941. 

  2941.             id: id,
    2942. 

  2942.             params: params,
    2943. 

  2943.             defaults: [],
    2944. 

  2944.             body: body,
    2945. 

  2945.             rest: null,
    2946. 

  2946.             generator: false,
    2947. 

  2947.             expression: false
    2948. 

  2948.         };
    2949. 

  2949.     }
    2950. 

  2950. 

  2951.     function parseFunctionExpression() {
    2952. 

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

  2953. 

  2954.         expectKeyword('function');
    2955. 

  2955. 

  2956.         if (!match('(')) {
    2957. 

  2957.             token = lookahead();
    2958. 

  2958.             id = parseVariableIdentifier();
    2959. 

  2959.             if (strict) {
    2960. 

  2960.                 if (isRestrictedWord(token.value)) {
    2961. 

  2961.                     throwErrorTolerant(token, Messages.StrictFunctionName);
    2962. 

  2962.                 }
    2963. 

  2963.             } else {
    2964. 

  2964.                 if (isRestrictedWord(token.value)) {
    2965. 

  2965.                     firstRestricted = token;
    2966. 

  2966.                     message = Messages.StrictFunctionName;
    2967. 

  2967.                 } else if (isStrictModeReservedWord(token.value)) {
    2968. 

  2968.                     firstRestricted = token;
    2969. 

  2969.                     message = Messages.StrictReservedWord;
    2970. 

  2970.                 }
    2971. 

  2971.             }
    2972. 

  2972.         }
    2973. 

  2973. 

  2974.         expect('(');
    2975. 

  2975. 

  2976.         if (!match(')')) {
    2977. 

  2977.             paramSet = {};
    2978. 

  2978.             while (index < length) {
    2979. 

  2979.                 token = lookahead();
    2980. 

  2980.                 param = parseVariableIdentifier();
    2981. 

  2981.                 if (strict) {
    2982. 

  2982.                     if (isRestrictedWord(token.value)) {
    2983. 

  2983.                         stricted = token;
    2984. 

  2984.                         message = Messages.StrictParamName;
    2985. 

  2985.                     }
    2986. 

  2986.                     if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {
    2987. 

  2987.                         stricted = token;
    2988. 

  2988.                         message = Messages.StrictParamDupe;
    2989. 

  2989.                     }
    2990. 

  2990.                 } else if (!firstRestricted) {
    2991. 

  2991.                     if (isRestrictedWord(token.value)) {
    2992. 

  2992.                         firstRestricted = token;
    2993. 

  2993.                         message = Messages.StrictParamName;
    2994. 

  2994.                     } else if (isStrictModeReservedWord(token.value)) {
    2995. 

  2995.                         firstRestricted = token;
    2996. 

  2996.                         message = Messages.StrictReservedWord;
    2997. 

  2997.                     } else if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {
    2998. 

  2998.                         firstRestricted = token;
    2999. 

  2999.                         message = Messages.StrictParamDupe;
    3000. 

  3000.                     }
    3001. 

  3001.                 }
    3002. 

  3002.                 params.push(param);
    3003. 

  3003.                 paramSet[param.name] = true;
    3004. 

  3004.                 if (match(')')) {
    3005. 

  3005.                     break;
    3006. 

  3006.                 }
    3007. 

  3007.                 expect(',');
    3008. 

  3008.             }
    3009. 

  3009.         }
    3010. 

  3010. 

  3011.         expect(')');
    3012. 

  3012. 

  3013.         previousStrict = strict;
    3014. 

  3014.         body = parseFunctionSourceElements();
    3015. 

  3015.         if (strict && firstRestricted) {
    3016. 

  3016.             throwError(firstRestricted, message);
    3017. 

  3017.         }
    3018. 

  3018.         if (strict && stricted) {
    3019. 

  3019.             throwErrorTolerant(stricted, message);
    3020. 

  3020.         }
    3021. 

  3021.         strict = previousStrict;
    3022. 

  3022. 

  3023.         return {
    3024. 

  3024.             type: Syntax.FunctionExpression,
    3025. 

  3025.             id: id,
    3026. 

  3026.             params: params,
    3027. 

  3027.             defaults: [],
    3028. 

  3028.             body: body,
    3029. 

  3029.             rest: null,
    3030. 

  3030.             generator: false,
    3031. 

  3031.             expression: false
    3032. 

  3032.         };
    3033. 

  3033.     }
    3034. 

  3034. 

  3035.     // 14 Program
    3036. 

  3036. 

  3037.     function parseSourceElement() {
    3038. 

  3038.         var token = lookahead();
    3039. 

  3039. 

  3040.         if (token.type === Token.Keyword) {
    3041. 

  3041.             switch (token.value) {
    3042. 

  3042.             case 'const':
    3043. 

  3043.             case 'let':
    3044. 

  3044.                 return parseConstLetDeclaration(token.value);
    3045. 

  3045.             case 'function':
    3046. 

  3046.                 return parseFunctionDeclaration();
    3047. 

  3047.             default:
    3048. 

  3048.                 return parseStatement();
    3049. 

  3049.             }
    3050. 

  3050.         }
    3051. 

  3051. 

  3052.         if (token.type !== Token.EOF) {
    3053. 

  3053.             return parseStatement();
    3054. 

  3054.         }
    3055. 

  3055.     }
    3056. 

  3056. 

  3057.     function parseSourceElements() {
    3058. 

  3058.         var sourceElement, sourceElements = [], token, directive, firstRestricted;
    3059. 

  3059. 

  3060.         while (index < length) {
    3061. 

  3061.             token = lookahead();
    3062. 

  3062.             if (token.type !== Token.StringLiteral) {
    3063. 

  3063.                 break;
    3064. 

  3064.             }
    3065. 

  3065. 

  3066.             sourceElement = parseSourceElement();
    3067. 

  3067.             sourceElements.push(sourceElement);
    3068. 

  3068.             if (sourceElement.expression.type !== Syntax.Literal) {
    3069. 

  3069.                 // this is not directive
    3070. 

  3070.                 break;
    3071. 

  3071.             }
    3072. 

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

  3073.             if (directive === 'use strict') {
    3074. 

  3074.                 strict = true;
    3075. 

  3075.                 if (firstRestricted) {
    3076. 

  3076.                     throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral);
    3077. 

  3077.                 }
    3078. 

  3078.             } else {
    3079. 

  3079.                 if (!firstRestricted && token.octal) {
    3080. 

  3080.                     firstRestricted = token;
    3081. 

  3081.                 }
    3082. 

  3082.             }
    3083. 

  3083.         }
    3084. 

  3084. 

  3085.         while (index < length) {
    3086. 

  3086.             sourceElement = parseSourceElement();
    3087. 

  3087.             if (typeof sourceElement === 'undefined') {
    3088. 

  3088.                 break;
    3089. 

  3089.             }
    3090. 

  3090.             sourceElements.push(sourceElement);
    3091. 

  3091.         }
    3092. 

  3092.         return sourceElements;
    3093. 

  3093.     }
    3094. 

  3094. 

  3095.     function parseProgram() {
    3096. 

  3096.         var program;
    3097. 

  3097.         strict = false;
    3098. 

  3098.         program = {
    3099. 

  3099.             type: Syntax.Program,
    3100. 

  3100.             body: parseSourceElements()
    3101. 

  3101.         };
    3102. 

  3102.         return program;
    3103. 

  3103.     }
    3104. 

  3104. 

  3105.     // The following functions are needed only when the option to preserve
    3106. 

  3106.     // the comments is active.
    3107. 

  3107. 

  3108.     function addComment(type, value, start, end, loc) {
    3109. 

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

  3110. 

  3111.         // Because the way the actual token is scanned, often the comments
    3112. 

  3112.         // (if any) are skipped twice during the lexical analysis.
    3113. 

  3113.         // Thus, we need to skip adding a comment if the comment array already
    3114. 

  3114.         // handled it.
    3115. 

  3115.         if (extra.comments.length > 0) {
    3116. 

  3116.             if (extra.comments[extra.comments.length - 1].range[1] > start) {
    3117. 

  3117.                 return;
    3118. 

  3118.             }
    3119. 

  3119.         }
    3120. 

  3120. 

  3121.         extra.comments.push({
    3122. 

  3122.             type: type,
    3123. 

  3123.             value: value,
    3124. 

  3124.             range: [start, end],
    3125. 

  3125.             loc: loc
    3126. 

  3126.         });
    3127. 

  3127.     }
    3128. 

  3128. 

  3129.     function scanComment() {
    3130. 

  3130.         var comment, ch, loc, start, blockComment, lineComment;
    3131. 

  3131. 

  3132.         comment = '';
    3133. 

  3133.         blockComment = false;
    3134. 

  3134.         lineComment = false;
    3135. 

  3135. 

  3136.         while (index < length) {
    3137. 

  3137.             ch = source[index];
    3138. 

  3138. 

  3139.             if (lineComment) {
    3140. 

  3140.                 ch = source[index++];
    3141. 

  3141.                 if (isLineTerminator(ch)) {
    3142. 

  3142.                     loc.end = {
    3143. 

  3143.                         line: lineNumber,
    3144. 

  3144.                         column: index - lineStart - 1
    3145. 

  3145.                     };
    3146. 

  3146.                     lineComment = false;
    3147. 

  3147.                     addComment('Line', comment, start, index - 1, loc);
    3148. 

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

  3149.                         ++index;
    3150. 

  3150.                     }
    3151. 

  3151.                     ++lineNumber;
    3152. 

  3152.                     lineStart = index;
    3153. 

  3153.                     comment = '';
    3154. 

  3154.                 } else if (index >= length) {
    3155. 

  3155.                     lineComment = false;
    3156. 

  3156.                     comment += ch;
    3157. 

  3157.                     loc.end = {
    3158. 

  3158.                         line: lineNumber,
    3159. 

  3159.                         column: length - lineStart
    3160. 

  3160.                     };
    3161. 

  3161.                     addComment('Line', comment, start, length, loc);
    3162. 

  3162.                 } else {
    3163. 

  3163.                     comment += ch;
    3164. 

  3164.                 }
    3165. 

  3165.             } else if (blockComment) {
    3166. 

  3166.                 if (isLineTerminator(ch)) {
    3167. 

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

  3168.                         ++index;
    3169. 

  3169.                         comment += '\r\n';
    3170. 

  3170.                     } else {
    3171. 

  3171.                         comment += ch;
    3172. 

  3172.                     }
    3173. 

  3173.                     ++lineNumber;
    3174. 

  3174.                     ++index;
    3175. 

  3175.                     lineStart = index;
    3176. 

  3176.                     if (index >= length) {
    3177. 

  3177.                         throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
    3178. 

  3178.                     }
    3179. 

  3179.                 } else {
    3180. 

  3180.                     ch = source[index++];
    3181. 

  3181.                     if (index >= length) {
    3182. 

  3182.                         throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
    3183. 

  3183.                     }
    3184. 

  3184.                     comment += ch;
    3185. 

  3185.                     if (ch === '*') {
    3186. 

  3186.                         ch = source[index];
    3187. 

  3187.                         if (ch === '/') {
    3188. 

  3188.                             comment = comment.substr(0, comment.length - 1);
    3189. 

  3189.                             blockComment = false;
    3190. 

  3190.                             ++index;
    3191. 

  3191.                             loc.end = {
    3192. 

  3192.                                 line: lineNumber,
    3193. 

  3193.                                 column: index - lineStart
    3194. 

  3194.                             };
    3195. 

  3195.                             addComment('Block', comment, start, index, loc);
    3196. 

  3196.                             comment = '';
    3197. 

  3197.                         }
    3198. 

  3198.                     }
    3199. 

  3199.                 }
    3200. 

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

  3201.                 ch = source[index + 1];
    3202. 

  3202.                 if (ch === '/') {
    3203. 

  3203.                     loc = {
    3204. 

  3204.                         start: {
    3205. 

  3205.                             line: lineNumber,
    3206. 

  3206.                             column: index - lineStart
    3207. 

  3207.                         }
    3208. 

  3208.                     };
    3209. 

  3209.                     start = index;
    3210. 

  3210.                     index += 2;
    3211. 

  3211.                     lineComment = true;
    3212. 

  3212.                     if (index >= length) {
    3213. 

  3213.                         loc.end = {
    3214. 

  3214.                             line: lineNumber,
    3215. 

  3215.                             column: index - lineStart
    3216. 

  3216.                         };
    3217. 

  3217.                         lineComment = false;
    3218. 

  3218.                         addComment('Line', comment, start, index, loc);
    3219. 

  3219.                     }
    3220. 

  3220.                 } else if (ch === '*') {
    3221. 

  3221.                     start = index;
    3222. 

  3222.                     index += 2;
    3223. 

  3223.                     blockComment = true;
    3224. 

  3224.                     loc = {
    3225. 

  3225.                         start: {
    3226. 

  3226.                             line: lineNumber,
    3227. 

  3227.                             column: index - lineStart - 2
    3228. 

  3228.                         }
    3229. 

  3229.                     };
    3230. 

  3230.                     if (index >= length) {
    3231. 

  3231.                         throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
    3232. 

  3232.                     }
    3233. 

  3233.                 } else {
    3234. 

  3234.                     break;
    3235. 

  3235.                 }
    3236. 

  3236.             } else if (isWhiteSpace(ch)) {
    3237. 

  3237.                 ++index;
    3238. 

  3238.             } else if (isLineTerminator(ch)) {
    3239. 

  3239.                 ++index;
    3240. 

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

  3241.                     ++index;
    3242. 

  3242.                 }
    3243. 

  3243.                 ++lineNumber;
    3244. 

  3244.                 lineStart = index;
    3245. 

  3245.             } else {
    3246. 

  3246.                 break;
    3247. 

  3247.             }
    3248. 

  3248.         }
    3249. 

  3249.     }
    3250. 

  3250. 

  3251.     function filterCommentLocation() {
    3252. 

  3252.         var i, entry, comment, comments = [];
    3253. 

  3253. 

  3254.         for (i = 0; i < extra.comments.length; ++i) {
    3255. 

  3255.             entry = extra.comments[i];
    3256. 

  3256.             comment = {
    3257. 

  3257.                 type: entry.type,
    3258. 

  3258.                 value: entry.value
    3259. 

  3259.             };
    3260. 

  3260.             if (extra.range) {
    3261. 

  3261.                 comment.range = entry.range;
    3262. 

  3262.             }
    3263. 

  3263.             if (extra.loc) {
    3264. 

  3264.                 comment.loc = entry.loc;
    3265. 

  3265.             }
    3266. 

  3266.             comments.push(comment);
    3267. 

  3267.         }
    3268. 

  3268. 

  3269.         extra.comments = comments;
    3270. 

  3270.     }
    3271. 

  3271. 

  3272.     function collectToken() {
    3273. 

  3273.         var start, loc, token, range, value;
    3274. 

  3274. 

  3275.         skipComment();
    3276. 

  3276.         start = index;
    3277. 

  3277.         loc = {
    3278. 

  3278.             start: {
    3279. 

  3279.                 line: lineNumber,
    3280. 

  3280.                 column: index - lineStart
    3281. 

  3281.             }
    3282. 

  3282.         };
    3283. 

  3283. 

  3284.         token = extra.advance();
    3285. 

  3285.         loc.end = {
    3286. 

  3286.             line: lineNumber,
    3287. 

  3287.             column: index - lineStart
    3288. 

  3288.         };
    3289. 

  3289. 

  3290.         if (token.type !== Token.EOF) {
    3291. 

  3291.             range = [token.range[0], token.range[1]];
    3292. 

  3292.             value = sliceSource(token.range[0], token.range[1]);
    3293. 

  3293.             extra.tokens.push({
    3294. 

  3294.                 type: TokenName[token.type],
    3295. 

  3295.                 value: value,
    3296. 

  3296.                 range: range,
    3297. 

  3297.                 loc: loc
    3298. 

  3298.             });
    3299. 

  3299.         }
    3300. 

  3300. 

  3301.         return token;
    3302. 

  3302.     }
    3303. 

  3303. 

  3304.     function collectRegex() {
    3305. 

  3305.         var pos, loc, regex, token;
    3306. 

  3306. 

  3307.         skipComment();
    3308. 

  3308. 

  3309.         pos = index;
    3310. 

  3310.         loc = {
    3311. 

  3311.             start: {
    3312. 

  3312.                 line: lineNumber,
    3313. 

  3313.                 column: index - lineStart
    3314. 

  3314.             }
    3315. 

  3315.         };
    3316. 

  3316. 

  3317.         regex = extra.scanRegExp();
    3318. 

  3318.         loc.end = {
    3319. 

  3319.             line: lineNumber,
    3320. 

  3320.             column: index - lineStart
    3321. 

  3321.         };
    3322. 

  3322. 

  3323.         // Pop the previous token, which is likely '/' or '/='
    3324. 

  3324.         if (extra.tokens.length > 0) {
    3325. 

  3325.             token = extra.tokens[extra.tokens.length - 1];
    3326. 

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

  3327.                 if (token.value === '/' || token.value === '/=') {
    3328. 

  3328.                     extra.tokens.pop();
    3329. 

  3329.                 }
    3330. 

  3330.             }
    3331. 

  3331.         }
    3332. 

  3332. 

  3333.         extra.tokens.push({
    3334. 

  3334.             type: 'RegularExpression',
    3335. 

  3335.             value: regex.literal,
    3336. 

  3336.             range: [pos, index],
    3337. 

  3337.             loc: loc
    3338. 

  3338.         });
    3339. 

  3339. 

  3340.         return regex;
    3341. 

  3341.     }
    3342. 

  3342. 

  3343.     function filterTokenLocation() {
    3344. 

  3344.         var i, entry, token, tokens = [];
    3345. 

  3345. 

  3346.         for (i = 0; i < extra.tokens.length; ++i) {
    3347. 

  3347.             entry = extra.tokens[i];
    3348. 

  3348.             token = {
    3349. 

  3349.                 type: entry.type,
    3350. 

  3350.                 value: entry.value
    3351. 

  3351.             };
    3352. 

  3352.             if (extra.range) {
    3353. 

  3353.                 token.range = entry.range;
    3354. 

  3354.             }
    3355. 

  3355.             if (extra.loc) {
    3356. 

  3356.                 token.loc = entry.loc;
    3357. 

  3357.             }
    3358. 

  3358.             tokens.push(token);
    3359. 

  3359.         }
    3360. 

  3360. 

  3361.         extra.tokens = tokens;
    3362. 

  3362.     }
    3363. 

  3363. 

  3364.     function createLiteral(token) {
    3365. 

  3365.         return {
    3366. 

  3366.             type: Syntax.Literal,
    3367. 

  3367.             value: token.value
    3368. 

  3368.         };
    3369. 

  3369.     }
    3370. 

  3370. 

  3371.     function createRawLiteral(token) {
    3372. 

  3372.         return {
    3373. 

  3373.             type: Syntax.Literal,
    3374. 

  3374.             value: token.value,
    3375. 

  3375.             raw: sliceSource(token.range[0], token.range[1])
    3376. 

  3376.         };
    3377. 

  3377.     }
    3378. 

  3378. 

  3379.     function createLocationMarker() {
    3380. 

  3380.         var marker = {};
    3381. 

  3381. 

  3382.         marker.range = [index, index];
    3383. 

  3383.         marker.loc = {
    3384. 

  3384.             start: {
    3385. 

  3385.                 line: lineNumber,
    3386. 

  3386.                 column: index - lineStart
    3387. 

  3387.             },
    3388. 

  3388.             end: {
    3389. 

  3389.                 line: lineNumber,
    3390. 

  3390.                 column: index - lineStart
    3391. 

  3391.             }
    3392. 

  3392.         };
    3393. 

  3393. 

  3394.         marker.end = function () {
    3395. 

  3395.             this.range[1] = index;
    3396. 

  3396.             this.loc.end.line = lineNumber;
    3397. 

  3397.             this.loc.end.column = index - lineStart;
    3398. 

  3398.         };
    3399. 

  3399. 

  3400.         marker.applyGroup = function (node) {
    3401. 

  3401.             if (extra.range) {
    3402. 

  3402.                 node.groupRange = [this.range[0], this.range[1]];
    3403. 

  3403.             }
    3404. 

  3404.             if (extra.loc) {
    3405. 

  3405.                 node.groupLoc = {
    3406. 

  3406.                     start: {
    3407. 

  3407.                         line: this.loc.start.line,
    3408. 

  3408.                         column: this.loc.start.column
    3409. 

  3409.                     },
    3410. 

  3410.                     end: {
    3411. 

  3411.                         line: this.loc.end.line,
    3412. 

  3412.                         column: this.loc.end.column
    3413. 

  3413.                     }
    3414. 

  3414.                 };
    3415. 

  3415.             }
    3416. 

  3416.         };
    3417. 

  3417. 

  3418.         marker.apply = function (node) {
    3419. 

  3419.             if (extra.range) {
    3420. 

  3420.                 node.range = [this.range[0], this.range[1]];
    3421. 

  3421.             }
    3422. 

  3422.             if (extra.loc) {
    3423. 

  3423.                 node.loc = {
    3424. 

  3424.                     start: {
    3425. 

  3425.                         line: this.loc.start.line,
    3426. 

  3426.                         column: this.loc.start.column
    3427. 

  3427.                     },
    3428. 

  3428.                     end: {
    3429. 

  3429.                         line: this.loc.end.line,
    3430. 

  3430.                         column: this.loc.end.column
    3431. 

  3431.                     }
    3432. 

  3432.                 };
    3433. 

  3433.             }
    3434. 

  3434.         };
    3435. 

  3435. 

  3436.         return marker;
    3437. 

  3437.     }
    3438. 

  3438. 

  3439.     function trackGroupExpression() {
    3440. 

  3440.         var marker, expr;
    3441. 

  3441. 

  3442.         skipComment();
    3443. 

  3443.         marker = createLocationMarker();
    3444. 

  3444.         expect('(');
    3445. 

  3445. 

  3446.         expr = parseExpression();
    3447. 

  3447. 

  3448.         expect(')');
    3449. 

  3449. 

  3450.         marker.end();
    3451. 

  3451.         marker.applyGroup(expr);
    3452. 

  3452. 

  3453.         return expr;
    3454. 

  3454.     }
    3455. 

  3455. 

  3456.     function trackLeftHandSideExpression() {
    3457. 

  3457.         var marker, expr;
    3458. 

  3458. 

  3459.         skipComment();
    3460. 

  3460.         marker = createLocationMarker();
    3461. 

  3461. 

  3462.         expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();
    3463. 

  3463. 

  3464.         while (match('.') || match('[')) {
    3465. 

  3465.             if (match('[')) {
    3466. 

  3466.                 expr = {
    3467. 

  3467.                     type: Syntax.MemberExpression,
    3468. 

  3468.                     computed: true,
    3469. 

  3469.                     object: expr,
    3470. 

  3470.                     property: parseComputedMember()
    3471. 

  3471.                 };
    3472. 

  3472.                 marker.end();
    3473. 

  3473.                 marker.apply(expr);
    3474. 

  3474.             } else {
    3475. 

  3475.                 expr = {
    3476. 

  3476.                     type: Syntax.MemberExpression,
    3477. 

  3477.                     computed: false,
    3478. 

  3478.                     object: expr,
    3479. 

  3479.                     property: parseNonComputedMember()
    3480. 

  3480.                 };
    3481. 

  3481.                 marker.end();
    3482. 

  3482.                 marker.apply(expr);
    3483. 

  3483.             }
    3484. 

  3484.         }
    3485. 

  3485. 

  3486.         return expr;
    3487. 

  3487.     }
    3488. 

  3488. 

  3489.     function trackLeftHandSideExpressionAllowCall() {
    3490. 

  3490.         var marker, expr;
    3491. 

  3491. 

  3492.         skipComment();
    3493. 

  3493.         marker = createLocationMarker();
    3494. 

  3494. 

  3495.         expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();
    3496. 

  3496. 

  3497.         while (match('.') || match('[') || match('(')) {
    3498. 

  3498.             if (match('(')) {
    3499. 

  3499.                 expr = {
    3500. 

  3500.                     type: Syntax.CallExpression,
    3501. 

  3501.                     callee: expr,
    3502. 

  3502.                     'arguments': parseArguments()
    3503. 

  3503.                 };
    3504. 

  3504.                 marker.end();
    3505. 

  3505.                 marker.apply(expr);
    3506. 

  3506.             } else if (match('[')) {
    3507. 

  3507.                 expr = {
    3508. 

  3508.                     type: Syntax.MemberExpression,
    3509. 

  3509.                     computed: true,
    3510. 

  3510.                     object: expr,
    3511. 

  3511.                     property: parseComputedMember()
    3512. 

  3512.                 };
    3513. 

  3513.                 marker.end();
    3514. 

  3514.                 marker.apply(expr);
    3515. 

  3515.             } else {
    3516. 

  3516.                 expr = {
    3517. 

  3517.                     type: Syntax.MemberExpression,
    3518. 

  3518.                     computed: false,
    3519. 

  3519.                     object: expr,
    3520. 

  3520.                     property: parseNonComputedMember()
    3521. 

  3521.                 };
    3522. 

  3522.                 marker.end();
    3523. 

  3523.                 marker.apply(expr);
    3524. 

  3524.             }
    3525. 

  3525.         }
    3526. 

  3526. 

  3527.         return expr;
    3528. 

  3528.     }
    3529. 

  3529. 

  3530.     function filterGroup(node) {
    3531. 

  3531.         var n, i, entry;
    3532. 

  3532. 

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

  3534.         for (i in node) {
    3535. 

  3535.             if (node.hasOwnProperty(i) && i !== 'groupRange' && i !== 'groupLoc') {
    3536. 

  3536.                 entry = node[i];
    3537. 

  3537.                 if (entry === null || typeof entry !== 'object' || entry instanceof RegExp) {
    3538. 

  3538.                     n[i] = entry;
    3539. 

  3539.                 } else {
    3540. 

  3540.                     n[i] = filterGroup(entry);
    3541. 

  3541.                 }
    3542. 

  3542.             }
    3543. 

  3543.         }
    3544. 

  3544.         return n;
    3545. 

  3545.     }
    3546. 

  3546. 

  3547.     function wrapTrackingFunction(range, loc) {
    3548. 

  3548. 

  3549.         return function (parseFunction) {
    3550. 

  3550. 

  3551.             function isBinary(node) {
    3552. 

  3552.                 return node.type === Syntax.LogicalExpression ||
    3553. 

  3553.                     node.type === Syntax.BinaryExpression;
    3554. 

  3554.             }
    3555. 

  3555. 

  3556.             function visit(node) {
    3557. 

  3557.                 var start, end;
    3558. 

  3558. 

  3559.                 if (isBinary(node.left)) {
    3560. 

  3560.                     visit(node.left);
    3561. 

  3561.                 }
    3562. 

  3562.                 if (isBinary(node.right)) {
    3563. 

  3563.                     visit(node.right);
    3564. 

  3564.                 }
    3565. 

  3565. 

  3566.                 if (range) {
    3567. 

  3567.                     if (node.left.groupRange || node.right.groupRange) {
    3568. 

  3568.                         start = node.left.groupRange ? node.left.groupRange[0] : node.left.range[0];
    3569. 

  3569.                         end = node.right.groupRange ? node.right.groupRange[1] : node.right.range[1];
    3570. 

  3570.                         node.range = [start, end];
    3571. 

  3571.                     } else if (typeof node.range === 'undefined') {
    3572. 

  3572.                         start = node.left.range[0];
    3573. 

  3573.                         end = node.right.range[1];
    3574. 

  3574.                         node.range = [start, end];
    3575. 

  3575.                     }
    3576. 

  3576.                 }
    3577. 

  3577.                 if (loc) {
    3578. 

  3578.                     if (node.left.groupLoc || node.right.groupLoc) {
    3579. 

  3579.                         start = node.left.groupLoc ? node.left.groupLoc.start : node.left.loc.start;
    3580. 

  3580.                         end = node.right.groupLoc ? node.right.groupLoc.end : node.right.loc.end;
    3581. 

  3581.                         node.loc = {
    3582. 

  3582.                             start: start,
    3583. 

  3583.                             end: end
    3584. 

  3584.                         };
    3585. 

  3585.                     } else if (typeof node.loc === 'undefined') {
    3586. 

  3586.                         node.loc = {
    3587. 

  3587.                             start: node.left.loc.start,
    3588. 

  3588.                             end: node.right.loc.end
    3589. 

  3589.                         };
    3590. 

  3590.                     }
    3591. 

  3591.                 }
    3592. 

  3592.             }
    3593. 

  3593. 

  3594.             return function () {
    3595. 

  3595.                 var marker, node;
    3596. 

  3596. 

  3597.                 skipComment();
    3598. 

  3598. 

  3599.                 marker = createLocationMarker();
    3600. 

  3600.                 node = parseFunction.apply(null, arguments);
    3601. 

  3601.                 marker.end();
    3602. 

  3602. 

  3603.                 if (range && typeof node.range === 'undefined') {
    3604. 

  3604.                     marker.apply(node);
    3605. 

  3605.                 }
    3606. 

  3606. 

  3607.                 if (loc && typeof node.loc === 'undefined') {
    3608. 

  3608.                     marker.apply(node);
    3609. 

  3609.                 }
    3610. 

  3610. 

  3611.                 if (isBinary(node)) {
    3612. 

  3612.                     visit(node);
    3613. 

  3613.                 }
    3614. 

  3614. 

  3615.                 return node;
    3616. 

  3616.             };
    3617. 

  3617.         };
    3618. 

  3618.     }
    3619. 

  3619. 

  3620.     function patch() {
    3621. 

  3621. 

  3622.         var wrapTracking;
    3623. 

  3623. 

  3624.         if (extra.comments) {
    3625. 

  3625.             extra.skipComment = skipComment;
    3626. 

  3626.             skipComment = scanComment;
    3627. 

  3627.         }
    3628. 

  3628. 

  3629.         if (extra.raw) {
    3630. 

  3630.             extra.createLiteral = createLiteral;
    3631. 

  3631.             createLiteral = createRawLiteral;
    3632. 

  3632.         }
    3633. 

  3633. 

  3634.         if (extra.range || extra.loc) {
    3635. 

  3635. 

  3636.             extra.parseGroupExpression = parseGroupExpression;
    3637. 

  3637.             extra.parseLeftHandSideExpression = parseLeftHandSideExpression;
    3638. 

  3638.             extra.parseLeftHandSideExpressionAllowCall = parseLeftHandSideExpressionAllowCall;
    3639. 

  3639.             parseGroupExpression = trackGroupExpression;
    3640. 

  3640.             parseLeftHandSideExpression = trackLeftHandSideExpression;
    3641. 

  3641.             parseLeftHandSideExpressionAllowCall = trackLeftHandSideExpressionAllowCall;
    3642. 

  3642. 

  3643.             wrapTracking = wrapTrackingFunction(extra.range, extra.loc);
    3644. 

  3644. 

  3645.             extra.parseAdditiveExpression = parseAdditiveExpression;
    3646. 

  3646.             extra.parseAssignmentExpression = parseAssignmentExpression;
    3647. 

  3647.             extra.parseBitwiseANDExpression = parseBitwiseANDExpression;
    3648. 

  3648.             extra.parseBitwiseORExpression = parseBitwiseORExpression;
    3649. 

  3649.             extra.parseBitwiseXORExpression = parseBitwiseXORExpression;
    3650. 

  3650.             extra.parseBlock = parseBlock;
    3651. 

  3651.             extra.parseFunctionSourceElements = parseFunctionSourceElements;
    3652. 

  3652.             extra.parseCatchClause = parseCatchClause;
    3653. 

  3653.             extra.parseComputedMember = parseComputedMember;
    3654. 

  3654.             extra.parseConditionalExpression = parseConditionalExpression;
    3655. 

  3655.             extra.parseConstLetDeclaration = parseConstLetDeclaration;
    3656. 

  3656.             extra.parseEqualityExpression = parseEqualityExpression;
    3657. 

  3657.             extra.parseExpression = parseExpression;
    3658. 

  3658.             extra.parseForVariableDeclaration = parseForVariableDeclaration;
    3659. 

  3659.             extra.parseFunctionDeclaration = parseFunctionDeclaration;
    3660. 

  3660.             extra.parseFunctionExpression = parseFunctionExpression;
    3661. 

  3661.             extra.parseLogicalANDExpression = parseLogicalANDExpression;
    3662. 

  3662.             extra.parseLogicalORExpression = parseLogicalORExpression;
    3663. 

  3663.             extra.parseMultiplicativeExpression = parseMultiplicativeExpression;
    3664. 

  3664.             extra.parseNewExpression = parseNewExpression;
    3665. 

  3665.             extra.parseNonComputedProperty = parseNonComputedProperty;
    3666. 

  3666.             extra.parseObjectProperty = parseObjectProperty;
    3667. 

  3667.             extra.parseObjectPropertyKey = parseObjectPropertyKey;
    3668. 

  3668.             extra.parsePostfixExpression = parsePostfixExpression;
    3669. 

  3669.             extra.parsePrimaryExpression = parsePrimaryExpression;
    3670. 

  3670.             extra.parseProgram = parseProgram;
    3671. 

  3671.             extra.parsePropertyFunction = parsePropertyFunction;
    3672. 

  3672.             extra.parseRelationalExpression = parseRelationalExpression;
    3673. 

  3673.             extra.parseStatement = parseStatement;
    3674. 

  3674.             extra.parseShiftExpression = parseShiftExpression;
    3675. 

  3675.             extra.parseSwitchCase = parseSwitchCase;
    3676. 

  3676.             extra.parseUnaryExpression = parseUnaryExpression;
    3677. 

  3677.             extra.parseVariableDeclaration = parseVariableDeclaration;
    3678. 

  3678.             extra.parseVariableIdentifier = parseVariableIdentifier;
    3679. 

  3679. 

  3680.             parseAdditiveExpression = wrapTracking(extra.parseAdditiveExpression);
    3681. 

  3681.             parseAssignmentExpression = wrapTracking(extra.parseAssignmentExpression);
    3682. 

  3682.             parseBitwiseANDExpression = wrapTracking(extra.parseBitwiseANDExpression);
    3683. 

  3683.             parseBitwiseORExpression = wrapTracking(extra.parseBitwiseORExpression);
    3684. 

  3684.             parseBitwiseXORExpression = wrapTracking(extra.parseBitwiseXORExpression);
    3685. 

  3685.             parseBlock = wrapTracking(extra.parseBlock);
    3686. 

  3686.             parseFunctionSourceElements = wrapTracking(extra.parseFunctionSourceElements);
    3687. 

  3687.             parseCatchClause = wrapTracking(extra.parseCatchClause);
    3688. 

  3688.             parseComputedMember = wrapTracking(extra.parseComputedMember);
    3689. 

  3689.             parseConditionalExpression = wrapTracking(extra.parseConditionalExpression);
    3690. 

  3690.             parseConstLetDeclaration = wrapTracking(extra.parseConstLetDeclaration);
    3691. 

  3691.             parseEqualityExpression = wrapTracking(extra.parseEqualityExpression);
    3692. 

  3692.             parseExpression = wrapTracking(extra.parseExpression);
    3693. 

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

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

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

  3696.             parseLeftHandSideExpression = wrapTracking(parseLeftHandSideExpression);
    3697. 

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

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

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

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

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

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

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

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

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

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

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

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

  3709.             parseStatement = wrapTracking(extra.parseStatement);
    3710. 

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

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

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

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

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

  3715.         }
    3716. 

  3716. 

  3717.         if (typeof extra.tokens !== 'undefined') {
    3718. 

  3718.             extra.advance = advance;
    3719. 

  3719.             extra.scanRegExp = scanRegExp;
    3720. 

  3720. 

  3721.             advance = collectToken;
    3722. 

  3722.             scanRegExp = collectRegex;
    3723. 

  3723.         }
    3724. 

  3724.     }
    3725. 

  3725. 

  3726.     function unpatch() {
    3727. 

  3727.         if (typeof extra.skipComment === 'function') {
    3728. 

  3728.             skipComment = extra.skipComment;
    3729. 

  3729.         }
    3730. 

  3730. 

  3731.         if (extra.raw) {
    3732. 

  3732.             createLiteral = extra.createLiteral;
    3733. 

  3733.         }
    3734. 

  3734. 

  3735.         if (extra.range || extra.loc) {
    3736. 

  3736.             parseAdditiveExpression = extra.parseAdditiveExpression;
    3737. 

  3737.             parseAssignmentExpression = extra.parseAssignmentExpression;
    3738. 

  3738.             parseBitwiseANDExpression = extra.parseBitwiseANDExpression;
    3739. 

  3739.             parseBitwiseORExpression = extra.parseBitwiseORExpression;
    3740. 

  3740.             parseBitwiseXORExpression = extra.parseBitwiseXORExpression;
    3741. 

  3741.             parseBlock = extra.parseBlock;
    3742. 

  3742.             parseFunctionSourceElements = extra.parseFunctionSourceElements;
    3743. 

  3743.             parseCatchClause = extra.parseCatchClause;
    3744. 

  3744.             parseComputedMember = extra.parseComputedMember;
    3745. 

  3745.             parseConditionalExpression = extra.parseConditionalExpression;
    3746. 

  3746.             parseConstLetDeclaration = extra.parseConstLetDeclaration;
    3747. 

  3747.             parseEqualityExpression = extra.parseEqualityExpression;
    3748. 

  3748.             parseExpression = extra.parseExpression;
    3749. 

  3749.             parseForVariableDeclaration = extra.parseForVariableDeclaration;
    3750. 

  3750.             parseFunctionDeclaration = extra.parseFunctionDeclaration;
    3751. 

  3751.             parseFunctionExpression = extra.parseFunctionExpression;
    3752. 

  3752.             parseGroupExpression = extra.parseGroupExpression;
    3753. 

  3753.             parseLeftHandSideExpression = extra.parseLeftHandSideExpression;
    3754. 

  3754.             parseLeftHandSideExpressionAllowCall = extra.parseLeftHandSideExpressionAllowCall;
    3755. 

  3755.             parseLogicalANDExpression = extra.parseLogicalANDExpression;
    3756. 

  3756.             parseLogicalORExpression = extra.parseLogicalORExpression;
    3757. 

  3757.             parseMultiplicativeExpression = extra.parseMultiplicativeExpression;
    3758. 

  3758.             parseNewExpression = extra.parseNewExpression;
    3759. 

  3759.             parseNonComputedProperty = extra.parseNonComputedProperty;
    3760. 

  3760.             parseObjectProperty = extra.parseObjectProperty;
    3761. 

  3761.             parseObjectPropertyKey = extra.parseObjectPropertyKey;
    3762. 

  3762.             parsePrimaryExpression = extra.parsePrimaryExpression;
    3763. 

  3763.             parsePostfixExpression = extra.parsePostfixExpression;
    3764. 

  3764.             parseProgram = extra.parseProgram;
    3765. 

  3765.             parsePropertyFunction = extra.parsePropertyFunction;
    3766. 

  3766.             parseRelationalExpression = extra.parseRelationalExpression;
    3767. 

  3767.             parseStatement = extra.parseStatement;
    3768. 

  3768.             parseShiftExpression = extra.parseShiftExpression;
    3769. 

  3769.             parseSwitchCase = extra.parseSwitchCase;
    3770. 

  3770.             parseUnaryExpression = extra.parseUnaryExpression;
    3771. 

  3771.             parseVariableDeclaration = extra.parseVariableDeclaration;
    3772. 

  3772.             parseVariableIdentifier = extra.parseVariableIdentifier;
    3773. 

  3773.         }
    3774. 

  3774. 

  3775.         if (typeof extra.scanRegExp === 'function') {
    3776. 

  3776.             advance = extra.advance;
    3777. 

  3777.             scanRegExp = extra.scanRegExp;
    3778. 

  3778.         }
    3779. 

  3779.     }
    3780. 

  3780. 

  3781.     function stringToArray(str) {
    3782. 

  3782.         var length = str.length,
    3783. 

  3783.             result = [],
    3784. 

  3784.             i;
    3785. 

  3785.         for (i = 0; i < length; ++i) {
    3786. 

  3786.             result[i] = str.charAt(i);
    3787. 

  3787.         }
    3788. 

  3788.         return result;
    3789. 

  3789.     }
    3790. 

  3790. 

  3791.     function parse(code, options) {
    3792. 

  3792.         var program, toString;
    3793. 

  3793. 

  3794.         toString = String;
    3795. 

  3795.         if (typeof code !== 'string' && !(code instanceof String)) {
    3796. 

  3796.             code = toString(code);
    3797. 

  3797.         }
    3798. 

  3798. 

  3799.         source = code;
    3800. 

  3800.         index = 0;
    3801. 

  3801.         lineNumber = (source.length > 0) ? 1 : 0;
    3802. 

  3802.         lineStart = 0;
    3803. 

  3803.         length = source.length;
    3804. 

  3804.         buffer = null;
    3805. 

  3805.         state = {
    3806. 

  3806.             allowIn: true,
    3807. 

  3807.             labelSet: {},
    3808. 

  3808.             inFunctionBody: false,
    3809. 

  3809.             inIteration: false,
    3810. 

  3810.             inSwitch: false
    3811. 

  3811.         };
    3812. 

  3812. 

  3813.         extra = {};
    3814. 

  3814.         if (typeof options !== 'undefined') {
    3815. 

  3815.             extra.range = (typeof options.range === 'boolean') && options.range;
    3816. 

  3816.             extra.loc = (typeof options.loc === 'boolean') && options.loc;
    3817. 

  3817.             extra.raw = (typeof options.raw === 'boolean') && options.raw;
    3818. 

  3818.             if (typeof options.tokens === 'boolean' && options.tokens) {
    3819. 

  3819.                 extra.tokens = [];
    3820. 

  3820.             }
    3821. 

  3821.             if (typeof options.comment === 'boolean' && options.comment) {
    3822. 

  3822.                 extra.comments = [];
    3823. 

  3823.             }
    3824. 

  3824.             if (typeof options.tolerant === 'boolean' && options.tolerant) {
    3825. 

  3825.                 extra.errors = [];
    3826. 

  3826.             }
    3827. 

  3827.         }
    3828. 

  3828. 

  3829.         if (length > 0) {
    3830. 

  3830.             if (typeof source[0] === 'undefined') {
    3831. 

  3831.                 // Try first to convert to a string. This is good as fast path
    3832. 

  3832.                 // for old IE which understands string indexing for string
    3833. 

  3833.                 // literals only and not for string object.
    3834. 

  3834.                 if (code instanceof String) {
    3835. 

  3835.                     source = code.valueOf();
    3836. 

  3836.                 }
    3837. 

  3837. 

  3838.                 // Force accessing the characters via an array.
    3839. 

  3839.                 if (typeof source[0] === 'undefined') {
    3840. 

  3840.                     source = stringToArray(code);
    3841. 

  3841.                 }
    3842. 

  3842.             }
    3843. 

  3843.         }
    3844. 

  3844. 

  3845.         patch();
    3846. 

  3846.         try {
    3847. 

  3847.             program = parseProgram();
    3848. 

  3848.             if (typeof extra.comments !== 'undefined') {
    3849. 

  3849.                 filterCommentLocation();
    3850. 

  3850.                 program.comments = extra.comments;
    3851. 

  3851.             }
    3852. 

  3852.             if (typeof extra.tokens !== 'undefined') {
    3853. 

  3853.                 filterTokenLocation();
    3854. 

  3854.                 program.tokens = extra.tokens;
    3855. 

  3855.             }
    3856. 

  3856.             if (typeof extra.errors !== 'undefined') {
    3857. 

  3857.                 program.errors = extra.errors;
    3858. 

  3858.             }
    3859. 

  3859.             if (extra.range || extra.loc) {
    3860. 

  3860.                 program.body = filterGroup(program.body);
    3861. 

  3861.             }
    3862. 

  3862.         } catch (e) {
    3863. 

  3863.             throw e;
    3864. 

  3864.         } finally {
    3865. 

  3865.             unpatch();
    3866. 

  3866.             extra = {};
    3867. 

  3867.         }
    3868. 

  3868. 

  3869.         return program;
    3870. 

  3870.     }
    3871. 

  3871. 

  3872.     // Sync with package.json.
    3873. 

  3873.     exports.version = '1.0.2';
    3874. 

  3874. 

  3875.     exports.parse = parse;
    3876. 

  3876. 

  3877.     // Deep copy.
    3878. 

  3878.     exports.Syntax = (function () {
    3879. 

  3879.         var name, types = {};
    3880. 

  3880. 

  3881.         if (typeof Object.create === 'function') {
    3882. 

  3882.             types = Object.create(null);
    3883. 

  3883.         }
    3884. 

  3884. 

  3885.         for (name in Syntax) {
    3886. 

  3886.             if (Syntax.hasOwnProperty(name)) {
    3887. 

  3887.                 types[name] = Syntax[name];
    3888. 

  3888.             }
    3889. 

  3889.         }
    3890. 

  3890. 

  3891.         if (typeof Object.freeze === 'function') {
    3892. 

  3892.             Object.freeze(types);
    3893. 

  3893.         }
    3894. 

  3894. 

  3895.         return types;
    3896. 

  3896.     }());
    3897. 

  3897. 

  3898. }));
    3899. 

  3899. /* vim: set sw=4 ts=4 et tw=80 : */
    3900. 

  3900. 

  3901. })(null);
    3902. 

  3902. 

  3903. (function(require,module){
    3904. 

  3904. 

  3905. var parse = require('esprima').parse;
    3906. 

  3906. var objectKeys = Object.keys || function (obj) {
    3907. 

  3907.     var keys = [];
    3908. 

  3908.     for (var key in obj) keys.push(key);
    3909. 

  3909.     return keys;
    3910. 

  3910. };
    3911. 

  3911. var forEach = function (xs, fn) {
    3912. 

  3912.     if (xs.forEach) return xs.forEach(fn);
    3913. 

  3913.     for (var i = 0; i < xs.length; i++) {
    3914. 

  3914.         fn.call(xs, xs[i], i, xs);
    3915. 

  3915.     }
    3916. 

  3916. };
    3917. 

  3917. 

  3918. var isArray = Array.isArray || function (xs) {
    3919. 

  3919.     return Object.prototype.toString.call(xs) === '[object Array]';
    3920. 

  3920. };
    3921. 

  3921. 

  3922. module.exports = function (src, opts, fn) {
    3923. 

  3923.     if (typeof opts === 'function') {
    3924. 

  3924.         fn = opts;
    3925. 

  3925.         opts = {};
    3926. 

  3926.     }
    3927. 

  3927.     if (typeof src === 'object') {
    3928. 

  3928.         opts = src;
    3929. 

  3929.         src = opts.source;
    3930. 

  3930.         delete opts.source;
    3931. 

  3931.     }
    3932. 

  3932.     src = src === undefined ? opts.source : src;
    3933. 

  3933.     opts.range = true;
    3934. 

  3934.     if (typeof src !== 'string') src = String(src);
    3935. 

  3935.     
    3936. 

  3936.     var ast = parse(src, opts);
    3937. 

  3937.     
    3938. 

  3938.     var result = {
    3939. 

  3939.         chunks : src.split(''),
    3940. 

  3940.         toString : function () { return result.chunks.join('') },
    3941. 

  3941.         inspect : function () { return result.toString() }
    3942. 

  3942.     };
    3943. 

  3943.     var index = 0;
    3944. 

  3944.     
    3945. 

  3945.     (function walk (node, parent) {
    3946. 

  3946.         insertHelpers(node, parent, result.chunks);
    3947. 

  3947.         
    3948. 

  3948.         forEach(objectKeys(node), function (key) {
    3949. 

  3949.             if (key === 'parent') return;
    3950. 

  3950.             
    3951. 

  3951.             var child = node[key];
    3952. 

  3952.             if (isArray(child)) {
    3953. 

  3953.                 forEach(child, function (c) {
    3954. 

  3954.                     if (c && typeof c.type === 'string') {
    3955. 

  3955.                         walk(c, node);
    3956. 

  3956.                     }
    3957. 

  3957.                 });
    3958. 

  3958.             }
    3959. 

  3959.             else if (child && typeof child.type === 'string') {
    3960. 

  3960.                 insertHelpers(child, node, result.chunks);
    3961. 

  3961.                 walk(child, node);
    3962. 

  3962.             }
    3963. 

  3963.         });
    3964. 

  3964.         fn(node);
    3965. 

  3965.     })(ast, undefined);
    3966. 

  3966.     
    3967. 

  3967.     return result;
    3968. 

  3968. };
    3969. 

  3969.  
    3970. 

  3970. function insertHelpers (node, parent, chunks) {
    3971. 

  3971.     if (!node.range) return;
    3972. 

  3972.     
    3973. 

  3973.     node.parent = parent;
    3974. 

  3974.     
    3975. 

  3975.     node.source = function () {
    3976. 

  3976.         return chunks.slice(
    3977. 

  3977.             node.range[0], node.range[1]
    3978. 

  3978.         ).join('');
    3979. 

  3979.     };
    3980. 

  3980.     
    3981. 

  3981.     if (node.update && typeof node.update === 'object') {
    3982. 

  3982.         var prev = node.update;
    3983. 

  3983.         forEach(objectKeys(prev), function (key) {
    3984. 

  3984.             update[key] = prev[key];
    3985. 

  3985.         });
    3986. 

  3986.         node.update = update;
    3987. 

  3987.     }
    3988. 

  3988.     else {
    3989. 

  3989.         node.update = update;
    3990. 

  3990.     }
    3991. 

  3991.     
    3992. 

  3992.     function update (s) {
    3993. 

  3993.         chunks[node.range[0]] = s;
    3994. 

  3994.         for (var i = node.range[0] + 1; i < node.range[1]; i++) {
    3995. 

  3995.             chunks[i] = '';
    3996. 

  3996.         }
    3997. 

  3997.     };
    3998. 

  3998. }
    3999. 

  3999. 

  4000. window.falafel = module.exports;})(function(){return {parse: esprima.parse};},{exports: {}});
    4001. 

  4001. 

  4002. var inBrowser = typeof window !== 'undefined' && this === window;
    4003. 

  4003. var parseAndModify = (inBrowser ? window.falafel : require("falafel"));
    4004. 

  4004. 

  4005. (inBrowser ? window : exports).blanket = (function(){
    4006. 

  4006.     var linesToAddTracking = [
    4007. 

  4007.         "ExpressionStatement",
    4008. 

  4008.         "BreakStatement"   ,
    4009. 

  4009.         "ContinueStatement" ,
    4010. 

  4010.         "VariableDeclaration",
    4011. 

  4011.         "ReturnStatement"   ,
    4012. 

  4012.         "ThrowStatement"   ,
    4013. 

  4013.         "TryStatement"     ,
    4014. 

  4014.         "FunctionDeclaration"    ,
    4015. 

  4015.         "IfStatement"       ,
    4016. 

  4016.         "WhileStatement"    ,
    4017. 

  4017.         "DoWhileStatement"   ,
    4018. 

  4018.         "ForStatement"   ,
    4019. 

  4019.         "ForInStatement"  ,
    4020. 

  4020.         "SwitchStatement"  ,
    4021. 

  4021.         "WithStatement"
    4022. 

  4022.     ],
    4023. 

  4023.     linesToAddBrackets = [
    4024. 

  4024.         "IfStatement"       ,
    4025. 

  4025.         "WhileStatement"    ,
    4026. 

  4026.         "DoWhileStatement"     ,
    4027. 

  4027.         "ForStatement"   ,
    4028. 

  4028.         "ForInStatement"  ,
    4029. 

  4029.         "WithStatement"
    4030. 

  4030.     ],
    4031. 

  4031.     __blanket,
    4032. 

  4032.     copynumber = Math.floor(Math.random()*1000),
    4033. 

  4033.     coverageInfo = {},options = {
    4034. 

  4034.         reporter: null,
    4035. 

  4035.         adapter:null,
    4036. 

  4036.         filter: null,
    4037. 

  4037.         customVariable: null,
    4038. 

  4038.         loader: null,
    4039. 

  4039.         ignoreScriptError: false,
    4040. 

  4040.         existingRequireJS:false,
    4041. 

  4041.         autoStart: false,
    4042. 

  4042.         timeout: 180,
    4043. 

  4043.         ignoreCors: false,
    4044. 

  4044.         branchTracking: false,
    4045. 

  4045.         sourceURL: false,
    4046. 

  4046.         debug:false,
    4047. 

  4047.         engineOnly:false,
    4048. 

  4048.         testReadyCallback:null,
    4049. 

  4049.         commonJS:false,
    4050. 

  4050.         instrumentCache:false,
    4051. 

  4051.         modulePattern: null
    4052. 

  4052.     };
    4053. 

  4053.     
    4054. 

  4054.     if (inBrowser && typeof window.blanket !== 'undefined'){
    4055. 

  4055.         __blanket = window.blanket.noConflict();
    4056. 

  4056.     }
    4057. 

  4057.     
    4058. 

  4058.     _blanket = {
    4059. 

  4059.         noConflict: function(){
    4060. 

  4060.             if (__blanket){
    4061. 

  4061.                 return __blanket;
    4062. 

  4062.             }
    4063. 

  4063.             return _blanket;
    4064. 

  4064.         },
    4065. 

  4065.         _getCopyNumber: function(){
    4066. 

  4066.             //internal method
    4067. 

  4067.             //for differentiating between instances
    4068. 

  4068.             return copynumber;
    4069. 

  4069.         },
    4070. 

  4070.         extend: function(obj) {
    4071. 

  4071.             //borrowed from underscore
    4072. 

  4072.             _blanket._extend(_blanket,obj);
    4073. 

  4073.         },
    4074. 

  4074.         _extend: function(dest,source){
    4075. 

  4075.           if (source) {
    4076. 

  4076.             for (var prop in source) {
    4077. 

  4077.               if ( dest[prop] instanceof Object && typeof dest[prop] !== "function"){
    4078. 

  4078.                 _blanket._extend(dest[prop],source[prop]);
    4079. 

  4079.               }else{
    4080. 

  4080.                   dest[prop] = source[prop];
    4081. 

  4081.               }
    4082. 

  4082.             }
    4083. 

  4083.           }
    4084. 

  4084.         },
    4085. 

  4085.         getCovVar: function(){
    4086. 

  4086.             var opt = _blanket.options("customVariable");
    4087. 

  4087.             if (opt){
    4088. 

  4088.                 if (_blanket.options("debug")) {console.log("BLANKET-Using custom tracking variable:",opt);}
    4089. 

  4089.                 return inBrowser ? "window."+opt : opt;
    4090. 

  4090.             }
    4091. 

  4091.             return inBrowser ?   "window._$blanket" : "_$jscoverage";
    4092. 

  4092.         },
    4093. 

  4093.         options: function(key,value){
    4094. 

  4094.             if (typeof key !== "string"){
    4095. 

  4095.                 _blanket._extend(options,key);
    4096. 

  4096.             }else if (typeof value === 'undefined'){
    4097. 

  4097.                 return options[key];
    4098. 

  4098.             }else{
    4099. 

  4099.                 options[key]=value;
    4100. 

  4100.             }
    4101. 

  4101.         },
    4102. 

  4102.         instrument: function(config, next){
    4103. 

  4103.             //check instrumented hash table,
    4104. 

  4104.             //return instrumented code if available.
    4105. 

  4105.             var inFile = config.inputFile,
    4106. 

  4106.                 inFileName = config.inputFileName;
    4107. 

  4107.             //check instrument cache
    4108. 

  4108.            if (_blanket.options("instrumentCache") && sessionStorage && sessionStorage.getItem("blanket_instrument_store-"+inFileName)){
    4109. 

  4109.                 if (_blanket.options("debug")) {console.log("BLANKET-Reading instrumentation from cache: ",inFileName);}
    4110. 

  4110.                 next(sessionStorage.getItem("blanket_instrument_store-"+inFileName));
    4111. 

  4111.             }else{
    4112. 

  4112.                 var sourceArray = _blanket._prepareSource(inFile);
    4113. 

  4113.                 _blanket._trackingArraySetup=[];
    4114. 

  4114.                 var instrumented =  parseAndModify(inFile,{loc:true,comment:true}, _blanket._addTracking(inFileName));
    4115. 

  4115.                 instrumented = _blanket._trackingSetup(inFileName,sourceArray)+instrumented;
    4116. 

  4116.                 if (_blanket.options("sourceURL")){
    4117. 

  4117.                     instrumented += "\n//@ sourceURL="+inFileName.replace("http://","");
    4118. 

  4118.                 }
    4119. 

  4119.                 if (_blanket.options("debug")) {console.log("BLANKET-Instrumented file: ",inFileName);}
    4120. 

  4120.                 if (_blanket.options("instrumentCache") && sessionStorage){
    4121. 

  4121.                     if (_blanket.options("debug")) {console.log("BLANKET-Saving instrumentation to cache: ",inFileName);}
    4122. 

  4122.                     sessionStorage.setItem("blanket_instrument_store-"+inFileName,instrumented);
    4123. 

  4123.                 }
    4124. 

  4124.                 next(instrumented);
    4125. 

  4125.             }
    4126. 

  4126.         },
    4127. 

  4127.         _trackingArraySetup: [],
    4128. 

  4128.         _branchingArraySetup: [],
    4129. 

  4129.         _prepareSource: function(source){
    4130. 

  4130.             return source.replace(/\\/g,"\\\\").replace(/'/g,"\\'").replace(/(\r\n|\n|\r)/gm,"\n").split('\n');
    4131. 

  4131.         },
    4132. 

  4132.         _trackingSetup: function(filename,sourceArray){
    4133. 

  4133.             var branches = _blanket.options("branchTracking");
    4134. 

  4134.             var sourceString = sourceArray.join("',\n'");
    4135. 

  4135.             var intro = "";
    4136. 

  4136.             var covVar = _blanket.getCovVar();
    4137. 

  4137. 

  4138.             intro += "if (typeof "+covVar+" === 'undefined') "+covVar+" = {};\n";
    4139. 

  4139.             if (branches){
    4140. 

  4140.                 intro += "var _$branchFcn=function(f,l,c,r){ ";
    4141. 

  4141.                 intro += "if (!!r) { ";
    4142. 

  4142.                 intro += covVar+"[f].branchData[l][c][0] = "+covVar+"[f].branchData[l][c][0] || [];";
    4143. 

  4143.                 intro += covVar+"[f].branchData[l][c][0].push(r); }";
    4144. 

  4144.                 intro += "else { ";
    4145. 

  4145.                 intro += covVar+"[f].branchData[l][c][1] = "+covVar+"[f].branchData[l][c][1] || [];";
    4146. 

  4146.                 intro += covVar+"[f].branchData[l][c][1].push(r); }";
    4147. 

  4147.                 intro += "return r;};\n";
    4148. 

  4148.             }
    4149. 

  4149.             intro += "if (typeof "+covVar+"['"+filename+"'] === 'undefined'){";
    4150. 

  4150. 

  4151.             intro += covVar+"['"+filename+"']=[];\n";
    4152. 

  4152.             if (branches){
    4153. 

  4153.                 intro += covVar+"['"+filename+"'].branchData=[];\n";
    4154. 

  4154.             }
    4155. 

  4155.             intro += covVar+"['"+filename+"'].source=['"+sourceString+"'];\n";
    4156. 

  4156.             //initialize array values
    4157. 

  4157.             _blanket._trackingArraySetup.sort(function(a,b){
    4158. 

  4158.                 return parseInt(a,10) > parseInt(b,10);
    4159. 

  4159.             }).forEach(function(item){
    4160. 

  4160.                 intro += covVar+"['"+filename+"']["+item+"]=0;\n";
    4161. 

  4161.             });
    4162. 

  4162.             if (branches){
    4163. 

  4163.                 _blanket._branchingArraySetup.sort(function(a,b){
    4164. 

  4164.                     return a.line > b.line;
    4165. 

  4165.                 }).sort(function(a,b){
    4166. 

  4166.                     return a.column > b.column;
    4167. 

  4167.                 }).forEach(function(item){
    4168. 

  4168.                     if (item.file === filename){
    4169. 

  4169.                         intro += "if (typeof "+ covVar+"['"+filename+"'].branchData["+item.line+"] === 'undefined'){\n";
    4170. 

  4170.                         intro += covVar+"['"+filename+"'].branchData["+item.line+"]=[];\n";
    4171. 

  4171.                         intro += "}";
    4172. 

  4172.                         intro += covVar+"['"+filename+"'].branchData["+item.line+"]["+item.column+"] = [];\n";
    4173. 

  4173.                         intro += covVar+"['"+filename+"'].branchData["+item.line+"]["+item.column+"].consequent = "+JSON.stringify(item.consequent)+";\n";
    4174. 

  4174.                         intro += covVar+"['"+filename+"'].branchData["+item.line+"]["+item.column+"].alternate = "+JSON.stringify(item.alternate)+";\n";
    4175. 

  4175.                     }
    4176. 

  4176.                 });
    4177. 

  4177.             }
    4178. 

  4178.             intro += "}";
    4179. 

  4179. 

  4180.             return intro;
    4181. 

  4181.         },
    4182. 

  4182.         _blockifyIf: function(node){
    4183. 

  4183.             if (linesToAddBrackets.indexOf(node.type) > -1){
    4184. 

  4184.                 var bracketsExistObject = node.consequent || node.body;
    4185. 

  4185.                 var bracketsExistAlt = node.alternate;
    4186. 

  4186.                 if( bracketsExistAlt && bracketsExistAlt.type !== "BlockStatement") {
    4187. 

  4187.                     bracketsExistAlt.update("{\n"+bracketsExistAlt.source()+"}\n");
    4188. 

  4188.                 }
    4189. 

  4189.                 if( bracketsExistObject && bracketsExistObject.type !== "BlockStatement") {
    4190. 

  4190.                     bracketsExistObject.update("{\n"+bracketsExistObject.source()+"}\n");
    4191. 

  4191.                 }
    4192. 

  4192.             }
    4193. 

  4193.         },
    4194. 

  4194.         _trackBranch: function(node,filename){
    4195. 

  4195.             //recursive on consequent and alternative
    4196. 

  4196.             var line = node.loc.start.line;
    4197. 

  4197.             var col = node.loc.start.column;
    4198. 

  4198. 

  4199.             _blanket._branchingArraySetup.push({
    4200. 

  4200.                 line: line,
    4201. 

  4201.                 column: col,
    4202. 

  4202.                 file:filename,
    4203. 

  4203.                 consequent: node.consequent.loc,
    4204. 

  4204.                 alternate: node.alternate.loc
    4205. 

  4205.             });
    4206. 

  4206. 

  4207.             var source = node.source();
    4208. 

  4208.             var updated = "_$branchFcn"+
    4209. 

  4209.                           "('"+filename+"',"+line+","+col+","+source.slice(0,source.indexOf("?"))+
    4210. 

  4210.                           ")"+source.slice(source.indexOf("?"));
    4211. 

  4211.             node.update(updated);
    4212. 

  4212.         },
    4213. 

  4213.         _addTracking: function (filename) {
    4214. 

  4214.             //falafel doesn't take a file name
    4215. 

  4215.             //so we include the filename in a closure
    4216. 

  4216.             //and return the function to falafel
    4217. 

  4217.             var covVar = _blanket.getCovVar();
    4218. 

  4218. 

  4219.             return function(node){
    4220. 

  4220.                 _blanket._blockifyIf(node);
    4221. 

  4221. 

  4222.                 if (linesToAddTracking.indexOf(node.type) > -1 && node.parent.type !== "LabeledStatement") {
    4223. 

  4223.                     _blanket._checkDefs(node,filename);
    4224. 

  4224.                     if (node.type === "VariableDeclaration" &&
    4225. 

  4225.                         (node.parent.type === "ForStatement" || node.parent.type === "ForInStatement")){
    4226. 

  4226.                         return;
    4227. 

  4227.                     }
    4228. 

  4228.                     if (node.loc && node.loc.start){
    4229. 

  4229.                         node.update(covVar+"['"+filename+"']["+node.loc.start.line+"]++;\n"+node.source());
    4230. 

  4230.                         _blanket._trackingArraySetup.push(node.loc.start.line);
    4231. 

  4231.                     }else{
    4232. 

  4232.                         //I don't think we can handle a node with no location
    4233. 

  4233.                         throw new Error("The instrumenter encountered a node with no location: "+Object.keys(node));
    4234. 

  4234.                     }
    4235. 

  4235.                 }else if (_blanket.options("branchTracking") && node.type === "ConditionalExpression"){
    4236. 

  4236.                     _blanket._trackBranch(node,filename);
    4237. 

  4237.                 }
    4238. 

  4238.             };
    4239. 

  4239.         },
    4240. 

  4240.         _checkDefs: function(node,filename){
    4241. 

  4241.             // Make sure developers don't redefine window. if they do, inform them it is wrong.
    4242. 

  4242.             if (inBrowser){
    4243. 

  4243.                 if (node.type === "VariableDeclaration" && node.declarations) {
    4244. 

  4244.                     node.declarations.forEach(function(declaration) {
    4245. 

  4245.                         if (declaration.id.name === "window") {
    4246. 

  4246.                             throw new Error("Instrumentation error, you cannot redefine the 'window' variable in  " + filename + ":" + node.loc.start.line);
    4247. 

  4247.                         }
    4248. 

  4248.                     });
    4249. 

  4249.                 }
    4250. 

  4250.                 if (node.type === "FunctionDeclaration" && node.params) {
    4251. 

  4251.                     node.params.forEach(function(param) {
    4252. 

  4252.                         if (param.name === "window") {
    4253. 

  4253.                             throw new Error("Instrumentation error, you cannot redefine the 'window' variable in  " + filename + ":" + node.loc.start.line);
    4254. 

  4254.                         }
    4255. 

  4255.                     });
    4256. 

  4256.                 }
    4257. 

  4257.                 //Make sure developers don't redefine the coverage variable
    4258. 

  4258.                 if (node.type === "ExpressionStatement" &&
    4259. 

  4259.                     node.expression && node.expression.left &&
    4260. 

  4260.                     node.expression.left.object && node.expression.left.property &&
    4261. 

  4261.                     node.expression.left.object.name +
    4262. 

  4262.                         "." + node.expression.left.property.name === _blanket.getCovVar()) {
    4263. 

  4263.                     throw new Error("Instrumentation error, you cannot redefine the coverage variable in  " + filename + ":" + node.loc.start.line);
    4264. 

  4264.                 }
    4265. 

  4265.             }else{
    4266. 

  4266.                 //Make sure developers don't redefine the coverage variable in node
    4267. 

  4267.                 if (node.type === "ExpressionStatement" &&
    4268. 

  4268.                     node.expression && node.expression.left &&
    4269. 

  4269.                     !node.expression.left.object && !node.expression.left.property &&
    4270. 

  4270.                     node.expression.left.name === _blanket.getCovVar()) {
    4271. 

  4271.                     throw new Error("Instrumentation error, you cannot redefine the coverage variable in  " + filename + ":" + node.loc.start.line);
    4272. 

  4272.                 }
    4273. 

  4273.             }
    4274. 

  4274.         },
    4275. 

  4275.         setupCoverage: function(){
    4276. 

  4276.             coverageInfo.instrumentation = "blanket";
    4277. 

  4277.             coverageInfo.stats = {
    4278. 

  4278.                 "suites": 0,
    4279. 

  4279.                 "tests": 0,
    4280. 

  4280.                 "passes": 0,
    4281. 

  4281.                 "pending": 0,
    4282. 

  4282.                 "failures": 0,
    4283. 

  4283.                 "start": new Date()
    4284. 

  4284.             };
    4285. 

  4285.         },
    4286. 

  4286.         _checkIfSetup: function(){
    4287. 

  4287.             if (!coverageInfo.stats){
    4288. 

  4288.                 throw new Error("You must call blanket.setupCoverage() first.");
    4289. 

  4289.             }
    4290. 

  4290.         },
    4291. 

  4291.         onTestStart: function(){
    4292. 

  4292.             if (_blanket.options("debug")) {console.log("BLANKET-Test event started");}
    4293. 

  4293.             this._checkIfSetup();
    4294. 

  4294.             coverageInfo.stats.tests++;
    4295. 

  4295.             coverageInfo.stats.pending++;
    4296. 

  4296.         },
    4297. 

  4297.         onTestDone: function(total,passed){
    4298. 

  4298.             this._checkIfSetup();
    4299. 

  4299.             if(passed === total){
    4300. 

  4300.                 coverageInfo.stats.passes++;
    4301. 

  4301.             }else{
    4302. 

  4302.                 coverageInfo.stats.failures++;
    4303. 

  4303.             }
    4304. 

  4304.             coverageInfo.stats.pending--;
    4305. 

  4305.         },
    4306. 

  4306.         onModuleStart: function(){
    4307. 

  4307.             this._checkIfSetup();
    4308. 

  4308.             coverageInfo.stats.suites++;
    4309. 

  4309.         },
    4310. 

  4310.         onTestsDone: function(){
    4311. 

  4311.             if (_blanket.options("debug")) {console.log("BLANKET-Test event done");}
    4312. 

  4312.             this._checkIfSetup();
    4313. 

  4313.             coverageInfo.stats.end = new Date();
    4314. 

  4314. 

  4315.             if (inBrowser){
    4316. 

  4316.                 this.report(coverageInfo);
    4317. 

  4317.             }else{
    4318. 

  4318.                 if (!_blanket.options("branchTracking")){
    4319. 

  4319.                     delete (inBrowser ? window : global)[_blanket.getCovVar()].branchFcn;
    4320. 

  4320.                 }
    4321. 

  4321.                 this.options("reporter").call(this,coverageInfo);
    4322. 

  4322.             }
    4323. 

  4323.         }
    4324. 

  4324.     };
    4325. 

  4325.     return _blanket;
    4326. 

  4326. })();
    4327. 

  4327. 

  4328. (function(_blanket){
    4329. 

  4329.     var oldOptions = _blanket.options;
    4330. 

  4330. _blanket.extend({
    4331. 

  4331.     outstandingRequireFiles:[],
    4332. 

  4332.     options: function(key,value){
    4333. 

  4333.         var newVal={};
    4334. 

  4334. 

  4335.         if (typeof key !== "string"){
    4336. 

  4336.             //key is key/value map
    4337. 

  4337.             oldOptions(key);
    4338. 

  4338.             newVal = key;
    4339. 

  4339.         }else if (typeof value === 'undefined'){
    4340. 

  4340.             //accessor
    4341. 

  4341.             return oldOptions(key);
    4342. 

  4342.         }else{
    4343. 

  4343.             //setter
    4344. 

  4344.             oldOptions(key,value);
    4345. 

  4345.             newVal[key] = value;
    4346. 

  4346.         }
    4347. 

  4347. 

  4348.         if (newVal.adapter){
    4349. 

  4349.             _blanket._loadFile(newVal.adapter);
    4350. 

  4350.         }
    4351. 

  4351.         if (newVal.loader){
    4352. 

  4352.             _blanket._loadFile(newVal.loader);
    4353. 

  4353.         }
    4354. 

  4354.     },
    4355. 

  4355.     requiringFile: function(filename,done){
    4356. 

  4356.         if (typeof filename === "undefined"){
    4357. 

  4357.             _blanket.outstandingRequireFiles=[];
    4358. 

  4358.         }else if (typeof done === "undefined"){
    4359. 

  4359.             _blanket.outstandingRequireFiles.push(filename);
    4360. 

  4360.         }else{
    4361. 

  4361.             _blanket.outstandingRequireFiles.splice(_blanket.outstandingRequireFiles.indexOf(filename),1);
    4362. 

  4362.         }
    4363. 

  4363.     },
    4364. 

  4364.     requireFilesLoaded: function(){
    4365. 

  4365.         return _blanket.outstandingRequireFiles.length === 0;
    4366. 

  4366.     },
    4367. 

  4367.     showManualLoader: function(){
    4368. 

  4368.         if (document.getElementById("blanketLoaderDialog")){
    4369. 

  4369.             return;
    4370. 

  4370.         }
    4371. 

  4371.         //copied from http://blog.avtex.com/2012/01/26/cross-browser-css-only-modal-box/
    4372. 

  4372.         var loader = "<div class='blanketDialogOverlay'>";
    4373. 

  4373.             loader += "&nbsp;</div>";
    4374. 

  4374.             loader += "<div class='blanketDialogVerticalOffset'>";
    4375. 

  4375.             loader += "<div class='blanketDialogBox'>";
    4376. 

  4376.             loader += "<b>Error:</b> Blanket.js encountered a cross origin request error while instrumenting the source files.  ";
    4377. 

  4377.             loader += "<br><br>This is likely caused by the source files being referenced locally (using the file:// protocol). ";
    4378. 

  4378.             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).";
    4379. 

  4379.             loader += "<br>";
    4380. 

  4380.             if (typeof FileReader !== "undefined"){
    4381. 

  4381.                 loader += "<br>Or, try the experimental loader.  When prompted, simply click on the directory containing all the source files you want covered.";
    4382. 

  4382.                 loader += "<a href='javascript:document.getElementById(\"fileInput\").click();'>Start Loader</a>";
    4383. 

  4383.                 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'/>";
    4384. 

  4384.             }
    4385. 

  4385.             loader += "<br><span style='float:right;cursor:pointer;'  onclick=document.getElementById('blanketLoaderDialog').style.display='none';>Close</span>";
    4386. 

  4386.             loader += "<div style='clear:both'></div>";
    4387. 

  4387.             loader += "</div></div>";
    4388. 

  4388. 

  4389.         var css = ".blanketDialogWrapper {";
    4390. 

  4390.             css += "display:block;";
    4391. 

  4391.             css += "position:fixed;";
    4392. 

  4392.             css += "z-index:40001; }";
    4393. 

  4393. 

  4394.             css += ".blanketDialogOverlay {";
    4395. 

  4395.             css += "position:fixed;";
    4396. 

  4396.             css += "width:100%;";
    4397. 

  4397.             css += "height:100%;";
    4398. 

  4398.             css += "background-color:black;";
    4399. 

  4399.             css += "opacity:.5; ";
    4400. 

  4400.             css += "-ms-filter:'progid:DXImageTransform.Microsoft.Alpha(Opacity=50)'; ";
    4401. 

  4401.             css += "filter:alpha(opacity=50); ";
    4402. 

  4402.             css += "z-index:40001; }";
    4403. 

  4403. 

  4404.             css += ".blanketDialogVerticalOffset { ";
    4405. 

  4405.             css += "position:fixed;";
    4406. 

  4406.             css += "top:30%;";
    4407. 

  4407.             css += "width:100%;";
    4408. 

  4408.             css += "z-index:40002; }";
    4409. 

  4409. 

  4410.             css += ".blanketDialogBox { ";
    4411. 

  4411.             css += "width:405px; ";
    4412. 

  4412.             css += "position:relative;";
    4413. 

  4413.             css += "margin:0 auto;";
    4414. 

  4414.             css += "background-color:white;";
    4415. 

  4415.             css += "padding:10px;";
    4416. 

  4416.             css += "border:1px solid black; }";
    4417. 

  4417. 

  4418.         var dom = document.createElement("style");
    4419. 

  4419.         dom.innerHTML = css;
    4420. 

  4420.         document.head.appendChild(dom);
    4421. 

  4421. 

  4422.         var div = document.createElement("div");
    4423. 

  4423.         div.id = "blanketLoaderDialog";
    4424. 

  4424.         div.className = "blanketDialogWrapper";
    4425. 

  4425.         div.innerHTML = loader;
    4426. 

  4426.         document.body.insertBefore(div,document.body.firstChild);
    4427. 

  4427. 

  4428.     },
    4429. 

  4429.     manualFileLoader: function(files){
    4430. 

  4430.         var toArray =Array.prototype.slice;
    4431. 

  4431.         files = toArray.call(files).filter(function(item){
    4432. 

  4432.             return item.type !== "";
    4433. 

  4433.         });
    4434. 

  4434.         var sessionLength = files.length-1;
    4435. 

  4435.         var sessionIndx=0;
    4436. 

  4436.         var sessionArray = {};
    4437. 

  4437.         if (sessionStorage["blanketSessionLoader"]){
    4438. 

  4438.             sessionArray = JSON.parse(sessionStorage["blanketSessionLoader"]);
    4439. 

  4439.         }
    4440. 

  4440. 

  4441. 

  4442.         var fileLoader = function(event){
    4443. 

  4443.             var fileContent = event.currentTarget.result;
    4444. 

  4444.             var file = files[sessionIndx];
    4445. 

  4445.             var filename = file.webkitRelativePath && file.webkitRelativePath !== '' ? file.webkitRelativePath : file.name;
    4446. 

  4446.             sessionArray[filename] = fileContent;
    4447. 

  4447.             sessionIndx++;
    4448. 

  4448.             if (sessionIndx === sessionLength){
    4449. 

  4449.                 sessionStorage.setItem("blanketSessionLoader", JSON.stringify(sessionArray));
    4450. 

  4450.                 document.location.reload();
    4451. 

  4451.             }else{
    4452. 

  4452.                 readFile(files[sessionIndx]);
    4453. 

  4453.             }
    4454. 

  4454.         };
    4455. 

  4455.         function readFile(file){
    4456. 

  4456.             var reader = new FileReader();
    4457. 

  4457.             reader.onload = fileLoader;
    4458. 

  4458.             reader.readAsText(file);
    4459. 

  4459.         }
    4460. 

  4460.         readFile(files[sessionIndx]);
    4461. 

  4461.     },
    4462. 

  4462.     _loadFile: function(path){
    4463. 

  4463.         if (typeof path !== "undefined"){
    4464. 

  4464.             var request = new XMLHttpRequest();
    4465. 

  4465.             request.open('GET', path, false);
    4466. 

  4466.             request.send();
    4467. 

  4467.             _blanket._addScript(request.responseText);
    4468. 

  4468.         }
    4469. 

  4469.     },
    4470. 

  4470.     _addScript: function(data){
    4471. 

  4471.         var script = document.createElement("script");
    4472. 

  4472.         script.type = "text/javascript";
    4473. 

  4473.         script.text = data;
    4474. 

  4474.         (document.body || document.getElementsByTagName('head')[0]).appendChild(script);
    4475. 

  4475.     },
    4476. 

  4476.     hasAdapter: function(callback){
    4477. 

  4477.         return _blanket.options("adapter") !== null;
    4478. 

  4478.     },
    4479. 

  4479.     report: function(coverage_data){
    4480. 

  4480.         if (!document.getElementById("blanketLoaderDialog")){
    4481. 

  4481.             //all found, clear it
    4482. 

  4482.             _blanket.blanketSession = null;
    4483. 

  4483.         }
    4484. 

  4484.         coverage_data.files = window._$blanket;
    4485. 

  4485.         var require = blanket.options("commonJS") ? blanket._commonjs.require : window.require;
    4486. 

  4486. 

  4487.         // Check if we have any covered files that requires reporting
    4488. 

  4488.         // otherwise just exit gracefully.
    4489. 

  4489.         if (!coverage_data.files || !Object.keys(coverage_data.files).length) {
    4490. 

  4490.             if (_blanket.options("debug")) {console.log("BLANKET-Reporting No files were instrumented.");}
    4491. 

  4491.             return;
    4492. 

  4492.         }
    4493. 

  4493. 

  4494.         if (typeof coverage_data.files.branchFcn !== "undefined"){
    4495. 

  4495.             delete coverage_data.files.branchFcn;
    4496. 

  4496.         }
    4497. 

  4497.         if (typeof _blanket.options("reporter") === "string"){
    4498. 

  4498.             _blanket._loadFile(_blanket.options("reporter"));
    4499. 

  4499.             _blanket.customReporter(coverage_data,_blanket.options("reporter_options"));
    4500. 

  4500.         }else if (typeof _blanket.options("reporter") === "function"){
    4501. 

  4501.             _blanket.options("reporter")(coverage_data);
    4502. 

  4502.         }else if (typeof _blanket.defaultReporter === 'function'){
    4503. 

  4503.             _blanket.defaultReporter(coverage_data);
    4504. 

  4504.         }else{
    4505. 

  4505.             throw new Error("no reporter defined.");
    4506. 

  4506.         }
    4507. 

  4507.     },
    4508. 

  4508.     _bindStartTestRunner: function(bindEvent,startEvent){
    4509. 

  4509.         if (bindEvent){
    4510. 

  4510.             bindEvent(startEvent);
    4511. 

  4511.         }else{
    4512. 

  4512.             window.addEventListener("load",startEvent,false);
    4513. 

  4513.         }
    4514. 

  4514.     },
    4515. 

  4515.     _loadSourceFiles: function(callback){
    4516. 

  4516.         var require = blanket.options("commonJS") ? blanket._commonjs.require : window.require;
    4517. 

  4517.         function copy(o){
    4518. 

  4518.           var _copy = Object.create( Object.getPrototypeOf(o) );
    4519. 

  4519.           var propNames = Object.getOwnPropertyNames(o);
    4520. 

  4520. 

  4521.           propNames.forEach(function(name){
    4522. 

  4522.             var desc = Object.getOwnPropertyDescriptor(o, name);
    4523. 

  4523.             Object.defineProperty(_copy, name, desc);
    4524. 

  4524.           });
    4525. 

  4525. 

  4526.           return _copy;
    4527. 

  4527.         }
    4528. 

  4528.         if (_blanket.options("debug")) {console.log("BLANKET-Collecting page scripts");}
    4529. 

  4529.         var scripts = _blanket.utils.collectPageScripts();
    4530. 

  4530.         //_blanket.options("filter",scripts);
    4531. 

  4531.         if (scripts.length === 0){
    4532. 

  4532.             callback();
    4533. 

  4533.         }else{
    4534. 

  4534. 

  4535.             //check session state
    4536. 

  4536.             if (sessionStorage["blanketSessionLoader"]){
    4537. 

  4537.                 _blanket.blanketSession = JSON.parse(sessionStorage["blanketSessionLoader"]);
    4538. 

  4538.             }
    4539. 

  4539.             
    4540. 

  4540.             scripts.forEach(function(file,indx){   
    4541. 

  4541.                 _blanket.utils.cache[file+".js"]={
    4542. 

  4542.                     loaded:false
    4543. 

  4543.                 };
    4544. 

  4544.             });
    4545. 

  4545.             
    4546. 

  4546.             var currScript=-1;
    4547. 

  4547.             _blanket.utils.loadAll(function(test){
    4548. 

  4548.                 if (test){
    4549. 

  4549.                   return typeof scripts[currScript+1] !== 'undefined';
    4550. 

  4550.                 }
    4551. 

  4551.                 currScript++;
    4552. 

  4552.                 if (currScript >= scripts.length){
    4553. 

  4553.                   return null;
    4554. 

  4554.                 }
    4555. 

  4555.                 return scripts[currScript]+".js";
    4556. 

  4556.             },callback);
    4557. 

  4557.         }
    4558. 

  4558.     },
    4559. 

  4559.     beforeStartTestRunner: function(opts){
    4560. 

  4560.         opts = opts || {};
    4561. 

  4561.         opts.checkRequirejs = typeof opts.checkRequirejs === "undefined" ? true : opts.checkRequirejs;
    4562. 

  4562.         opts.callback = opts.callback || function() {  };
    4563. 

  4563.         opts.coverage = typeof opts.coverage === "undefined" ? true : opts.coverage;
    4564. 

  4564.         if (opts.coverage) {
    4565. 

  4565.             _blanket._bindStartTestRunner(opts.bindEvent,
    4566. 

  4566.             function(){
    4567. 

  4567.                 _blanket._loadSourceFiles(function() {
    4568. 

  4568. 

  4569.                     var allLoaded = function(){
    4570. 

  4570.                         return opts.condition ? opts.condition() : _blanket.requireFilesLoaded();
    4571. 

  4571.                     };
    4572. 

  4572.                     var check = function() {
    4573. 

  4573.                         if (allLoaded()) {
    4574. 

  4574.                             if (_blanket.options("debug")) {console.log("BLANKET-All files loaded, init start test runner callback.");}
    4575. 

  4575.                             var cb = _blanket.options("testReadyCallback");
    4576. 

  4576. 

  4577.                             if (cb){
    4578. 

  4578.                                 if (typeof cb === "function"){
    4579. 

  4579.                                     cb(opts.callback);
    4580. 

  4580.                                 }else if (typeof cb === "string"){
    4581. 

  4581.                                     _blanket._addScript(cb);
    4582. 

  4582.                                     opts.callback();
    4583. 

  4583.                                 }
    4584. 

  4584.                             }else{
    4585. 

  4585.                                 opts.callback();
    4586. 

  4586.                             }
    4587. 

  4587.                         } else {
    4588. 

  4588.                             setTimeout(check, 13);
    4589. 

  4589.                         }
    4590. 

  4590.                     };
    4591. 

  4591.                     check();
    4592. 

  4592.                 });
    4593. 

  4593.             });
    4594. 

  4594.         }else{
    4595. 

  4595.             opts.callback();
    4596. 

  4596.         }
    4597. 

  4597.     },
    4598. 

  4598.     utils: {
    4599. 

  4599.         qualifyURL: function (url) {
    4600. 

  4600.             //http://stackoverflow.com/questions/470832/getting-an-absolute-url-from-a-relative-one-ie6-issue
    4601. 

  4601.             var a = document.createElement('a');
    4602. 

  4602.             a.href = url;
    4603. 

  4603.             return a.href;
    4604. 

  4604.         }
    4605. 

  4605.     }
    4606. 

  4606. });
    4607. 

  4607. 

  4608. })(blanket);
    4609. 

  4609. 

  4610. blanket.defaultReporter = function(coverage){
    4611. 

  4611.     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;}",
    4612. 

  4612.         successRate = 60,
    4613. 

  4613.         head = document.head,
    4614. 

  4614.         fileNumber = 0,
    4615. 

  4615.         body = document.body,
    4616. 

  4616.         headerContent,
    4617. 

  4617.         hasBranchTracking = Object.keys(coverage.files).some(function(elem){
    4618. 

  4618.           return typeof coverage.files[elem].branchData !== 'undefined';
    4619. 

  4619.         }),
    4620. 

  4620.         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>",
    4621. 

  4621.         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>";
    4622. 

  4622.         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>";
    4623. 

  4623. 

  4624.     function blanket_toggleSource(id) {
    4625. 

  4625.         var element = document.getElementById(id);
    4626. 

  4626.         if(element.style.display === 'block') {
    4627. 

  4627.             element.style.display = 'none';
    4628. 

  4628.         } else {
    4629. 

  4629.             element.style.display = 'block';
    4630. 

  4630.         }
    4631. 

  4631.     }
    4632. 

  4632. 

  4633. 

  4634.     var script = document.createElement("script");
    4635. 

  4635.     script.type = "text/javascript";
    4636. 

  4636.     script.text = blanket_toggleSource.toString().replace('function ' + blanket_toggleSource.name, 'function blanket_toggleSource');
    4637. 

  4637.     body.appendChild(script);
    4638. 

  4638. 

  4639.     var percentage = function(number, total) {
    4640. 

  4640.         return (Math.round(((number/total) * 100)*100)/100);
    4641. 

  4641.     };
    4642. 

  4642. 

  4643.     var appendTag = function (type, el, str) {
    4644. 

  4644.         var dom = document.createElement(type);
    4645. 

  4645.         dom.innerHTML = str;
    4646. 

  4646.         el.appendChild(dom);
    4647. 

  4647.     };
    4648. 

  4648. 

  4649.     function escapeInvalidXmlChars(str) {
    4650. 

  4650.         return str.replace(/\&/g, "&amp;")
    4651. 

  4651.             .replace(/</g, "&lt;")
    4652. 

  4652.             .replace(/\>/g, "&gt;")
    4653. 

  4653.             .replace(/\"/g, "&quot;")
    4654. 

  4654.             .replace(/\'/g, "&apos;");
    4655. 

  4655.     }
    4656. 

  4656. 

  4657.     function isBranchFollowed(data,bool){
    4658. 

  4658.         var mode = bool ? 0 : 1;
    4659. 

  4659.         if (typeof data === 'undefined' ||
    4660. 

  4660.             typeof data === null ||
    4661. 

  4661.             typeof data[mode] === 'undefined'){
    4662. 

  4662.             return false;
    4663. 

  4663.         }
    4664. 

  4664.         return data[mode].length > 0;
    4665. 

  4665.     }
    4666. 

  4666. 

  4667.     var branchStack = [];
    4668. 

  4668. 

  4669.     function branchReport(colsIndex,src,cols,offset,lineNum){
    4670. 

  4670.       var newsrc="";
    4671. 

  4671.        var postfix="";
    4672. 

  4672.       if (branchStack.length > 0){
    4673. 

  4673.         newsrc += "<span class='" + (isBranchFollowed(branchStack[0][1],branchStack[0][1].consequent === branchStack[0][0]) ? 'branchOkay' : 'branchWarning') + "'>";
    4674. 

  4674.         if (branchStack[0][0].end.line === lineNum){
    4675. 

  4675.           newsrc += escapeInvalidXmlChars(src.slice(0,branchStack[0][0].end.column)) + "</span>";
    4676. 

  4676.           src = src.slice(branchStack[0][0].end.column);
    4677. 

  4677.           branchStack.shift();
    4678. 

  4678.           if (branchStack.length > 0){
    4679. 

  4679.             newsrc += "<span class='" + (isBranchFollowed(branchStack[0][1],false) ? 'branchOkay' : 'branchWarning') + "'>";
    4680. 

  4680.             if (branchStack[0][0].end.line === lineNum){
    4681. 

  4681.               newsrc += escapeInvalidXmlChars(src.slice(0,branchStack[0][0].end.column)) + "</span>";
    4682. 

  4682.               src = src.slice(branchStack[0][0].end.column);
    4683. 

  4683.               branchStack.shift();
    4684. 

  4684.               if (!cols){
    4685. 

  4685.                 return {src: newsrc + escapeInvalidXmlChars(src) ,cols:cols};
    4686. 

  4686.               }
    4687. 

  4687.             }
    4688. 

  4688.             else if (!cols){
    4689. 

  4689.               return {src: newsrc + escapeInvalidXmlChars(src) + "</span>",cols:cols};
    4690. 

  4690.             }
    4691. 

  4691.             else{
    4692. 

  4692.               postfix = "</span>";
    4693. 

  4693.             }
    4694. 

  4694.           }else if (!cols){
    4695. 

  4695.             return {src: newsrc + escapeInvalidXmlChars(src) ,cols:cols};
    4696. 

  4696.           }
    4697. 

  4697.         }else if(!cols){
    4698. 

  4698.           return {src: newsrc + escapeInvalidXmlChars(src) + "</span>",cols:cols};
    4699. 

  4699.         }else{
    4700. 

  4700.           postfix = "</span>";
    4701. 

  4701.         }
    4702. 

  4702.       }
    4703. 

  4703.       var thisline = cols[colsIndex];
    4704. 

  4704.       //consequent
    4705. 

  4705.       
    4706. 

  4706.       var cons = thisline.consequent;
    4707. 

  4707.       if (cons.start.line > lineNum){
    4708. 

  4708.         branchStack.unshift([thisline.alternate,thisline]);
    4709. 

  4709.         branchStack.unshift([cons,thisline]);
    4710. 

  4710.         src = escapeInvalidXmlChars(src);
    4711. 

  4711.       }else{
    4712. 

  4712.         var style = "<span class='" + (isBranchFollowed(thisline,true) ? 'branchOkay' : 'branchWarning') + "'>";
    4713. 

  4713.         newsrc += escapeInvalidXmlChars(src.slice(0,cons.start.column-offset)) + style;
    4714. 

  4714.         
    4715. 

  4715.         if (cols.length > colsIndex+1 &&
    4716. 

  4716.           cols[colsIndex+1].consequent.start.line === lineNum &&
    4717. 

  4717.           cols[colsIndex+1].consequent.start.column-offset < cols[colsIndex].consequent.end.column-offset)
    4718. 

  4718.         {
    4719. 

  4719.           var res = branchReport(colsIndex+1,src.slice(cons.start.column-offset,cons.end.column-offset),cols,cons.start.column-offset,lineNum);
    4720. 

  4720.           newsrc += res.src;
    4721. 

  4721.           cols = res.cols;
    4722. 

  4722.           cols[colsIndex+1] = cols[colsIndex+2];
    4723. 

  4723.           cols.length--;
    4724. 

  4724.         }else{
    4725. 

  4725.           newsrc += escapeInvalidXmlChars(src.slice(cons.start.column-offset,cons.end.column-offset));
    4726. 

  4726.         }
    4727. 

  4727.         newsrc += "</span>";
    4728. 

  4728. 

  4729.         var alt = thisline.alternate;
    4730. 

  4730.         if (alt.start.line > lineNum){
    4731. 

  4731.           newsrc += escapeInvalidXmlChars(src.slice(cons.end.column-offset));
    4732. 

  4732.           branchStack.unshift([alt,thisline]);
    4733. 

  4733.         }else{
    4734. 

  4734.           newsrc += escapeInvalidXmlChars(src.slice(cons.end.column-offset,alt.start.column-offset));
    4735. 

  4735.           style = "<span class='" + (isBranchFollowed(thisline,false) ? 'branchOkay' : 'branchWarning') + "'>";
    4736. 

  4736.           newsrc +=  style;
    4737. 

  4737.           if (cols.length > colsIndex+1 &&
    4738. 

  4738.             cols[colsIndex+1].consequent.start.line === lineNum &&
    4739. 

  4739.             cols[colsIndex+1].consequent.start.column-offset < cols[colsIndex].alternate.end.column-offset)
    4740. 

  4740.           {
    4741. 

  4741.             var res2 = branchReport(colsIndex+1,src.slice(alt.start.column-offset,alt.end.column-offset),cols,alt.start.column-offset,lineNum);
    4742. 

  4742.             newsrc += res2.src;
    4743. 

  4743.             cols = res2.cols;
    4744. 

  4744.             cols[colsIndex+1] = cols[colsIndex+2];
    4745. 

  4745.             cols.length--;
    4746. 

  4746.           }else{
    4747. 

  4747.             newsrc += escapeInvalidXmlChars(src.slice(alt.start.column-offset,alt.end.column-offset));
    4748. 

  4748.           }
    4749. 

  4749.           newsrc += "</span>";
    4750. 

  4750.           newsrc += escapeInvalidXmlChars(src.slice(alt.end.column-offset));
    4751. 

  4751.           src = newsrc;
    4752. 

  4752.         }
    4753. 

  4753.       }
    4754. 

  4754.       return {src:src+postfix, cols:cols};
    4755. 

  4755.     }
    4756. 

  4756. 

  4757.     var isUndefined =  function(item){
    4758. 

  4758.             return typeof item !== 'undefined';
    4759. 

  4759.       };
    4760. 

  4760. 

  4761.     var files = coverage.files;
    4762. 

  4762.     var totals = {
    4763. 

  4763.       totalSmts: 0,
    4764. 

  4764.       numberOfFilesCovered: 0,
    4765. 

  4765.       passedBranches: 0,
    4766. 

  4766.       totalBranches: 0,
    4767. 

  4767.       moduleTotalStatements : {},
    4768. 

  4768.       moduleTotalCoveredStatements : {},
    4769. 

  4769.       moduleTotalBranches : {},
    4770. 

  4770.       moduleTotalCoveredBranches : {}   
    4771. 

  4771.     };
    4772. 

  4772. 

  4773.     // check if a data-cover-modulepattern was provided for per-module coverage reporting
    4774. 

  4774.     var modulePattern = _blanket.options("modulePattern");
    4775. 

  4775.     var modulePatternRegex = ( modulePattern ? new RegExp(modulePattern) : null );    
    4776. 

  4776. 

  4777.     for(var file in files)
    4778. 

  4778.     {
    4779. 

  4779.         fileNumber++;
    4780. 

  4780. 

  4781.         var statsForFile = files[file],
    4782. 

  4782.             totalSmts = 0,
    4783. 

  4783.             numberOfFilesCovered = 0,
    4784. 

  4784.             code = [],
    4785. 

  4785.             i;
    4786. 

  4786.         
    4787. 

  4787. 

  4788.         var end = [];
    4789. 

  4789.         for(i = 0; i < statsForFile.source.length; i +=1){
    4790. 

  4790.             var src = statsForFile.source[i];
    4791. 

  4791.             
    4792. 

  4792.             if (branchStack.length > 0 ||
    4793. 

  4793.                 typeof statsForFile.branchData !== 'undefined')
    4794. 

  4794.             {
    4795. 

  4795.                 if (typeof statsForFile.branchData[i+1] !== 'undefined')
    4796. 

  4796.                 {
    4797. 

  4797.                   var cols = statsForFile.branchData[i+1].filter(isUndefined);
    4798. 

  4798.                   var colsIndex=0;
    4799. 

  4799.                   
    4800. 

  4800.                     
    4801. 

  4801.                   src = branchReport(colsIndex,src,cols,0,i+1).src;
    4802. 

  4802.                   
    4803. 

  4803.                 }else if (branchStack.length){
    4804. 

  4804.                   src = branchReport(0,src,null,0,i+1).src;
    4805. 

  4805.                 }else{
    4806. 

  4806.                   src = escapeInvalidXmlChars(src);
    4807. 

  4807.                 }
    4808. 

  4808.               }else{
    4809. 

  4809.                 src = escapeInvalidXmlChars(src);
    4810. 

  4810.               }
    4811. 

  4811.               var lineClass="";
    4812. 

  4812.               if(statsForFile[i+1]) {
    4813. 

  4813.                 numberOfFilesCovered += 1;
    4814. 

  4814.                 totalSmts += 1;
    4815. 

  4815.                 lineClass = 'hit';
    4816. 

  4816.               }else{
    4817. 

  4817.                 if(statsForFile[i+1] === 0){
    4818. 

  4818.                     totalSmts++;
    4819. 

  4819.                     lineClass = 'miss';
    4820. 

  4820.                 }
    4821. 

  4821.               }
    4822. 

  4822.               code[i + 1] = "<div class='"+lineClass+"'><span class=''>"+(i + 1)+"</span>"+src+"</div>";
    4823. 

  4823.         }
    4824. 

  4824.         totals.totalSmts += totalSmts;
    4825. 

  4825.         totals.numberOfFilesCovered += numberOfFilesCovered;
    4826. 

  4826.         var totalBranches=0;
    4827. 

  4827.         var passedBranches=0;
    4828. 

  4828.         if (typeof statsForFile.branchData !== 'undefined'){
    4829. 

  4829.           for(var j=0;j<statsForFile.branchData.length;j++){
    4830. 

  4830.             if (typeof statsForFile.branchData[j] !== 'undefined'){
    4831. 

  4831.               for(var k=0;k<statsForFile.branchData[j].length;k++){
    4832. 

  4832.                 if (typeof statsForFile.branchData[j][k] !== 'undefined'){
    4833. 

  4833.                   totalBranches++;
    4834. 

  4834.                   if (typeof statsForFile.branchData[j][k][0] !== 'undefined' &&
    4835. 

  4835.                     statsForFile.branchData[j][k][0].length > 0 &&
    4836. 

  4836.                     typeof statsForFile.branchData[j][k][1] !== 'undefined' &&
    4837. 

  4837.                     statsForFile.branchData[j][k][1].length > 0){
    4838. 

  4838.                     passedBranches++;
    4839. 

  4839.                   }
    4840. 

  4840.                 }
    4841. 

  4841.               }
    4842. 

  4842.             }
    4843. 

  4843.           }
    4844. 

  4844.         }
    4845. 

  4845.         totals.passedBranches += passedBranches;
    4846. 

  4846.         totals.totalBranches += totalBranches;
    4847. 

  4847. 

  4848.         // if "data-cover-modulepattern" was provided, 
    4849. 

  4849.         // track totals per module name as well as globally
    4850. 

  4850.         if (modulePatternRegex) {
    4851. 

  4851.             var moduleName = file.match(modulePatternRegex)[1];
    4852. 

  4852. 

  4853.             if(!totals.moduleTotalStatements.hasOwnProperty(moduleName)) {
    4854. 

  4854.                 totals.moduleTotalStatements[moduleName] = 0;
    4855. 

  4855.                 totals.moduleTotalCoveredStatements[moduleName] = 0;
    4856. 

  4856.             }
    4857. 

  4857. 

  4858.             totals.moduleTotalStatements[moduleName] += totalSmts;
    4859. 

  4859.             totals.moduleTotalCoveredStatements[moduleName] += numberOfFilesCovered;
    4860. 

  4860. 

  4861.             if(!totals.moduleTotalBranches.hasOwnProperty(moduleName)) {
    4862. 

  4862.                 totals.moduleTotalBranches[moduleName] = 0;
    4863. 

  4863.                 totals.moduleTotalCoveredBranches[moduleName] = 0;
    4864. 

  4864.             }
    4865. 

  4865. 

  4866.             totals.moduleTotalBranches[moduleName] += totalBranches;
    4867. 

  4867.             totals.moduleTotalCoveredBranches[moduleName] += passedBranches;            
    4868. 

  4868.         }
    4869. 

  4869. 

  4870.         var result = percentage(numberOfFilesCovered, totalSmts);
    4871. 

  4871. 

  4872.         var output = fileTemplate.replace("{{file}}", file)
    4873. 

  4873.                                  .replace("{{percentage}}",result)
    4874. 

  4874.                                  .replace("{{numberCovered}}", numberOfFilesCovered)
    4875. 

  4875.                                  .replace(/\{\{fileNumber\}\}/g, fileNumber)
    4876. 

  4876.                                  .replace("{{totalSmts}}", totalSmts)
    4877. 

  4877.                                  .replace("{{totalBranches}}", totalBranches)
    4878. 

  4878.                                  .replace("{{passedBranches}}", passedBranches)
    4879. 

  4879.                                  .replace("{{source}}", code.join(" "));
    4880. 

  4880.         if(result < successRate)
    4881. 

  4881.         {
    4882. 

  4882.             output = output.replace("{{statusclass}}", "bl-error");
    4883. 

  4883.         } else {
    4884. 

  4884.             output = output.replace("{{statusclass}}", "bl-success");
    4885. 

  4885.         }
    4886. 

  4886.         bodyContent += output;
    4887. 

  4887.     }
    4888. 

  4888. 

  4889.     // create temporary function for use by the global totals reporter, 
    4890. 

  4890.     // as well as the per-module totals reporter
    4891. 

  4891.     var createAggregateTotal = function(numSt, numCov, numBranch, numCovBr, moduleName) {
    4892. 

  4892. 

  4893.         var totalPercent = percentage(numCov, numSt);
    4894. 

  4894.         var statusClass = totalPercent < successRate ? "bl-error" : "bl-success";
    4895. 

  4895.         var rowTitle = ( moduleName ? "Total for module: " + moduleName : "Global total" );
    4896. 

  4896.         var totalsOutput = grandTotalTemplate.replace("{{rowTitle}}", rowTitle)
    4897. 

  4897.             .replace("{{percentage}}", totalPercent)
    4898. 

  4898.             .replace("{{numberCovered}}", numCov)
    4899. 

  4899.             .replace("{{totalSmts}}", numSt)
    4900. 

  4900.             .replace("{{passedBranches}}", numCovBr)
    4901. 

  4901.             .replace("{{totalBranches}}", numBranch)
    4902. 

  4902.             .replace("{{statusclass}}", statusClass);
    4903. 

  4903. 

  4904.         bodyContent += totalsOutput;
    4905. 

  4905.     };
    4906. 

  4906. 

  4907.     // if "data-cover-modulepattern" was provided, 
    4908. 

  4908.     // output the per-module totals alongside the global totals    
    4909. 

  4909.     if (modulePatternRegex) {
    4910. 

  4910.         for (var thisModuleName in totals.moduleTotalStatements) {
    4911. 

  4911.             if (totals.moduleTotalStatements.hasOwnProperty(thisModuleName)) {
    4912. 

  4912. 

  4913.                 var moduleTotalSt = totals.moduleTotalStatements[thisModuleName];
    4914. 

  4914.                 var moduleTotalCovSt = totals.moduleTotalCoveredStatements[thisModuleName];
    4915. 

  4915. 

  4916.                 var moduleTotalBr = totals.moduleTotalBranches[thisModuleName];
    4917. 

  4917.                 var moduleTotalCovBr = totals.moduleTotalCoveredBranches[thisModuleName];
    4918. 

  4918. 

  4919.                 createAggregateTotal(moduleTotalSt, moduleTotalCovSt, moduleTotalBr, moduleTotalCovBr, thisModuleName);
    4920. 

  4920.             }
    4921. 

  4921.         }        
    4922. 

  4922.     }
    4923. 

  4923. 

  4924.     createAggregateTotal(totals.totalSmts, totals.numberOfFilesCovered, totals.totalBranches, totals.passedBranches, null);
    4925. 

  4925.     bodyContent += "</div>"; //closing main
    4926. 

  4926. 

  4927. 

  4928.     appendTag('style', head, cssSytle);
    4929. 

  4929.     //appendStyle(body, headerContent);
    4930. 

  4930.     if (document.getElementById("blanket-main")){
    4931. 

  4931.         document.getElementById("blanket-main").innerHTML=
    4932. 

  4932.             bodyContent.slice(23,-6);
    4933. 

  4933.     }else{
    4934. 

  4934.         appendTag('div', body, bodyContent);
    4935. 

  4935.     }
    4936. 

  4936.     //appendHtml(body, '</div>');
    4937. 

  4937. };
    4938. 

  4938. 

  4939. (function(){
    4940. 

  4940.     var newOptions={};
    4941. 

  4941.     //http://stackoverflow.com/a/2954896
    4942. 

  4942.     var toArray =Array.prototype.slice;
    4943. 

  4943.     var scripts = toArray.call(document.scripts);
    4944. 

  4944.     toArray.call(scripts[scripts.length - 1].attributes)
    4945. 

  4945.                     .forEach(function(es){
    4946. 

  4946.                         if(es.nodeName === "data-cover-only"){
    4947. 

  4947.                             newOptions.filter = es.nodeValue;
    4948. 

  4948.                         }
    4949. 

  4949.                         if(es.nodeName === "data-cover-never"){
    4950. 

  4950.                             newOptions.antifilter = es.nodeValue;
    4951. 

  4951.                         }
    4952. 

  4952.                         if(es.nodeName === "data-cover-reporter"){
    4953. 

  4953.                             newOptions.reporter = es.nodeValue;
    4954. 

  4954.                         }
    4955. 

  4955.                         if (es.nodeName === "data-cover-adapter"){
    4956. 

  4956.                             newOptions.adapter = es.nodeValue;
    4957. 

  4957.                         }
    4958. 

  4958.                         if (es.nodeName === "data-cover-loader"){
    4959. 

  4959.                             newOptions.loader = es.nodeValue;
    4960. 

  4960.                         }
    4961. 

  4961.                         if (es.nodeName === "data-cover-timeout"){
    4962. 

  4962.                             newOptions.timeout = es.nodeValue;
    4963. 

  4963.                         }
    4964. 

  4964.                         if (es.nodeName === "data-cover-modulepattern") {
    4965. 

  4965.                             newOptions.modulePattern = es.nodeValue;
    4966. 

  4966.                         }                        
    4967. 

  4967.                         if (es.nodeName === "data-cover-reporter-options"){
    4968. 

  4968.                             try{
    4969. 

  4969.                                 newOptions.reporter_options = JSON.parse(es.nodeValue);
    4970. 

  4970.                             }catch(e){
    4971. 

  4971.                                 if (blanket.options("debug")){
    4972. 

  4972.                                     throw new Error("Invalid reporter options.  Must be a valid stringified JSON object.");
    4973. 

  4973.                                 }
    4974. 

  4974.                             }
    4975. 

  4975.                         }
    4976. 

  4976.                         if (es.nodeName === "data-cover-testReadyCallback"){
    4977. 

  4977.                             newOptions.testReadyCallback = es.nodeValue;
    4978. 

  4978.                         }
    4979. 

  4979.                         if (es.nodeName === "data-cover-customVariable"){
    4980. 

  4980.                             newOptions.customVariable = es.nodeValue;
    4981. 

  4981.                         }
    4982. 

  4982.                         if (es.nodeName === "data-cover-flags"){
    4983. 

  4983.                             var flags = " "+es.nodeValue+" ";
    4984. 

  4984.                             if (flags.indexOf(" ignoreError ") > -1){
    4985. 

  4985.                                 newOptions.ignoreScriptError = true;
    4986. 

  4986.                             }
    4987. 

  4987.                             if (flags.indexOf(" autoStart ") > -1){
    4988. 

  4988.                                 newOptions.autoStart = true;
    4989. 

  4989.                             }
    4990. 

  4990.                             if (flags.indexOf(" ignoreCors ") > -1){
    4991. 

  4991.                                 newOptions.ignoreCors = true;
    4992. 

  4992.                             }
    4993. 

  4993.                             if (flags.indexOf(" branchTracking ") > -1){
    4994. 

  4994.                                 newOptions.branchTracking = true;
    4995. 

  4995.                             }
    4996. 

  4996.                             if (flags.indexOf(" sourceURL ") > -1){
    4997. 

  4997.                                 newOptions.sourceURL = true;
    4998. 

  4998.                             }
    4999. 

  4999.                             if (flags.indexOf(" debug ") > -1){
    5000. 

  5000.                                 newOptions.debug = true;
    5001. 

  5001.                             }
    5002. 

  5002.                             if (flags.indexOf(" engineOnly ") > -1){
    5003. 

  5003.                                 newOptions.engineOnly = true;
    5004. 

  5004.                             }
    5005. 

  5005.                             if (flags.indexOf(" commonJS ") > -1){
    5006. 

  5006.                                 newOptions.commonJS = true;
    5007. 

  5007.                             }
    5008. 

  5008.                              if (flags.indexOf(" instrumentCache ") > -1){
    5009. 

  5009.                                 newOptions.instrumentCache = true;
    5010. 

  5010.                             }
    5011. 

  5011.                         }
    5012. 

  5012.                     });
    5013. 

  5013.     blanket.options(newOptions);
    5014. 

  5014. 

  5015.     if (typeof requirejs !== 'undefined'){
    5016. 

  5016.         blanket.options("existingRequireJS",true);
    5017. 

  5017.     }
    5018. 

  5018.     /* setup requirejs loader, if needed */
    5019. 

  5019.     
    5020. 

  5020.     if (blanket.options("commonJS")){
    5021. 

  5021.         blanket._commonjs = {};
    5022. 

  5022.     }
    5023. 

  5023. })();
    5024. 

  5024. (function(_blanket){
    5025. 

  5025. _blanket.extend({
    5026. 

  5026.     utils: {
    5027. 

  5027.         normalizeBackslashes: function(str) {
    5028. 

  5028.             return str.replace(/\\/g, '/');
    5029. 

  5029.         },
    5030. 

  5030.         matchPatternAttribute: function(filename,pattern){
    5031. 

  5031.             if (typeof pattern === 'string'){
    5032. 

  5032.                 if (pattern.indexOf("[") === 0){
    5033. 

  5033.                     //treat as array
    5034. 

  5034.                     var pattenArr = pattern.slice(1,pattern.length-1).split(",");
    5035. 

  5035.                     return pattenArr.some(function(elem){
    5036. 

  5036.                         return _blanket.utils.matchPatternAttribute(filename,_blanket.utils.normalizeBackslashes(elem.slice(1,-1)));
    5037. 

  5037.                         //return filename.indexOf(_blanket.utils.normalizeBackslashes(elem.slice(1,-1))) > -1;
    5038. 

  5038.                     });
    5039. 

  5039.                 }else if ( pattern.indexOf("//") === 0){
    5040. 

  5040.                     var ex = pattern.slice(2,pattern.lastIndexOf('/'));
    5041. 

  5041.                     var mods = pattern.slice(pattern.lastIndexOf('/')+1);
    5042. 

  5042.                     var regex = new RegExp(ex,mods);
    5043. 

  5043.                     return regex.test(filename);
    5044. 

  5044.                 }else if (pattern.indexOf("#") === 0){
    5045. 

  5045.                     return window[pattern.slice(1)].call(window,filename);
    5046. 

  5046.                 }else{
    5047. 

  5047.                     return filename.indexOf(_blanket.utils.normalizeBackslashes(pattern)) > -1;
    5048. 

  5048.                 }
    5049. 

  5049.             }else if ( pattern instanceof Array ){
    5050. 

  5050.                 return pattern.some(function(elem){
    5051. 

  5051.                     return _blanket.utils.matchPatternAttribute(filename,elem);
    5052. 

  5052.                 });
    5053. 

  5053.             }else if (pattern instanceof RegExp){
    5054. 

  5054.                 return pattern.test(filename);
    5055. 

  5055.             }else if (typeof pattern === "function"){
    5056. 

  5056.                 return pattern.call(window,filename);
    5057. 

  5057.             }
    5058. 

  5058.         },
    5059. 

  5059.         blanketEval: function(data){
    5060. 

  5060.             _blanket._addScript(data);
    5061. 

  5061.         },
    5062. 

  5062.         collectPageScripts: function(){
    5063. 

  5063.             var toArray = Array.prototype.slice;
    5064. 

  5064.             var scripts = toArray.call(document.scripts);
    5065. 

  5065.             var selectedScripts=[],scriptNames=[];
    5066. 

  5066.             var filter = _blanket.options("filter");
    5067. 

  5067.             if(filter != null){
    5068. 

  5068.                 //global filter in place, data-cover-only
    5069. 

  5069.                 var antimatch = _blanket.options("antifilter");
    5070. 

  5070.                 selectedScripts = toArray.call(document.scripts)
    5071. 

  5071.                                 .filter(function(s){
    5072. 

  5072.                                     return toArray.call(s.attributes).filter(function(sn){
    5073. 

  5073.                                         return sn.nodeName === "src" && _blanket.utils.matchPatternAttribute(sn.nodeValue,filter) &&
    5074. 

  5074.                                             (typeof antimatch === "undefined" || !_blanket.utils.matchPatternAttribute(sn.nodeValue,antimatch));
    5075. 

  5075.                                     }).length === 1;
    5076. 

  5076.                                 });
    5077. 

  5077.             }else{
    5078. 

  5078.                 selectedScripts = toArray.call(document.querySelectorAll("script[data-cover]"));
    5079. 

  5079.             }
    5080. 

  5080.             scriptNames = selectedScripts.map(function(s){
    5081. 

  5081.                                     return _blanket.utils.qualifyURL(
    5082. 

  5082.                                         toArray.call(s.attributes).filter(
    5083. 

  5083.                                             function(sn){
    5084. 

  5084.                                                 return sn.nodeName === "src";
    5085. 

  5085.                                             })[0].nodeValue).replace(".js","");
    5086. 

  5086.                                     });
    5087. 

  5087.             if (!filter){
    5088. 

  5088.                 _blanket.options("filter","['"+scriptNames.join("','")+"']");
    5089. 

  5089.             }
    5090. 

  5090.             return scriptNames;
    5091. 

  5091.         },
    5092. 

  5092.         loadAll: function(nextScript,cb,preprocessor){
    5093. 

  5093.             /**
    5094. 

  5094.              * load dependencies
    5095. 

  5095.              * @param {nextScript} factory for priority level
    5096. 

  5096.              * @param {cb} the done callback
    5097. 

  5097.              */
    5098. 

  5098.             var currScript=nextScript();
    5099. 

  5099.             var isLoaded = _blanket.utils.scriptIsLoaded(
    5100. 

  5100.                                 currScript,
    5101. 

  5101.                                 _blanket.utils.ifOrdered,
    5102. 

  5102.                                 nextScript,
    5103. 

  5103.                                 cb
    5104. 

  5104.                             );
    5105. 

  5105.             
    5106. 

  5106.             if (!(_blanket.utils.cache[currScript] && _blanket.utils.cache[currScript].loaded)){
    5107. 

  5107.                 var attach = function(){
    5108. 

  5108.                     if (_blanket.options("debug")) {console.log("BLANKET-Mark script:"+currScript+", as loaded and move to next script.");}
    5109. 

  5109.                     isLoaded();
    5110. 

  5110.                 };
    5111. 

  5111.                 var whenDone = function(result){
    5112. 

  5112.                     if (_blanket.options("debug")) {console.log("BLANKET-File loading finished");}
    5113. 

  5113.                     if (typeof result !== 'undefined'){
    5114. 

  5114.                         if (_blanket.options("debug")) {console.log("BLANKET-Add file to DOM.");}
    5115. 

  5115.                         _blanket._addScript(result);
    5116. 

  5116.                     }
    5117. 

  5117.                     attach();
    5118. 

  5118.                 };
    5119. 

  5119. 

  5120.                 _blanket.utils.attachScript(
    5121. 

  5121.                     {
    5122. 

  5122.                         url: currScript
    5123. 

  5123.                     },
    5124. 

  5124.                     function (content){
    5125. 

  5125.                         _blanket.utils.processFile(
    5126. 

  5126.                             content,
    5127. 

  5127.                             currScript,
    5128. 

  5128.                             whenDone,
    5129. 

  5129.                             whenDone
    5130. 

  5130.                         );
    5131. 

  5131.                     }
    5132. 

  5132.                 );
    5133. 

  5133.             }else{
    5134. 

  5134.                 isLoaded();
    5135. 

  5135.             }
    5136. 

  5136.         },
    5137. 

  5137.         attachScript: function(options,cb){
    5138. 

  5138.            var timeout = _blanket.options("timeout") || 3000;
    5139. 

  5139.            setTimeout(function(){
    5140. 

  5140.                 if (!_blanket.utils.cache[options.url].loaded){
    5141. 

  5141.                     throw new Error("error loading source script");
    5142. 

  5142.                 }
    5143. 

  5143.            },timeout);
    5144. 

  5144.            _blanket.utils.getFile(
    5145. 

  5145.                 options.url,
    5146. 

  5146.                 cb, 
    5147. 

  5147.                 function(){ throw new Error("error loading source script");}
    5148. 

  5148.             );
    5149. 

  5149.         },
    5150. 

  5150.         ifOrdered: function(nextScript,cb){
    5151. 

  5151.             /**
    5152. 

  5152.              * ordered loading callback
    5153. 

  5153.              * @param {nextScript} factory for priority level
    5154. 

  5154.              * @param {cb} the done callback
    5155. 

  5155.              */
    5156. 

  5156.             var currScript = nextScript(true);
    5157. 

  5157.             if (currScript){
    5158. 

  5158.               _blanket.utils.loadAll(nextScript,cb);
    5159. 

  5159.             }else{
    5160. 

  5160.               cb(new Error("Error in loading chain."));
    5161. 

  5161.             }
    5162. 

  5162.         },
    5163. 

  5163.         scriptIsLoaded: function(url,orderedCb,nextScript,cb){
    5164. 

  5164.             /**
    5165. 

  5165.            * returns a callback that checks a loading list to see if a script is loaded.
    5166. 

  5166.            * @param {orderedCb} callback if ordered loading is being done
    5167. 

  5167.            * @param {nextScript} factory for next priority level
    5168. 

  5168.            * @param {cb} the done callback
    5169. 

  5169.            */
    5170. 

  5170.            if (_blanket.options("debug")) {console.log("BLANKET-Returning function");}
    5171. 

  5171.             return function(){
    5172. 

  5172.                 if (_blanket.options("debug")) {console.log("BLANKET-Marking file as loaded: "+url);}
    5173. 

  5173.            
    5174. 

  5174.                 _blanket.utils.cache[url].loaded=true;
    5175. 

  5175.             
    5176. 

  5176.                 if (_blanket.utils.allLoaded()){
    5177. 

  5177.                     if (_blanket.options("debug")) {console.log("BLANKET-All files loaded");}
    5178. 

  5178.                     cb();
    5179. 

  5179.                 }else if (orderedCb){
    5180. 

  5180.                     //if it's ordered we need to
    5181. 

  5181.                     //traverse down to the next
    5182. 

  5182.                     //priority level
    5183. 

  5183.                     if (_blanket.options("debug")) {console.log("BLANKET-Load next file.");}
    5184. 

  5184.                     orderedCb(nextScript,cb);
    5185. 

  5185.                 }
    5186. 

  5186.             };
    5187. 

  5187.         },
    5188. 

  5188.         cache: {},
    5189. 

  5189.         allLoaded: function (){
    5190. 

  5190.             /**
    5191. 

  5191.              * check if depdencies are loaded in cache
    5192. 

  5192.              */
    5193. 

  5193.             var cached = Object.keys(_blanket.utils.cache);
    5194. 

  5194.             for (var i=0;i<cached.length;i++){
    5195. 

  5195.                 if (!_blanket.utils.cache[cached[i]].loaded){
    5196. 

  5196.                     return false;
    5197. 

  5197.                 }
    5198. 

  5198.             }
    5199. 

  5199.             return true;
    5200. 

  5200.         },
    5201. 

  5201.         processFile: function (content,url,cb,oldCb) {
    5202. 

  5202.             var match = _blanket.options("filter");
    5203. 

  5203.             //we check the never matches first
    5204. 

  5204.             var antimatch = _blanket.options("antifilter");
    5205. 

  5205.             if (typeof antimatch !== "undefined" &&
    5206. 

  5206.                     _blanket.utils.matchPatternAttribute(url.replace(/\.js$/,""),antimatch)
    5207. 

  5207.                 ){
    5208. 

  5208.                 oldCb(content);
    5209. 

  5209.                 if (_blanket.options("debug")) {console.log("BLANKET-File will never be instrumented:"+url);}
    5210. 

  5210.                 _blanket.requiringFile(url,true);
    5211. 

  5211.             }else if (_blanket.utils.matchPatternAttribute(url.replace(/\.js$/,""),match)){
    5212. 

  5212.                 if (_blanket.options("debug")) {console.log("BLANKET-Attempting instrument of:"+url);}
    5213. 

  5213.                 _blanket.instrument({
    5214. 

  5214.                     inputFile: content,
    5215. 

  5215.                     inputFileName: url
    5216. 

  5216.                 },function(instrumented){
    5217. 

  5217.                     try{
    5218. 

  5218.                         if (_blanket.options("debug")) {console.log("BLANKET-instrument of:"+url+" was successfull.");}
    5219. 

  5219.                         _blanket.utils.blanketEval(instrumented);
    5220. 

  5220.                         cb();
    5221. 

  5221.                         _blanket.requiringFile(url,true);
    5222. 

  5222.                     }
    5223. 

  5223.                     catch(err){
    5224. 

  5224.                         if (_blanket.options("ignoreScriptError")){
    5225. 

  5225.                             //we can continue like normal if
    5226. 

  5226.                             //we're ignoring script errors,
    5227. 

  5227.                             //but otherwise we don't want
    5228. 

  5228.                             //to completeLoad or the error might be
    5229. 

  5229.                             //missed.
    5230. 

  5230.                             if (_blanket.options("debug")) { console.log("BLANKET-There was an error loading the file:"+url); }
    5231. 

  5231.                             cb(content);
    5232. 

  5232.                             _blanket.requiringFile(url,true);
    5233. 

  5233.                         }else{
    5234. 

  5234.                             throw new Error("Error parsing instrumented code: "+err);
    5235. 

  5235.                         }
    5236. 

  5236.                     }
    5237. 

  5237.                 });
    5238. 

  5238.             }else{
    5239. 

  5239.                 if (_blanket.options("debug")) { console.log("BLANKET-Loading (without instrumenting) the file:"+url);}
    5240. 

  5240.                 oldCb(content);
    5241. 

  5241.                 _blanket.requiringFile(url,true);
    5242. 

  5242.             }
    5243. 

  5243. 

  5244.         },
    5245. 

  5245.         createXhr: function(){
    5246. 

  5246.             var xhr, i, progId;
    5247. 

  5247.             if (typeof XMLHttpRequest !== "undefined") {
    5248. 

  5248.                 return new XMLHttpRequest();
    5249. 

  5249.             } else if (typeof ActiveXObject !== "undefined") {
    5250. 

  5250.                 for (i = 0; i < 3; i += 1) {
    5251. 

  5251.                     progId = progIds[i];
    5252. 

  5252.                     try {
    5253. 

  5253.                         xhr = new ActiveXObject(progId);
    5254. 

  5254.                     } catch (e) {}
    5255. 

  5255. 

  5256.                     if (xhr) {
    5257. 

  5257.                         progIds = [progId];  // so faster next time
    5258. 

  5258.                         break;
    5259. 

  5259.                     }
    5260. 

  5260.                 }
    5261. 

  5261.             }
    5262. 

  5262. 

  5263.             return xhr;
    5264. 

  5264.         },
    5265. 

  5265.         getFile: function(url, callback, errback, onXhr){
    5266. 

  5266.             var foundInSession = false;
    5267. 

  5267.             if (_blanket.blanketSession){
    5268. 

  5268.                 var files = Object.keys(_blanket.blanketSession);
    5269. 

  5269.                 for (var i=0; i<files.length;i++ ){
    5270. 

  5270.                     var key = files[i];
    5271. 

  5271.                     if (url.indexOf(key) > -1){
    5272. 

  5272.                         callback(_blanket.blanketSession[key]);
    5273. 

  5273.                         foundInSession=true;
    5274. 

  5274.                         return;
    5275. 

  5275.                     }
    5276. 

  5276.                 }
    5277. 

  5277.             }
    5278. 

  5278.             if (!foundInSession){
    5279. 

  5279.                 var xhr = _blanket.utils.createXhr();
    5280. 

  5280.                 xhr.open('GET', url, true);
    5281. 

  5281. 

  5282.                 //Allow overrides specified in config
    5283. 

  5283.                 if (onXhr) {
    5284. 

  5284.                     onXhr(xhr, url);
    5285. 

  5285.                 }
    5286. 

  5286. 

  5287.                 xhr.onreadystatechange = function (evt) {
    5288. 

  5288.                     var status, err;
    5289. 

  5289.                     
    5290. 

  5290.                     //Do not explicitly handle errors, those should be
    5291. 

  5291.                     //visible via console output in the browser.
    5292. 

  5292.                     if (xhr.readyState === 4) {
    5293. 

  5293.                         status = xhr.status;
    5294. 

  5294.                         if ((status > 399 && status < 600) /*||
    5295. 

  5295.                             (status === 0 &&
    5296. 

  5296.                                 navigator.userAgent.toLowerCase().indexOf('firefox') > -1)
    5297. 

  5297.                            */ ) {
    5298. 

  5298.                             //An http 4xx or 5xx error. Signal an error.
    5299. 

  5299.                             err = new Error(url + ' HTTP status: ' + status);
    5300. 

  5300.                             err.xhr = xhr;
    5301. 

  5301.                             errback(err);
    5302. 

  5302.                         } else {
    5303. 

  5303.                             callback(xhr.responseText);
    5304. 

  5304.                         }
    5305. 

  5305.                     }
    5306. 

  5306.                 };
    5307. 

  5307.                 try{
    5308. 

  5308.                     xhr.send(null);
    5309. 

  5309.                 }catch(e){
    5310. 

  5310.                     if (e.code && (e.code === 101 || e.code === 1012) && _blanket.options("ignoreCors") === false){
    5311. 

  5311.                         //running locally and getting error from browser
    5312. 

  5312.                         _blanket.showManualLoader();
    5313. 

  5313.                     } else {
    5314. 

  5314.                         throw e;
    5315. 

  5315.                     }
    5316. 

  5316.                 }
    5317. 

  5317.             }
    5318. 

  5318.         }
    5319. 

  5319.     }
    5320. 

  5320. });
    5321. 

  5321. 

  5322. (function(){
    5323. 

  5323.     var require = blanket.options("commonJS") ? blanket._commonjs.require : window.require;
    5324. 

  5324.     var requirejs = blanket.options("commonJS") ? blanket._commonjs.requirejs : window.requirejs;
    5325. 

  5325.     if (!_blanket.options("engineOnly") && _blanket.options("existingRequireJS")){
    5326. 

  5326. 

  5327.         _blanket.utils.oldloader = requirejs.load;
    5328. 

  5328. 

  5329.         requirejs.load = function (context, moduleName, url) {
    5330. 

  5330.             _blanket.requiringFile(url);
    5331. 

  5331.             _blanket.utils.getFile(url, 
    5332. 

  5332.                 function(content){ 
    5333. 

  5333.                     _blanket.utils.processFile(
    5334. 

  5334.                         content,
    5335. 

  5335.                         url,
    5336. 

  5336.                         function newLoader(){
    5337. 

  5337.                             context.completeLoad(moduleName);
    5338. 

  5338.                         },
    5339. 

  5339.                         function oldLoader(){
    5340. 

  5340.                             _blanket.utils.oldloader(context, moduleName, url);
    5341. 

  5341.                         }
    5342. 

  5342.                     );
    5343. 

  5343.                 }, function (err) {
    5344. 

  5344.                 _blanket.requiringFile();
    5345. 

  5345.                 throw err;
    5346. 

  5346.             });
    5347. 

  5347.         };
    5348. 

  5348.     }
    5349. 

  5349. })();
    5350. 

  5350. 

  5351. })(blanket);
    5352. 

  5352. 

  5353. (function() {
    5354. 

  5354. 

  5355.     if (! jasmine) {
    5356. 

  5356.         throw new Exception("jasmine library does not exist in global namespace!");
    5357. 

  5357.     }
    5358. 

  5358. 

  5359.     function elapsed(startTime, endTime) {
    5360. 

  5360.         return (endTime - startTime)/1000;
    5361. 

  5361.     }
    5362. 

  5362. 

  5363.     function ISODateString(d) {
    5364. 

  5364.         function pad(n) { return n < 10 ? '0'+n : n; }
    5365. 

  5365. 

  5366.         return d.getFullYear() + '-' +
    5367. 

  5367.             pad(d.getMonth()+1) + '-' +
    5368. 

  5368.             pad(d.getDate()) + 'T' +
    5369. 

  5369.             pad(d.getHours()) + ':' +
    5370. 

  5370.             pad(d.getMinutes()) + ':' +
    5371. 

  5371.             pad(d.getSeconds());
    5372. 

  5372.     }
    5373. 

  5373. 

  5374.     function trim(str) {
    5375. 

  5375.         return str.replace(/^\s+/, "" ).replace(/\s+$/, "" );
    5376. 

  5376.     }
    5377. 

  5377. 

  5378.     function escapeInvalidXmlChars(str) {
    5379. 

  5379.         return str.replace(/\&/g, "&amp;")
    5380. 

  5380.             .replace(/</g, "&lt;")
    5381. 

  5381.             .replace(/\>/g, "&gt;")
    5382. 

  5382.             .replace(/\"/g, "&quot;")
    5383. 

  5383.             .replace(/\'/g, "&apos;");
    5384. 

  5384.     }
    5385. 

  5385. 

  5386.     /**
    5387. 

  5387.      * based on https://raw.github.com/larrymyers/jasmine-reporters/master/src/jasmine.junit_reporter.js
    5388. 

  5388.      */
    5389. 

  5389.     var BlanketReporter = function(savePath, consolidate, useDotNotation) {
    5390. 

  5390.         
    5391. 

  5391.         blanket.setupCoverage();
    5392. 

  5392.     };
    5393. 

  5393.     BlanketReporter.finished_at = null; // will be updated after all files have been written
    5394. 

  5394. 

  5395.     BlanketReporter.prototype = {
    5396. 

  5396.         reportSpecStarting: function(spec) {
    5397. 

  5397.             blanket.onTestStart();
    5398. 

  5398.         },
    5399. 

  5399. 

  5400.         reportSpecResults: function(suite) {
    5401. 

  5401.             var results = suite.results();
    5402. 

  5402. 

  5403.             blanket.onTestDone(results.totalCount,results.passed());
    5404. 

  5404.         },
    5405. 

  5405. 

  5406.         reportRunnerResults: function(runner) {
    5407. 

  5407.             blanket.onTestsDone();
    5408. 

  5408.         },
    5409. 

  5409. 

  5410.         log: function(str) {
    5411. 

  5411.             var console = jasmine.getGlobal().console;
    5412. 

  5412. 

  5413.             if (console && console.log) {
    5414. 

  5414.                 console.log(str);
    5415. 

  5415.             }
    5416. 

  5416.         }
    5417. 

  5417.     };
    5418. 

  5418. 

  5419. 

  5420.     // export public
    5421. 

  5421.     jasmine.BlanketReporter = BlanketReporter;
    5422. 

  5422. 

  5423.     //override existing jasmine execute
    5424. 

  5424.     jasmine.getEnv().execute = function(){ console.log("waiting for blanket..."); };
    5425. 

  5425.     
    5426. 

  5426.     //check to make sure requirejs is completed before we start the test runner
    5427. 

  5427.     var allLoaded = function() {
    5428. 

  5428.         return window.jasmine.getEnv().currentRunner().specs().length > 0 && blanket.requireFilesLoaded();
    5429. 

  5429.     };
    5430. 

  5430. 

  5431.     blanket.beforeStartTestRunner({
    5432. 

  5432.         checkRequirejs:true,
    5433. 

  5433.         condition: allLoaded,
    5434. 

  5434.         callback:function(){
    5435. 

  5435.             jasmine.getEnv().addReporter(new jasmine.BlanketReporter());
    5436. 

  5436.             window.jasmine.getEnv().currentRunner().execute();
    5437. 

  5437.             jasmine.getEnv().execute = function () {
    5438. 

  5438.                 jasmine.getEnv().currentRunner().execute();   
    5439. 

  5439.             };  
    5440. 

  5440.         }
    5441. 

  5441.     });
    5442. 

  5442. })();
    5443.