PageRenderTime 89ms CodeModel.GetById 12ms RepoModel.GetById 1ms app.codeStats 1ms

/ajax/libs/blanket.js/1.1.4/blanket_jasmine.js

https://bitbucket.org/kolbyjAFK/cdnjs
JavaScript | 7292 lines | 6365 code | 716 blank | 211 comment | 790 complexity | de8c3f8aa0636d50458f345a56fe4c2b MD5 | raw file
Possible License(s): MPL-2.0-no-copyleft-exception 
    

  1. /*! blanket - v1.1.3 */ 
    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.         orderedLoading: true,
    4039. 

  4039.         loader: null,
    4040. 

  4040.         ignoreScriptError: false,
    4041. 

  4041.         existingRequireJS:false,
    4042. 

  4042.         autoStart: false,
    4043. 

  4043.         timeout: 180,
    4044. 

  4044.         ignoreCors: false,
    4045. 

  4045.         branchTracking: false,
    4046. 

  4046.         sourceURL: false,
    4047. 

  4047.         debug:false,
    4048. 

  4048.         engineOnly:false,
    4049. 

  4049.         testReadyCallback:null,
    4050. 

  4050.         commonJS:false,
    4051. 

  4051.         instrumentCache:false
    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.             var script = document.createElement("script");
    4468. 

  4468.             script.type = "text/javascript";
    4469. 

  4469.             script.text = request.responseText;
    4470. 

  4470.             (document.body || document.getElementsByTagName('head')[0]).appendChild(script);
    4471. 

  4471.         }
    4472. 

  4472.     },
    4473. 

  4473.     hasAdapter: function(callback){
    4474. 

  4474.         return _blanket.options("adapter") !== null;
    4475. 

  4475.     },
    4476. 

  4476.     report: function(coverage_data){
    4477. 

  4477.         if (!document.getElementById("blanketLoaderDialog")){
    4478. 

  4478.             //all found, clear it
    4479. 

  4479.             _blanket.blanketSession = null;
    4480. 

  4480.         }
    4481. 

  4481.         coverage_data.files = window._$blanket;
    4482. 

  4482.         var require = blanket.options("commonJS") ? blanket._commonjs.require : window.require;
    4483. 

  4483. 

  4484.         // Check if we have any covered files that requires reporting
    4485. 

  4485.         // otherwise just exit gracefully.
    4486. 

  4486.         if (!coverage_data.files || !Object.keys(coverage_data.files).length) {
    4487. 

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

  4488.             return;
    4489. 

  4489.         }
    4490. 

  4490. 

  4491.         if (typeof coverage_data.files.branchFcn !== "undefined"){
    4492. 

  4492.             delete coverage_data.files.branchFcn;
    4493. 

  4493.         }
    4494. 

  4494.         if (typeof _blanket.options("reporter") === "string"){
    4495. 

  4495.             require([_blanket.options("reporter").replace(".js","")],function(r){
    4496. 

  4496.                 r(coverage_data,_blanket.options("reporter_options"));
    4497. 

  4497.             });
    4498. 

  4498.         }else if (typeof _blanket.options("reporter") === "function"){
    4499. 

  4499.             _blanket.options("reporter")(coverage_data);
    4500. 

  4500.         }else if (typeof _blanket.defaultReporter === 'function'){
    4501. 

  4501.             _blanket.defaultReporter(coverage_data);
    4502. 

  4502.         }else{
    4503. 

  4503.             throw new Error("no reporter defined.");
    4504. 

  4504.         }
    4505. 

  4505.     },
    4506. 

  4506.     _bindStartTestRunner: function(bindEvent,startEvent){
    4507. 

  4507.         if (bindEvent){
    4508. 

  4508.             bindEvent(startEvent);
    4509. 

  4509.         }else{
    4510. 

  4510.             window.addEventListener("load",startEvent,false);
    4511. 

  4511.         }
    4512. 

  4512.     },
    4513. 

  4513.     _loadSourceFiles: function(callback){
    4514. 

  4514.         console.log("ls1:"+new Date().getTime());
    4515. 

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

  4516.         function copy(o){
    4517. 

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

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

  4519. 

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

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

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

  4523.           });
    4524. 

  4524. 

  4525.           return _copy;
    4526. 

  4526.         }
    4527. 

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

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

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

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

  4531.             callback();
    4532. 

  4532.         }else{
    4533. 

  4533. 

  4534.             //check session state
    4535. 

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

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

  4537.             }
    4538. 

  4538. 

  4539.             var requireConfig = {
    4540. 

  4540.                 paths: {},
    4541. 

  4541.                 shim: {},
    4542. 

  4542.                 waitSeconds: _blanket.options("timeout")
    4543. 

  4543.             };
    4544. 

  4544.             var lastDep = {
    4545. 

  4545.                 deps: []
    4546. 

  4546.             };
    4547. 

  4547.             var isOrdered = _blanket.options("orderedLoading");
    4548. 

  4548.             var initialGet=[];
    4549. 

  4549.             scripts.forEach(function(file,indx){
    4550. 

  4550.                 //for whatever reason requirejs
    4551. 

  4551.                 //prefers when we don't use the full path
    4552. 

  4552.                 //so we just use a custom name
    4553. 

  4553.                 var requireKey = "blanket_"+indx;
    4554. 

  4554.                 initialGet.push(requireKey);
    4555. 

  4555.                 requireConfig.paths[requireKey] = file;
    4556. 

  4556.                 if (isOrdered){
    4557. 

  4557.                     if (indx > 0){
    4558. 

  4558.                        requireConfig.shim[requireKey] = copy(lastDep);
    4559. 

  4559.                     }
    4560. 

  4560.                     lastDep.deps = [requireKey];
    4561. 

  4561.                 }
    4562. 

  4562.             });
    4563. 

  4563.             require.config(requireConfig);
    4564. 

  4564.             var filt = initialGet;
    4565. 

  4565.             require(filt, function(){
    4566. 

  4566.                 callback();
    4567. 

  4567.             });
    4568. 

  4568.         }
    4569. 

  4569.         console.log("ls2:"+new Date().getTime());
    4570. 

  4570.     },
    4571. 

  4571.     beforeStartTestRunner: function(opts){
    4572. 

  4572.         opts = opts || {};
    4573. 

  4573.         opts.checkRequirejs = typeof opts.checkRequirejs === "undefined" ? true : opts.checkRequirejs;
    4574. 

  4574.         opts.callback = opts.callback || function() {  };
    4575. 

  4575.         opts.coverage = typeof opts.coverage === "undefined" ? true : opts.coverage;
    4576. 

  4576.         if (opts.coverage) {
    4577. 

  4577.             _blanket._bindStartTestRunner(opts.bindEvent,
    4578. 

  4578.             function(){
    4579. 

  4579.                 _blanket._loadSourceFiles(function() {
    4580. 

  4580. 

  4581.                     var allLoaded = function(){
    4582. 

  4582.                         return opts.condition ? opts.condition() : _blanket.requireFilesLoaded();
    4583. 

  4583.                     };
    4584. 

  4584.                     var check = function() {
    4585. 

  4585.                         if (allLoaded()) {
    4586. 

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

  4587.                             var cb = _blanket.options("testReadyCallback");
    4588. 

  4588. 

  4589.                             if (cb){
    4590. 

  4590.                                 if (typeof cb === "function"){
    4591. 

  4591.                                     cb(opts.callback);
    4592. 

  4592.                                 }else if (typeof cb === "string"){
    4593. 

  4593.                                     eval(cb);
    4594. 

  4594.                                     opts.callback();
    4595. 

  4595.                                 }
    4596. 

  4596.                             }else{
    4597. 

  4597.                                 opts.callback();
    4598. 

  4598.                             }
    4599. 

  4599.                         } else {
    4600. 

  4600.                             setTimeout(check, 13);
    4601. 

  4601.                         }
    4602. 

  4602.                     };
    4603. 

  4603.                     check();
    4604. 

  4604.                 });
    4605. 

  4605.             });
    4606. 

  4606.         }else{
    4607. 

  4607.             opts.callback();
    4608. 

  4608.         }
    4609. 

  4609.     },
    4610. 

  4610.     utils: {
    4611. 

  4611.         qualifyURL: function (url) {
    4612. 

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

  4613.             var a = document.createElement('a');
    4614. 

  4614.             a.href = url;
    4615. 

  4615.             return a.href;
    4616. 

  4616.         }
    4617. 

  4617.     }
    4618. 

  4618. });
    4619. 

  4619. 

  4620. })(blanket);
    4621. 

  4621. 

  4622. blanket.setupRequireJS=function(context){
    4623. 

  4623. 

  4624. /** vim: et:ts=4:sw=4:sts=4
    4625. 

  4625.  * @license RequireJS 2.1.4 Copyright (c) 2010-2012, The Dojo Foundation All Rights Reserved.
    4626. 

  4626.  * Available via the MIT or new BSD license.
    4627. 

  4627.  * see: http://github.com/jrburke/requirejs for details
    4628. 

  4628.  */
    4629. 

  4629. //Not using strict: uneven strict support in browsers, #392, and causes
    4630. 

  4630. //problems with requirejs.exec()/transpiler plugins that may not be strict.
    4631. 

  4631. /*jslint regexp: true, nomen: true, sloppy: true */
    4632. 

  4632. /*global window, navigator, document, importScripts, setTimeout, opera */
    4633. 

  4633. 

  4634. var requirejs, require, define;
    4635. 

  4635. (function (global) {
    4636. 

  4636.     var req, s, head, baseElement, dataMain, src,
    4637. 

  4637.         interactiveScript, currentlyAddingScript, mainScript, subPath,
    4638. 

  4638.         version = '2.1.4',
    4639. 

  4639.         commentRegExp = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/mg,
    4640. 

  4640.         cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,
    4641. 

  4641.         jsSuffixRegExp = /\.js$/,
    4642. 

  4642.         currDirRegExp = /^\.\//,
    4643. 

  4643.         op = Object.prototype,
    4644. 

  4644.         ostring = op.toString,
    4645. 

  4645.         hasOwn = op.hasOwnProperty,
    4646. 

  4646.         ap = Array.prototype,
    4647. 

  4647.         apsp = ap.splice,
    4648. 

  4648.         isBrowser = !!(typeof window !== 'undefined' && navigator && document),
    4649. 

  4649.         isWebWorker = !isBrowser && typeof importScripts !== 'undefined',
    4650. 

  4650.         //PS3 indicates loaded and complete, but need to wait for complete
    4651. 

  4651.         //specifically. Sequence is 'loading', 'loaded', execution,
    4652. 

  4652.         // then 'complete'. The UA check is unfortunate, but not sure how
    4653. 

  4653.         //to feature test w/o causing perf issues.
    4654. 

  4654.         readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ?
    4655. 

  4655.                       /^complete$/ : /^(complete|loaded)$/,
    4656. 

  4656.         defContextName = '_',
    4657. 

  4657.         //Oh the tragedy, detecting opera. See the usage of isOpera for reason.
    4658. 

  4658.         isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]',
    4659. 

  4659.         contexts = {},
    4660. 

  4660.         cfg = {},
    4661. 

  4661.         globalDefQueue = [],
    4662. 

  4662.         useInteractive = false;
    4663. 

  4663. 

  4664.     function isFunction(it) {
    4665. 

  4665.         return ostring.call(it) === '[object Function]';
    4666. 

  4666.     }
    4667. 

  4667. 

  4668.     function isArray(it) {
    4669. 

  4669.         return ostring.call(it) === '[object Array]';
    4670. 

  4670.     }
    4671. 

  4671. 

  4672.     /**
    4673. 

  4673.      * Helper function for iterating over an array. If the func returns
    4674. 

  4674.      * a true value, it will break out of the loop.
    4675. 

  4675.      */
    4676. 

  4676.     function each(ary, func) {
    4677. 

  4677.         if (ary) {
    4678. 

  4678.             var i;
    4679. 

  4679.             for (i = 0; i < ary.length; i += 1) {
    4680. 

  4680.                 if (ary[i] && func(ary[i], i, ary)) {
    4681. 

  4681.                     break;
    4682. 

  4682.                 }
    4683. 

  4683.             }
    4684. 

  4684.         }
    4685. 

  4685.     }
    4686. 

  4686. 

  4687.     /**
    4688. 

  4688.      * Helper function for iterating over an array backwards. If the func
    4689. 

  4689.      * returns a true value, it will break out of the loop.
    4690. 

  4690.      */
    4691. 

  4691.     function eachReverse(ary, func) {
    4692. 

  4692.         if (ary) {
    4693. 

  4693.             var i;
    4694. 

  4694.             for (i = ary.length - 1; i > -1; i -= 1) {
    4695. 

  4695.                 if (ary[i] && func(ary[i], i, ary)) {
    4696. 

  4696.                     break;
    4697. 

  4697.                 }
    4698. 

  4698.             }
    4699. 

  4699.         }
    4700. 

  4700.     }
    4701. 

  4701. 

  4702.     function hasProp(obj, prop) {
    4703. 

  4703.         return hasOwn.call(obj, prop);
    4704. 

  4704.     }
    4705. 

  4705. 

  4706.     function getOwn(obj, prop) {
    4707. 

  4707.         return hasProp(obj, prop) && obj[prop];
    4708. 

  4708.     }
    4709. 

  4709. 

  4710.     /**
    4711. 

  4711.      * Cycles over properties in an object and calls a function for each
    4712. 

  4712.      * property value. If the function returns a truthy value, then the
    4713. 

  4713.      * iteration is stopped.
    4714. 

  4714.      */
    4715. 

  4715.     function eachProp(obj, func) {
    4716. 

  4716.         var prop;
    4717. 

  4717.         for (prop in obj) {
    4718. 

  4718.             if (hasProp(obj, prop)) {
    4719. 

  4719.                 if (func(obj[prop], prop)) {
    4720. 

  4720.                     break;
    4721. 

  4721.                 }
    4722. 

  4722.             }
    4723. 

  4723.         }
    4724. 

  4724.     }
    4725. 

  4725. 

  4726.     /**
    4727. 

  4727.      * Simple function to mix in properties from source into target,
    4728. 

  4728.      * but only if target does not already have a property of the same name.
    4729. 

  4729.      */
    4730. 

  4730.     function mixin(target, source, force, deepStringMixin) {
    4731. 

  4731.         if (source) {
    4732. 

  4732.             eachProp(source, function (value, prop) {
    4733. 

  4733.                 if (force || !hasProp(target, prop)) {
    4734. 

  4734.                     if (deepStringMixin && typeof value !== 'string') {
    4735. 

  4735.                         if (!target[prop]) {
    4736. 

  4736.                             target[prop] = {};
    4737. 

  4737.                         }
    4738. 

  4738.                         mixin(target[prop], value, force, deepStringMixin);
    4739. 

  4739.                     } else {
    4740. 

  4740.                         target[prop] = value;
    4741. 

  4741.                     }
    4742. 

  4742.                 }
    4743. 

  4743.             });
    4744. 

  4744.         }
    4745. 

  4745.         return target;
    4746. 

  4746.     }
    4747. 

  4747. 

  4748.     //Similar to Function.prototype.bind, but the 'this' object is specified
    4749. 

  4749.     //first, since it is easier to read/figure out what 'this' will be.
    4750. 

  4750.     function bind(obj, fn) {
    4751. 

  4751.         return function () {
    4752. 

  4752.             return fn.apply(obj, arguments);
    4753. 

  4753.         };
    4754. 

  4754.     }
    4755. 

  4755. 

  4756.     function scripts() {
    4757. 

  4757.         return document.getElementsByTagName('script');
    4758. 

  4758.     }
    4759. 

  4759. 

  4760.     //Allow getting a global that expressed in
    4761. 

  4761.     //dot notation, like 'a.b.c'.
    4762. 

  4762.     function getGlobal(value) {
    4763. 

  4763.         if (!value) {
    4764. 

  4764.             return value;
    4765. 

  4765.         }
    4766. 

  4766.         var g = global;
    4767. 

  4767.         each(value.split('.'), function (part) {
    4768. 

  4768.             g = g[part];
    4769. 

  4769.         });
    4770. 

  4770.         return g;
    4771. 

  4771.     }
    4772. 

  4772. 

  4773.     /**
    4774. 

  4774.      * Constructs an error with a pointer to an URL with more information.
    4775. 

  4775.      * @param {String} id the error ID that maps to an ID on a web page.
    4776. 

  4776.      * @param {String} message human readable error.
    4777. 

  4777.      * @param {Error} [err] the original error, if there is one.
    4778. 

  4778.      *
    4779. 

  4779.      * @returns {Error}
    4780. 

  4780.      */
    4781. 

  4781.     function makeError(id, msg, err, requireModules) {
    4782. 

  4782.         var e = new Error(msg + '\nhttp://requirejs.org/docs/errors.html#' + id);
    4783. 

  4783.         e.requireType = id;
    4784. 

  4784.         e.requireModules = requireModules;
    4785. 

  4785.         if (err) {
    4786. 

  4786.             e.originalError = err;
    4787. 

  4787.         }
    4788. 

  4788.         return e;
    4789. 

  4789.     }
    4790. 

  4790. 

  4791.     if (typeof define !== 'undefined') {
    4792. 

  4792.         //If a define is already in play via another AMD loader,
    4793. 

  4793.         //do not overwrite.
    4794. 

  4794.         return;
    4795. 

  4795.     }
    4796. 

  4796. 

  4797.     if (typeof requirejs !== 'undefined') {
    4798. 

  4798.         if (isFunction(requirejs)) {
    4799. 

  4799.             //Do not overwrite and existing requirejs instance.
    4800. 

  4800.             return;
    4801. 

  4801.         }
    4802. 

  4802.         cfg = requirejs;
    4803. 

  4803.         requirejs = undefined;
    4804. 

  4804.     }
    4805. 

  4805. 

  4806.     //Allow for a require config object
    4807. 

  4807.     if (typeof require !== 'undefined' && !isFunction(require)) {
    4808. 

  4808.         //assume it is a config object.
    4809. 

  4809.         cfg = require;
    4810. 

  4810.         require = undefined;
    4811. 

  4811.     }
    4812. 

  4812. 

  4813.     function newContext(contextName) {
    4814. 

  4814.         var inCheckLoaded, Module, context, handlers,
    4815. 

  4815.             checkLoadedTimeoutId,
    4816. 

  4816.             config = {
    4817. 

  4817.                 waitSeconds: 7,
    4818. 

  4818.                 baseUrl: './',
    4819. 

  4819.                 paths: {},
    4820. 

  4820.                 pkgs: {},
    4821. 

  4821.                 shim: {},
    4822. 

  4822.                 map: {},
    4823. 

  4823.                 config: {}
    4824. 

  4824.             },
    4825. 

  4825.             registry = {},
    4826. 

  4826.             undefEvents = {},
    4827. 

  4827.             defQueue = [],
    4828. 

  4828.             defined = {},
    4829. 

  4829.             urlFetched = {},
    4830. 

  4830.             requireCounter = 1,
    4831. 

  4831.             unnormalizedCounter = 1;
    4832. 

  4832. 

  4833.         /**
    4834. 

  4834.          * Trims the . and .. from an array of path segments.
    4835. 

  4835.          * It will keep a leading path segment if a .. will become
    4836. 

  4836.          * the first path segment, to help with module name lookups,
    4837. 

  4837.          * which act like paths, but can be remapped. But the end result,
    4838. 

  4838.          * all paths that use this function should look normalized.
    4839. 

  4839.          * NOTE: this method MODIFIES the input array.
    4840. 

  4840.          * @param {Array} ary the array of path segments.
    4841. 

  4841.          */
    4842. 

  4842.         function trimDots(ary) {
    4843. 

  4843.             var i, part;
    4844. 

  4844.             for (i = 0; ary[i]; i += 1) {
    4845. 

  4845.                 part = ary[i];
    4846. 

  4846.                 if (part === '.') {
    4847. 

  4847.                     ary.splice(i, 1);
    4848. 

  4848.                     i -= 1;
    4849. 

  4849.                 } else if (part === '..') {
    4850. 

  4850.                     if (i === 1 && (ary[2] === '..' || ary[0] === '..')) {
    4851. 

  4851.                         //End of the line. Keep at least one non-dot
    4852. 

  4852.                         //path segment at the front so it can be mapped
    4853. 

  4853.                         //correctly to disk. Otherwise, there is likely
    4854. 

  4854.                         //no path mapping for a path starting with '..'.
    4855. 

  4855.                         //This can still fail, but catches the most reasonable
    4856. 

  4856.                         //uses of ..
    4857. 

  4857.                         break;
    4858. 

  4858.                     } else if (i > 0) {
    4859. 

  4859.                         ary.splice(i - 1, 2);
    4860. 

  4860.                         i -= 2;
    4861. 

  4861.                     }
    4862. 

  4862.                 }
    4863. 

  4863.             }
    4864. 

  4864.         }
    4865. 

  4865. 

  4866.         /**
    4867. 

  4867.          * Given a relative module name, like ./something, normalize it to
    4868. 

  4868.          * a real name that can be mapped to a path.
    4869. 

  4869.          * @param {String} name the relative name
    4870. 

  4870.          * @param {String} baseName a real name that the name arg is relative
    4871. 

  4871.          * to.
    4872. 

  4872.          * @param {Boolean} applyMap apply the map config to the value. Should
    4873. 

  4873.          * only be done if this normalization is for a dependency ID.
    4874. 

  4874.          * @returns {String} normalized name
    4875. 

  4875.          */
    4876. 

  4876.         function normalize(name, baseName, applyMap) {
    4877. 

  4877.             var pkgName, pkgConfig, mapValue, nameParts, i, j, nameSegment,
    4878. 

  4878.                 foundMap, foundI, foundStarMap, starI,
    4879. 

  4879.                 baseParts = baseName && baseName.split('/'),
    4880. 

  4880.                 normalizedBaseParts = baseParts,
    4881. 

  4881.                 map = config.map,
    4882. 

  4882.                 starMap = map && map['*'];
    4883. 

  4883. 

  4884.             //Adjust any relative paths.
    4885. 

  4885.             if (name && name.charAt(0) === '.') {
    4886. 

  4886.                 //If have a base name, try to normalize against it,
    4887. 

  4887.                 //otherwise, assume it is a top-level require that will
    4888. 

  4888.                 //be relative to baseUrl in the end.
    4889. 

  4889.                 if (baseName) {
    4890. 

  4890.                     if (getOwn(config.pkgs, baseName)) {
    4891. 

  4891.                         //If the baseName is a package name, then just treat it as one
    4892. 

  4892.                         //name to concat the name with.
    4893. 

  4893.                         normalizedBaseParts = baseParts = [baseName];
    4894. 

  4894.                     } else {
    4895. 

  4895.                         //Convert baseName to array, and lop off the last part,
    4896. 

  4896.                         //so that . matches that 'directory' and not name of the baseName's
    4897. 

  4897.                         //module. For instance, baseName of 'one/two/three', maps to
    4898. 

  4898.                         //'one/two/three.js', but we want the directory, 'one/two' for
    4899. 

  4899.                         //this normalization.
    4900. 

  4900.                         normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
    4901. 

  4901.                     }
    4902. 

  4902. 

  4903.                     name = normalizedBaseParts.concat(name.split('/'));
    4904. 

  4904.                     trimDots(name);
    4905. 

  4905. 

  4906.                     //Some use of packages may use a . path to reference the
    4907. 

  4907.                     //'main' module name, so normalize for that.
    4908. 

  4908.                     pkgConfig = getOwn(config.pkgs, (pkgName = name[0]));
    4909. 

  4909.                     name = name.join('/');
    4910. 

  4910.                     if (pkgConfig && name === pkgName + '/' + pkgConfig.main) {
    4911. 

  4911.                         name = pkgName;
    4912. 

  4912.                     }
    4913. 

  4913.                 } else if (name.indexOf('./') === 0) {
    4914. 

  4914.                     // No baseName, so this is ID is resolved relative
    4915. 

  4915.                     // to baseUrl, pull off the leading dot.
    4916. 

  4916.                     name = name.substring(2);
    4917. 

  4917.                 }
    4918. 

  4918.             }
    4919. 

  4919. 

  4920.             //Apply map config if available.
    4921. 

  4921.             if (applyMap && (baseParts || starMap) && map) {
    4922. 

  4922.                 nameParts = name.split('/');
    4923. 

  4923. 

  4924.                 for (i = nameParts.length; i > 0; i -= 1) {
    4925. 

  4925.                     nameSegment = nameParts.slice(0, i).join('/');
    4926. 

  4926. 

  4927.                     if (baseParts) {
    4928. 

  4928.                         //Find the longest baseName segment match in the config.
    4929. 

  4929.                         //So, do joins on the biggest to smallest lengths of baseParts.
    4930. 

  4930.                         for (j = baseParts.length; j > 0; j -= 1) {
    4931. 

  4931.                             mapValue = getOwn(map, baseParts.slice(0, j).join('/'));
    4932. 

  4932. 

  4933.                             //baseName segment has config, find if it has one for
    4934. 

  4934.                             //this name.
    4935. 

  4935.                             if (mapValue) {
    4936. 

  4936.                                 mapValue = getOwn(mapValue, nameSegment);
    4937. 

  4937.                                 if (mapValue) {
    4938. 

  4938.                                     //Match, update name to the new value.
    4939. 

  4939.                                     foundMap = mapValue;
    4940. 

  4940.                                     foundI = i;
    4941. 

  4941.                                     break;
    4942. 

  4942.                                 }
    4943. 

  4943.                             }
    4944. 

  4944.                         }
    4945. 

  4945.                     }
    4946. 

  4946. 

  4947.                     if (foundMap) {
    4948. 

  4948.                         break;
    4949. 

  4949.                     }
    4950. 

  4950. 

  4951.                     //Check for a star map match, but just hold on to it,
    4952. 

  4952.                     //if there is a shorter segment match later in a matching
    4953. 

  4953.                     //config, then favor over this star map.
    4954. 

  4954.                     if (!foundStarMap && starMap && getOwn(starMap, nameSegment)) {
    4955. 

  4955.                         foundStarMap = getOwn(starMap, nameSegment);
    4956. 

  4956.                         starI = i;
    4957. 

  4957.                     }
    4958. 

  4958.                 }
    4959. 

  4959. 

  4960.                 if (!foundMap && foundStarMap) {
    4961. 

  4961.                     foundMap = foundStarMap;
    4962. 

  4962.                     foundI = starI;
    4963. 

  4963.                 }
    4964. 

  4964. 

  4965.                 if (foundMap) {
    4966. 

  4966.                     nameParts.splice(0, foundI, foundMap);
    4967. 

  4967.                     name = nameParts.join('/');
    4968. 

  4968.                 }
    4969. 

  4969.             }
    4970. 

  4970. 

  4971.             return name;
    4972. 

  4972.         }
    4973. 

  4973. 

  4974.         function removeScript(name) {
    4975. 

  4975.             if (isBrowser) {
    4976. 

  4976.                 each(scripts(), function (scriptNode) {
    4977. 

  4977.                     if (scriptNode.getAttribute('data-requiremodule') === name &&
    4978. 

  4978.                             scriptNode.getAttribute('data-requirecontext') === context.contextName) {
    4979. 

  4979.                         scriptNode.parentNode.removeChild(scriptNode);
    4980. 

  4980.                         return true;
    4981. 

  4981.                     }
    4982. 

  4982.                 });
    4983. 

  4983.             }
    4984. 

  4984.         }
    4985. 

  4985. 

  4986.         function hasPathFallback(id) {
    4987. 

  4987.             var pathConfig = getOwn(config.paths, id);
    4988. 

  4988.             if (pathConfig && isArray(pathConfig) && pathConfig.length > 1) {
    4989. 

  4989.                 removeScript(id);
    4990. 

  4990.                 //Pop off the first array value, since it failed, and
    4991. 

  4991.                 //retry
    4992. 

  4992.                 pathConfig.shift();
    4993. 

  4993.                 context.require.undef(id);
    4994. 

  4994.                 context.require([id]);
    4995. 

  4995.                 return true;
    4996. 

  4996.             }
    4997. 

  4997.         }
    4998. 

  4998. 

  4999.         //Turns a plugin!resource to [plugin, resource]
    5000. 

  5000.         //with the plugin being undefined if the name
    5001. 

  5001.         //did not have a plugin prefix.
    5002. 

  5002.         function splitPrefix(name) {
    5003. 

  5003.             var prefix,
    5004. 

  5004.                 index = name ? name.indexOf('!') : -1;
    5005. 

  5005.             if (index > -1) {
    5006. 

  5006.                 prefix = name.substring(0, index);
    5007. 

  5007.                 name = name.substring(index + 1, name.length);
    5008. 

  5008.             }
    5009. 

  5009.             return [prefix, name];
    5010. 

  5010.         }
    5011. 

  5011. 

  5012.         /**
    5013. 

  5013.          * Creates a module mapping that includes plugin prefix, module
    5014. 

  5014.          * name, and path. If parentModuleMap is provided it will
    5015. 

  5015.          * also normalize the name via require.normalize()
    5016. 

  5016.          *
    5017. 

  5017.          * @param {String} name the module name
    5018. 

  5018.          * @param {String} [parentModuleMap] parent module map
    5019. 

  5019.          * for the module name, used to resolve relative names.
    5020. 

  5020.          * @param {Boolean} isNormalized: is the ID already normalized.
    5021. 

  5021.          * This is true if this call is done for a define() module ID.
    5022. 

  5022.          * @param {Boolean} applyMap: apply the map config to the ID.
    5023. 

  5023.          * Should only be true if this map is for a dependency.
    5024. 

  5024.          *
    5025. 

  5025.          * @returns {Object}
    5026. 

  5026.          */
    5027. 

  5027.         function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {
    5028. 

  5028.             var url, pluginModule, suffix, nameParts,
    5029. 

  5029.                 prefix = null,
    5030. 

  5030.                 parentName = parentModuleMap ? parentModuleMap.name : null,
    5031. 

  5031.                 originalName = name,
    5032. 

  5032.                 isDefine = true,
    5033. 

  5033.                 normalizedName = '';
    5034. 

  5034. 

  5035.             //If no name, then it means it is a require call, generate an
    5036. 

  5036.             //internal name.
    5037. 

  5037.             if (!name) {
    5038. 

  5038.                 isDefine = false;
    5039. 

  5039.                 name = '_@r' + (requireCounter += 1);
    5040. 

  5040.             }
    5041. 

  5041. 

  5042.             nameParts = splitPrefix(name);
    5043. 

  5043.             prefix = nameParts[0];
    5044. 

  5044.             name = nameParts[1];
    5045. 

  5045. 

  5046.             if (prefix) {
    5047. 

  5047.                 prefix = normalize(prefix, parentName, applyMap);
    5048. 

  5048.                 pluginModule = getOwn(defined, prefix);
    5049. 

  5049.             }
    5050. 

  5050. 

  5051.             //Account for relative paths if there is a base name.
    5052. 

  5052.             if (name) {
    5053. 

  5053.                 if (prefix) {
    5054. 

  5054.                     if (pluginModule && pluginModule.normalize) {
    5055. 

  5055.                         //Plugin is loaded, use its normalize method.
    5056. 

  5056.                         normalizedName = pluginModule.normalize(name, function (name) {
    5057. 

  5057.                             return normalize(name, parentName, applyMap);
    5058. 

  5058.                         });
    5059. 

  5059.                     } else {
    5060. 

  5060.                         normalizedName = normalize(name, parentName, applyMap);
    5061. 

  5061.                     }
    5062. 

  5062.                 } else {
    5063. 

  5063.                     //A regular module.
    5064. 

  5064.                     normalizedName = normalize(name, parentName, applyMap);
    5065. 

  5065. 

  5066.                     //Normalized name may be a plugin ID due to map config
    5067. 

  5067.                     //application in normalize. The map config values must
    5068. 

  5068.                     //already be normalized, so do not need to redo that part.
    5069. 

  5069.                     nameParts = splitPrefix(normalizedName);
    5070. 

  5070.                     prefix = nameParts[0];
    5071. 

  5071.                     normalizedName = nameParts[1];
    5072. 

  5072.                     isNormalized = true;
    5073. 

  5073. 

  5074.                     url = context.nameToUrl(normalizedName);
    5075. 

  5075.                 }
    5076. 

  5076.             }
    5077. 

  5077. 

  5078.             //If the id is a plugin id that cannot be determined if it needs
    5079. 

  5079.             //normalization, stamp it with a unique ID so two matching relative
    5080. 

  5080.             //ids that may conflict can be separate.
    5081. 

  5081.             suffix = prefix && !pluginModule && !isNormalized ?
    5082. 

  5082.                      '_unnormalized' + (unnormalizedCounter += 1) :
    5083. 

  5083.                      '';
    5084. 

  5084. 

  5085.             return {
    5086. 

  5086.                 prefix: prefix,
    5087. 

  5087.                 name: normalizedName,
    5088. 

  5088.                 parentMap: parentModuleMap,
    5089. 

  5089.                 unnormalized: !!suffix,
    5090. 

  5090.                 url: url,
    5091. 

  5091.                 originalName: originalName,
    5092. 

  5092.                 isDefine: isDefine,
    5093. 

  5093.                 id: (prefix ?
    5094. 

  5094.                         prefix + '!' + normalizedName :
    5095. 

  5095.                         normalizedName) + suffix
    5096. 

  5096.             };
    5097. 

  5097.         }
    5098. 

  5098. 

  5099.         function getModule(depMap) {
    5100. 

  5100.             var id = depMap.id,
    5101. 

  5101.                 mod = getOwn(registry, id);
    5102. 

  5102. 

  5103.             if (!mod) {
    5104. 

  5104.                 mod = registry[id] = new context.Module(depMap);
    5105. 

  5105.             }
    5106. 

  5106. 

  5107.             return mod;
    5108. 

  5108.         }
    5109. 

  5109. 

  5110.         function on(depMap, name, fn) {
    5111. 

  5111.             var id = depMap.id,
    5112. 

  5112.                 mod = getOwn(registry, id);
    5113. 

  5113. 

  5114.             if (hasProp(defined, id) &&
    5115. 

  5115.                     (!mod || mod.defineEmitComplete)) {
    5116. 

  5116.                 if (name === 'defined') {
    5117. 

  5117.                     fn(defined[id]);
    5118. 

  5118.                 }
    5119. 

  5119.             } else {
    5120. 

  5120.                 getModule(depMap).on(name, fn);
    5121. 

  5121.             }
    5122. 

  5122.         }
    5123. 

  5123. 

  5124.         function onError(err, errback) {
    5125. 

  5125.             var ids = err.requireModules,
    5126. 

  5126.                 notified = false;
    5127. 

  5127. 

  5128.             if (errback) {
    5129. 

  5129.                 errback(err);
    5130. 

  5130.             } else {
    5131. 

  5131.                 each(ids, function (id) {
    5132. 

  5132.                     var mod = getOwn(registry, id);
    5133. 

  5133.                     if (mod) {
    5134. 

  5134.                         //Set error on module, so it skips timeout checks.
    5135. 

  5135.                         mod.error = err;
    5136. 

  5136.                         if (mod.events.error) {
    5137. 

  5137.                             notified = true;
    5138. 

  5138.                             mod.emit('error', err);
    5139. 

  5139.                         }
    5140. 

  5140.                     }
    5141. 

  5141.                 });
    5142. 

  5142. 

  5143.                 if (!notified) {
    5144. 

  5144.                     req.onError(err);
    5145. 

  5145.                 }
    5146. 

  5146.             }
    5147. 

  5147.         }
    5148. 

  5148. 

  5149.         /**
    5150. 

  5150.          * Internal method to transfer globalQueue items to this context's
    5151. 

  5151.          * defQueue.
    5152. 

  5152.          */
    5153. 

  5153.         function takeGlobalQueue() {
    5154. 

  5154.             //Push all the globalDefQueue items into the context's defQueue
    5155. 

  5155.             if (globalDefQueue.length) {
    5156. 

  5156.                 //Array splice in the values since the context code has a
    5157. 

  5157.                 //local var ref to defQueue, so cannot just reassign the one
    5158. 

  5158.                 //on context.
    5159. 

  5159.                 apsp.apply(defQueue,
    5160. 

  5160.                            [defQueue.length - 1, 0].concat(globalDefQueue));
    5161. 

  5161.                 globalDefQueue = [];
    5162. 

  5162.             }
    5163. 

  5163.         }
    5164. 

  5164. 

  5165.         handlers = {
    5166. 

  5166.             'require': function (mod) {
    5167. 

  5167.                 if (mod.require) {
    5168. 

  5168.                     return mod.require;
    5169. 

  5169.                 } else {
    5170. 

  5170.                     return (mod.require = context.makeRequire(mod.map));
    5171. 

  5171.                 }
    5172. 

  5172.             },
    5173. 

  5173.             'exports': function (mod) {
    5174. 

  5174.                 mod.usingExports = true;
    5175. 

  5175.                 if (mod.map.isDefine) {
    5176. 

  5176.                     if (mod.exports) {
    5177. 

  5177.                         return mod.exports;
    5178. 

  5178.                     } else {
    5179. 

  5179.                         return (mod.exports = defined[mod.map.id] = {});
    5180. 

  5180.                     }
    5181. 

  5181.                 }
    5182. 

  5182.             },
    5183. 

  5183.             'module': function (mod) {
    5184. 

  5184.                 if (mod.module) {
    5185. 

  5185.                     return mod.module;
    5186. 

  5186.                 } else {
    5187. 

  5187.                     return (mod.module = {
    5188. 

  5188.                         id: mod.map.id,
    5189. 

  5189.                         uri: mod.map.url,
    5190. 

  5190.                         config: function () {
    5191. 

  5191.                             return (config.config && getOwn(config.config, mod.map.id)) || {};
    5192. 

  5192.                         },
    5193. 

  5193.                         exports: defined[mod.map.id]
    5194. 

  5194.                     });
    5195. 

  5195.                 }
    5196. 

  5196.             }
    5197. 

  5197.         };
    5198. 

  5198. 

  5199.         function cleanRegistry(id) {
    5200. 

  5200.             //Clean up machinery used for waiting modules.
    5201. 

  5201.             delete registry[id];
    5202. 

  5202.         }
    5203. 

  5203. 

  5204.         function breakCycle(mod, traced, processed) {
    5205. 

  5205.             var id = mod.map.id;
    5206. 

  5206. 

  5207.             if (mod.error) {
    5208. 

  5208.                 mod.emit('error', mod.error);
    5209. 

  5209.             } else {
    5210. 

  5210.                 traced[id] = true;
    5211. 

  5211.                 each(mod.depMaps, function (depMap, i) {
    5212. 

  5212.                     var depId = depMap.id,
    5213. 

  5213.                         dep = getOwn(registry, depId);
    5214. 

  5214. 

  5215.                     //Only force things that have not completed
    5216. 

  5216.                     //being defined, so still in the registry,
    5217. 

  5217.                     //and only if it has not been matched up
    5218. 

  5218.                     //in the module already.
    5219. 

  5219.                     if (dep && !mod.depMatched[i] && !processed[depId]) {
    5220. 

  5220.                         if (getOwn(traced, depId)) {
    5221. 

  5221.                             mod.defineDep(i, defined[depId]);
    5222. 

  5222.                             mod.check(); //pass false?
    5223. 

  5223.                         } else {
    5224. 

  5224.                             breakCycle(dep, traced, processed);
    5225. 

  5225.                         }
    5226. 

  5226.                     }
    5227. 

  5227.                 });
    5228. 

  5228.                 processed[id] = true;
    5229. 

  5229.             }
    5230. 

  5230.         }
    5231. 

  5231. 

  5232.         function checkLoaded() {
    5233. 

  5233.             var map, modId, err, usingPathFallback,
    5234. 

  5234.                 waitInterval = config.waitSeconds * 1000,
    5235. 

  5235.                 //It is possible to disable the wait interval by using waitSeconds of 0.
    5236. 

  5236.                 expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
    5237. 

  5237.                 noLoads = [],
    5238. 

  5238.                 reqCalls = [],
    5239. 

  5239.                 stillLoading = false,
    5240. 

  5240.                 needCycleCheck = true;
    5241. 

  5241. 

  5242.             //Do not bother if this call was a result of a cycle break.
    5243. 

  5243.             if (inCheckLoaded) {
    5244. 

  5244.                 return;
    5245. 

  5245.             }
    5246. 

  5246. 

  5247.             inCheckLoaded = true;
    5248. 

  5248. 

  5249.             //Figure out the state of all the modules.
    5250. 

  5250.             eachProp(registry, function (mod) {
    5251. 

  5251.                 map = mod.map;
    5252. 

  5252.                 modId = map.id;
    5253. 

  5253. 

  5254.                 //Skip things that are not enabled or in error state.
    5255. 

  5255.                 if (!mod.enabled) {
    5256. 

  5256.                     return;
    5257. 

  5257.                 }
    5258. 

  5258. 

  5259.                 if (!map.isDefine) {
    5260. 

  5260.                     reqCalls.push(mod);
    5261. 

  5261.                 }
    5262. 

  5262. 

  5263.                 if (!mod.error) {
    5264. 

  5264.                     //If the module should be executed, and it has not
    5265. 

  5265.                     //been inited and time is up, remember it.
    5266. 

  5266.                     if (!mod.inited && expired) {
    5267. 

  5267.                         if (hasPathFallback(modId)) {
    5268. 

  5268.                             usingPathFallback = true;
    5269. 

  5269.                             stillLoading = true;
    5270. 

  5270.                         } else {
    5271. 

  5271.                             noLoads.push(modId);
    5272. 

  5272.                             removeScript(modId);
    5273. 

  5273.                         }
    5274. 

  5274.                     } else if (!mod.inited && mod.fetched && map.isDefine) {
    5275. 

  5275.                         stillLoading = true;
    5276. 

  5276.                         if (!map.prefix) {
    5277. 

  5277.                             //No reason to keep looking for unfinished
    5278. 

  5278.                             //loading. If the only stillLoading is a
    5279. 

  5279.                             //plugin resource though, keep going,
    5280. 

  5280.                             //because it may be that a plugin resource
    5281. 

  5281.                             //is waiting on a non-plugin cycle.
    5282. 

  5282.                             return (needCycleCheck = false);
    5283. 

  5283.                         }
    5284. 

  5284.                     }
    5285. 

  5285.                 }
    5286. 

  5286.             });
    5287. 

  5287. 

  5288.             if (expired && noLoads.length) {
    5289. 

  5289.                 //If wait time expired, throw error of unloaded modules.
    5290. 

  5290.                 err = makeError('timeout', 'Load timeout for modules: ' + noLoads, null, noLoads);
    5291. 

  5291.                 err.contextName = context.contextName;
    5292. 

  5292.                 return onError(err);
    5293. 

  5293.             }
    5294. 

  5294. 

  5295.             //Not expired, check for a cycle.
    5296. 

  5296.             if (needCycleCheck) {
    5297. 

  5297.                 each(reqCalls, function (mod) {
    5298. 

  5298.                     breakCycle(mod, {}, {});
    5299. 

  5299.                 });
    5300. 

  5300.             }
    5301. 

  5301. 

  5302.             //If still waiting on loads, and the waiting load is something
    5303. 

  5303.             //other than a plugin resource, or there are still outstanding
    5304. 

  5304.             //scripts, then just try back later.
    5305. 

  5305.             if ((!expired || usingPathFallback) && stillLoading) {
    5306. 

  5306.                 //Something is still waiting to load. Wait for it, but only
    5307. 

  5307.                 //if a timeout is not already in effect.
    5308. 

  5308.                 if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {
    5309. 

  5309.                     checkLoadedTimeoutId = setTimeout(function () {
    5310. 

  5310.                         checkLoadedTimeoutId = 0;
    5311. 

  5311.                         checkLoaded();
    5312. 

  5312.                     }, 50);
    5313. 

  5313.                 }
    5314. 

  5314.             }
    5315. 

  5315. 

  5316.             inCheckLoaded = false;
    5317. 

  5317.         }
    5318. 

  5318. 

  5319.         Module = function (map) {
    5320. 

  5320.             this.events = getOwn(undefEvents, map.id) || {};
    5321. 

  5321.             this.map = map;
    5322. 

  5322.             this.shim = getOwn(config.shim, map.id);
    5323. 

  5323.             this.depExports = [];
    5324. 

  5324.             this.depMaps = [];
    5325. 

  5325.             this.depMatched = [];
    5326. 

  5326.             this.pluginMaps = {};
    5327. 

  5327.             this.depCount = 0;
    5328. 

  5328. 

  5329.             /* this.exports this.factory
    5330. 

  5330.                this.depMaps = [],
    5331. 

  5331.                this.enabled, this.fetched
    5332. 

  5332.             */
    5333. 

  5333.         };
    5334. 

  5334. 

  5335.         Module.prototype = {
    5336. 

  5336.             init: function (depMaps, factory, errback, options) {
    5337. 

  5337.                 options = options || {};
    5338. 

  5338. 

  5339.                 //Do not do more inits if already done. Can happen if there
    5340. 

  5340.                 //are multiple define calls for the same module. That is not
    5341. 

  5341.                 //a normal, common case, but it is also not unexpected.
    5342. 

  5342.                 if (this.inited) {
    5343. 

  5343.                     return;
    5344. 

  5344.                 }
    5345. 

  5345. 

  5346.                 this.factory = factory;
    5347. 

  5347. 

  5348.                 if (errback) {
    5349. 

  5349.                     //Register for errors on this module.
    5350. 

  5350.                     this.on('error', errback);
    5351. 

  5351.                 } else if (this.events.error) {
    5352. 

  5352.                     //If no errback already, but there are error listeners
    5353. 

  5353.                     //on this module, set up an errback to pass to the deps.
    5354. 

  5354.                     errback = bind(this, function (err) {
    5355. 

  5355.                         this.emit('error', err);
    5356. 

  5356.                     });
    5357. 

  5357.                 }
    5358. 

  5358. 

  5359.                 //Do a copy of the dependency array, so that
    5360. 

  5360.                 //source inputs are not modified. For example
    5361. 

  5361.                 //"shim" deps are passed in here directly, and
    5362. 

  5362.                 //doing a direct modification of the depMaps array
    5363. 

  5363.                 //would affect that config.
    5364. 

  5364.                 this.depMaps = depMaps && depMaps.slice(0);
    5365. 

  5365. 

  5366.                 this.errback = errback;
    5367. 

  5367. 

  5368.                 //Indicate this module has be initialized
    5369. 

  5369.                 this.inited = true;
    5370. 

  5370. 

  5371.                 this.ignore = options.ignore;
    5372. 

  5372. 

  5373.                 //Could have option to init this module in enabled mode,
    5374. 

  5374.                 //or could have been previously marked as enabled. However,
    5375. 

  5375.                 //the dependencies are not known until init is called. So
    5376. 

  5376.                 //if enabled previously, now trigger dependencies as enabled.
    5377. 

  5377.                 if (options.enabled || this.enabled) {
    5378. 

  5378.                     //Enable this module and dependencies.
    5379. 

  5379.                     //Will call this.check()
    5380. 

  5380.                     this.enable();
    5381. 

  5381.                 } else {
    5382. 

  5382.                     this.check();
    5383. 

  5383.                 }
    5384. 

  5384.             },
    5385. 

  5385. 

  5386.             defineDep: function (i, depExports) {
    5387. 

  5387.                 //Because of cycles, defined callback for a given
    5388. 

  5388.                 //export can be called more than once.
    5389. 

  5389.                 if (!this.depMatched[i]) {
    5390. 

  5390.                     this.depMatched[i] = true;
    5391. 

  5391.                     this.depCount -= 1;
    5392. 

  5392.                     this.depExports[i] = depExports;
    5393. 

  5393.                 }
    5394. 

  5394.             },
    5395. 

  5395. 

  5396.             fetch: function () {
    5397. 

  5397.                 if (this.fetched) {
    5398. 

  5398.                     return;
    5399. 

  5399.                 }
    5400. 

  5400.                 this.fetched = true;
    5401. 

  5401. 

  5402.                 context.startTime = (new Date()).getTime();
    5403. 

  5403. 

  5404.                 var map = this.map;
    5405. 

  5405. 

  5406.                 //If the manager is for a plugin managed resource,
    5407. 

  5407.                 //ask the plugin to load it now.
    5408. 

  5408.                 if (this.shim) {
    5409. 

  5409.                     context.makeRequire(this.map, {
    5410. 

  5410.                         enableBuildCallback: true
    5411. 

  5411.                     })(this.shim.deps || [], bind(this, function () {
    5412. 

  5412.                         return map.prefix ? this.callPlugin() : this.load();
    5413. 

  5413.                     }));
    5414. 

  5414.                 } else {
    5415. 

  5415.                     //Regular dependency.
    5416. 

  5416.                     return map.prefix ? this.callPlugin() : this.load();
    5417. 

  5417.                 }
    5418. 

  5418.             },
    5419. 

  5419. 

  5420.             load: function () {
    5421. 

  5421.                 var url = this.map.url;
    5422. 

  5422. 

  5423.                 //Regular dependency.
    5424. 

  5424.                 if (!urlFetched[url]) {
    5425. 

  5425.                     urlFetched[url] = true;
    5426. 

  5426.                     context.load(this.map.id, url);
    5427. 

  5427.                 }
    5428. 

  5428.             },
    5429. 

  5429. 

  5430.             /**
    5431. 

  5431.              * Checks is the module is ready to define itself, and if so,
    5432. 

  5432.              * define it.
    5433. 

  5433.              */
    5434. 

  5434.             check: function () {
    5435. 

  5435.                 if (!this.enabled || this.enabling) {
    5436. 

  5436.                     return;
    5437. 

  5437.                 }
    5438. 

  5438. 

  5439.                 var err, cjsModule,
    5440. 

  5440.                     id = this.map.id,
    5441. 

  5441.                     depExports = this.depExports,
    5442. 

  5442.                     exports = this.exports,
    5443. 

  5443.                     factory = this.factory;
    5444. 

  5444. 

  5445.                 if (!this.inited) {
    5446. 

  5446.                     this.fetch();
    5447. 

  5447.                 } else if (this.error) {
    5448. 

  5448.                     this.emit('error', this.error);
    5449. 

  5449.                 } else if (!this.defining) {
    5450. 

  5450.                     //The factory could trigger another require call
    5451. 

  5451.                     //that would result in checking this module to
    5452. 

  5452.                     //define itself again. If already in the process
    5453. 

  5453.                     //of doing that, skip this work.
    5454. 

  5454.                     this.defining = true;
    5455. 

  5455. 

  5456.                     if (this.depCount < 1 && !this.defined) {
    5457. 

  5457.                         if (isFunction(factory)) {
    5458. 

  5458.                             //If there is an error listener, favor passing
    5459. 

  5459.                             //to that instead of throwing an error.
    5460. 

  5460.                             if (this.events.error) {
    5461. 

  5461.                                 try {
    5462. 

  5462.                                     exports = context.execCb(id, factory, depExports, exports);
    5463. 

  5463.                                 } catch (e) {
    5464. 

  5464.                                     err = e;
    5465. 

  5465.                                 }
    5466. 

  5466.                             } else {
    5467. 

  5467.                                 exports = context.execCb(id, factory, depExports, exports);
    5468. 

  5468.                             }
    5469. 

  5469. 

  5470.                             if (this.map.isDefine) {
    5471. 

  5471.                                 //If setting exports via 'module' is in play,
    5472. 

  5472.                                 //favor that over return value and exports. After that,
    5473. 

  5473.                                 //favor a non-undefined return value over exports use.
    5474. 

  5474.                                 cjsModule = this.module;
    5475. 

  5475.                                 if (cjsModule &&
    5476. 

  5476.                                         cjsModule.exports !== undefined &&
    5477. 

  5477.                                         //Make sure it is not already the exports value
    5478. 

  5478.                                         cjsModule.exports !== this.exports) {
    5479. 

  5479.                                     exports = cjsModule.exports;
    5480. 

  5480.                                 } else if (exports === undefined && this.usingExports) {
    5481. 

  5481.                                     //exports already set the defined value.
    5482. 

  5482.                                     exports = this.exports;
    5483. 

  5483.                                 }
    5484. 

  5484.                             }
    5485. 

  5485. 

  5486.                             if (err) {
    5487. 

  5487.                                 err.requireMap = this.map;
    5488. 

  5488.                                 err.requireModules = [this.map.id];
    5489. 

  5489.                                 err.requireType = 'define';
    5490. 

  5490.                                 return onError((this.error = err));
    5491. 

  5491.                             }
    5492. 

  5492. 

  5493.                         } else {
    5494. 

  5494.                             //Just a literal value
    5495. 

  5495.                             exports = factory;
    5496. 

  5496.                         }
    5497. 

  5497. 

  5498.                         this.exports = exports;
    5499. 

  5499. 

  5500.                         if (this.map.isDefine && !this.ignore) {
    5501. 

  5501.                             defined[id] = exports;
    5502. 

  5502. 

  5503.                             if (req.onResourceLoad) {
    5504. 

  5504.                                 req.onResourceLoad(context, this.map, this.depMaps);
    5505. 

  5505.                             }
    5506. 

  5506.                         }
    5507. 

  5507. 

  5508.                         //Clean up
    5509. 

  5509.                         delete registry[id];
    5510. 

  5510. 

  5511.                         this.defined = true;
    5512. 

  5512.                     }
    5513. 

  5513. 

  5514.                     //Finished the define stage. Allow calling check again
    5515. 

  5515.                     //to allow define notifications below in the case of a
    5516. 

  5516.                     //cycle.
    5517. 

  5517.                     this.defining = false;
    5518. 

  5518. 

  5519.                     if (this.defined && !this.defineEmitted) {
    5520. 

  5520.                         this.defineEmitted = true;
    5521. 

  5521.                         this.emit('defined', this.exports);
    5522. 

  5522.                         this.defineEmitComplete = true;
    5523. 

  5523.                     }
    5524. 

  5524. 

  5525.                 }
    5526. 

  5526.             },
    5527. 

  5527. 

  5528.             callPlugin: function () {
    5529. 

  5529.                 var map = this.map,
    5530. 

  5530.                     id = map.id,
    5531. 

  5531.                     //Map already normalized the prefix.
    5532. 

  5532.                     pluginMap = makeModuleMap(map.prefix);
    5533. 

  5533. 

  5534.                 //Mark this as a dependency for this plugin, so it
    5535. 

  5535.                 //can be traced for cycles.
    5536. 

  5536.                 this.depMaps.push(pluginMap);
    5537. 

  5537. 

  5538.                 on(pluginMap, 'defined', bind(this, function (plugin) {
    5539. 

  5539.                     var load, normalizedMap, normalizedMod,
    5540. 

  5540.                         name = this.map.name,
    5541. 

  5541.                         parentName = this.map.parentMap ? this.map.parentMap.name : null,
    5542. 

  5542.                         localRequire = context.makeRequire(map.parentMap, {
    5543. 

  5543.                             enableBuildCallback: true
    5544. 

  5544.                         });
    5545. 

  5545. 

  5546.                     //If current map is not normalized, wait for that
    5547. 

  5547.                     //normalized name to load instead of continuing.
    5548. 

  5548.                     if (this.map.unnormalized) {
    5549. 

  5549.                         //Normalize the ID if the plugin allows it.
    5550. 

  5550.                         if (plugin.normalize) {
    5551. 

  5551.                             name = plugin.normalize(name, function (name) {
    5552. 

  5552.                                 return normalize(name, parentName, true);
    5553. 

  5553.                             }) || '';
    5554. 

  5554.                         }
    5555. 

  5555. 

  5556.                         //prefix and name should already be normalized, no need
    5557. 

  5557.                         //for applying map config again either.
    5558. 

  5558.                         normalizedMap = makeModuleMap(map.prefix + '!' + name,
    5559. 

  5559.                                                       this.map.parentMap);
    5560. 

  5560.                         on(normalizedMap,
    5561. 

  5561.                             'defined', bind(this, function (value) {
    5562. 

  5562.                                 this.init([], function () { return value; }, null, {
    5563. 

  5563.                                     enabled: true,
    5564. 

  5564.                                     ignore: true
    5565. 

  5565.                                 });
    5566. 

  5566.                             }));
    5567. 

  5567. 

  5568.                         normalizedMod = getOwn(registry, normalizedMap.id);
    5569. 

  5569.                         if (normalizedMod) {
    5570. 

  5570.                             //Mark this as a dependency for this plugin, so it
    5571. 

  5571.                             //can be traced for cycles.
    5572. 

  5572.                             this.depMaps.push(normalizedMap);
    5573. 

  5573. 

  5574.                             if (this.events.error) {
    5575. 

  5575.                                 normalizedMod.on('error', bind(this, function (err) {
    5576. 

  5576.                                     this.emit('error', err);
    5577. 

  5577.                                 }));
    5578. 

  5578.                             }
    5579. 

  5579.                             normalizedMod.enable();
    5580. 

  5580.                         }
    5581. 

  5581. 

  5582.                         return;
    5583. 

  5583.                     }
    5584. 

  5584. 

  5585.                     load = bind(this, function (value) {
    5586. 

  5586.                         this.init([], function () { return value; }, null, {
    5587. 

  5587.                             enabled: true
    5588. 

  5588.                         });
    5589. 

  5589.                     });
    5590. 

  5590. 

  5591.                     load.error = bind(this, function (err) {
    5592. 

  5592.                         this.inited = true;
    5593. 

  5593.                         this.error = err;
    5594. 

  5594.                         err.requireModules = [id];
    5595. 

  5595. 

  5596.                         //Remove temp unnormalized modules for this module,
    5597. 

  5597.                         //since they will never be resolved otherwise now.
    5598. 

  5598.                         eachProp(registry, function (mod) {
    5599. 

  5599.                             if (mod.map.id.indexOf(id + '_unnormalized') === 0) {
    5600. 

  5600.                                 cleanRegistry(mod.map.id);
    5601. 

  5601.                             }
    5602. 

  5602.                         });
    5603. 

  5603. 

  5604.                         onError(err);
    5605. 

  5605.                     });
    5606. 

  5606. 

  5607.                     //Allow plugins to load other code without having to know the
    5608. 

  5608.                     //context or how to 'complete' the load.
    5609. 

  5609.                     load.fromText = bind(this, function (text, textAlt) {
    5610. 

  5610.                         /*jslint evil: true */
    5611. 

  5611.                         var moduleName = map.name,
    5612. 

  5612.                             moduleMap = makeModuleMap(moduleName),
    5613. 

  5613.                             hasInteractive = useInteractive;
    5614. 

  5614. 

  5615.                         //As of 2.1.0, support just passing the text, to reinforce
    5616. 

  5616.                         //fromText only being called once per resource. Still
    5617. 

  5617.                         //support old style of passing moduleName but discard
    5618. 

  5618.                         //that moduleName in favor of the internal ref.
    5619. 

  5619.                         if (textAlt) {
    5620. 

  5620.                             text = textAlt;
    5621. 

  5621.                         }
    5622. 

  5622. 

  5623.                         //Turn off interactive script matching for IE for any define
    5624. 

  5624.                         //calls in the text, then turn it back on at the end.
    5625. 

  5625.                         if (hasInteractive) {
    5626. 

  5626.                             useInteractive = false;
    5627. 

  5627.                         }
    5628. 

  5628. 

  5629.                         //Prime the system by creating a module instance for
    5630. 

  5630.                         //it.
    5631. 

  5631.                         getModule(moduleMap);
    5632. 

  5632. 

  5633.                         //Transfer any config to this other module.
    5634. 

  5634.                         if (hasProp(config.config, id)) {
    5635. 

  5635.                             config.config[moduleName] = config.config[id];
    5636. 

  5636.                         }
    5637. 

  5637. 

  5638.                         try {
    5639. 

  5639.                             req.exec(text);
    5640. 

  5640.                         } catch (e) {
    5641. 

  5641.                             return onError(makeError('fromtexteval',
    5642. 

  5642.                                              'fromText eval for ' + id +
    5643. 

  5643.                                             ' failed: ' + e,
    5644. 

  5644.                                              e,
    5645. 

  5645.                                              [id]));
    5646. 

  5646.                         }
    5647. 

  5647. 

  5648.                         if (hasInteractive) {
    5649. 

  5649.                             useInteractive = true;
    5650. 

  5650.                         }
    5651. 

  5651. 

  5652.                         //Mark this as a dependency for the plugin
    5653. 

  5653.                         //resource
    5654. 

  5654.                         this.depMaps.push(moduleMap);
    5655. 

  5655. 

  5656.                         //Support anonymous modules.
    5657. 

  5657.                         context.completeLoad(moduleName);
    5658. 

  5658. 

  5659.                         //Bind the value of that module to the value for this
    5660. 

  5660.                         //resource ID.
    5661. 

  5661.                         localRequire([moduleName], load);
    5662. 

  5662.                     });
    5663. 

  5663. 

  5664.                     //Use parentName here since the plugin's name is not reliable,
    5665. 

  5665.                     //could be some weird string with no path that actually wants to
    5666. 

  5666.                     //reference the parentName's path.
    5667. 

  5667.                     plugin.load(map.name, localRequire, load, config);
    5668. 

  5668.                 }));
    5669. 

  5669. 

  5670.                 context.enable(pluginMap, this);
    5671. 

  5671.                 this.pluginMaps[pluginMap.id] = pluginMap;
    5672. 

  5672.             },
    5673. 

  5673. 

  5674.             enable: function () {
    5675. 

  5675.                 this.enabled = true;
    5676. 

  5676. 

  5677.                 //Set flag mentioning that the module is enabling,
    5678. 

  5678.                 //so that immediate calls to the defined callbacks
    5679. 

  5679.                 //for dependencies do not trigger inadvertent load
    5680. 

  5680.                 //with the depCount still being zero.
    5681. 

  5681.                 this.enabling = true;
    5682. 

  5682. 

  5683.                 //Enable each dependency
    5684. 

  5684.                 each(this.depMaps, bind(this, function (depMap, i) {
    5685. 

  5685.                     var id, mod, handler;
    5686. 

  5686. 

  5687.                     if (typeof depMap === 'string') {
    5688. 

  5688.                         //Dependency needs to be converted to a depMap
    5689. 

  5689.                         //and wired up to this module.
    5690. 

  5690.                         depMap = makeModuleMap(depMap,
    5691. 

  5691.                                                (this.map.isDefine ? this.map : this.map.parentMap),
    5692. 

  5692.                                                false,
    5693. 

  5693.                                                !this.skipMap);
    5694. 

  5694.                         this.depMaps[i] = depMap;
    5695. 

  5695. 

  5696.                         handler = getOwn(handlers, depMap.id);
    5697. 

  5697. 

  5698.                         if (handler) {
    5699. 

  5699.                             this.depExports[i] = handler(this);
    5700. 

  5700.                             return;
    5701. 

  5701.                         }
    5702. 

  5702. 

  5703.                         this.depCount += 1;
    5704. 

  5704. 

  5705.                         on(depMap, 'defined', bind(this, function (depExports) {
    5706. 

  5706.                             this.defineDep(i, depExports);
    5707. 

  5707.                             this.check();
    5708. 

  5708.                         }));
    5709. 

  5709. 

  5710.                         if (this.errback) {
    5711. 

  5711.                             on(depMap, 'error', this.errback);
    5712. 

  5712.                         }
    5713. 

  5713.                     }
    5714. 

  5714. 

  5715.                     id = depMap.id;
    5716. 

  5716.                     mod = registry[id];
    5717. 

  5717. 

  5718.                     //Skip special modules like 'require', 'exports', 'module'
    5719. 

  5719.                     //Also, don't call enable if it is already enabled,
    5720. 

  5720.                     //important in circular dependency cases.
    5721. 

  5721.                     if (!hasProp(handlers, id) && mod && !mod.enabled) {
    5722. 

  5722.                         context.enable(depMap, this);
    5723. 

  5723.                     }
    5724. 

  5724.                 }));
    5725. 

  5725. 

  5726.                 //Enable each plugin that is used in
    5727. 

  5727.                 //a dependency
    5728. 

  5728.                 eachProp(this.pluginMaps, bind(this, function (pluginMap) {
    5729. 

  5729.                     var mod = getOwn(registry, pluginMap.id);
    5730. 

  5730.                     if (mod && !mod.enabled) {
    5731. 

  5731.                         context.enable(pluginMap, this);
    5732. 

  5732.                     }
    5733. 

  5733.                 }));
    5734. 

  5734. 

  5735.                 this.enabling = false;
    5736. 

  5736. 

  5737.                 this.check();
    5738. 

  5738.             },
    5739. 

  5739. 

  5740.             on: function (name, cb) {
    5741. 

  5741.                 var cbs = this.events[name];
    5742. 

  5742.                 if (!cbs) {
    5743. 

  5743.                     cbs = this.events[name] = [];
    5744. 

  5744.                 }
    5745. 

  5745.                 cbs.push(cb);
    5746. 

  5746.             },
    5747. 

  5747. 

  5748.             emit: function (name, evt) {
    5749. 

  5749.                 each(this.events[name], function (cb) {
    5750. 

  5750.                     cb(evt);
    5751. 

  5751.                 });
    5752. 

  5752.                 if (name === 'error') {
    5753. 

  5753.                     //Now that the error handler was triggered, remove
    5754. 

  5754.                     //the listeners, since this broken Module instance
    5755. 

  5755.                     //can stay around for a while in the registry.
    5756. 

  5756.                     delete this.events[name];
    5757. 

  5757.                 }
    5758. 

  5758.             }
    5759. 

  5759.         };
    5760. 

  5760. 

  5761.         function callGetModule(args) {
    5762. 

  5762.             //Skip modules already defined.
    5763. 

  5763.             if (!hasProp(defined, args[0])) {
    5764. 

  5764.                 getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2]);
    5765. 

  5765.             }
    5766. 

  5766.         }
    5767. 

  5767. 

  5768.         function removeListener(node, func, name, ieName) {
    5769. 

  5769.             //Favor detachEvent because of IE9
    5770. 

  5770.             //issue, see attachEvent/addEventListener comment elsewhere
    5771. 

  5771.             //in this file.
    5772. 

  5772.             if (node.detachEvent && !isOpera) {
    5773. 

  5773.                 //Probably IE. If not it will throw an error, which will be
    5774. 

  5774.                 //useful to know.
    5775. 

  5775.                 if (ieName) {
    5776. 

  5776.                     node.detachEvent(ieName, func);
    5777. 

  5777.                 }
    5778. 

  5778.             } else {
    5779. 

  5779.                 node.removeEventListener(name, func, false);
    5780. 

  5780.             }
    5781. 

  5781.         }
    5782. 

  5782. 

  5783.         /**
    5784. 

  5784.          * Given an event from a script node, get the requirejs info from it,
    5785. 

  5785.          * and then removes the event listeners on the node.
    5786. 

  5786.          * @param {Event} evt
    5787. 

  5787.          * @returns {Object}
    5788. 

  5788.          */
    5789. 

  5789.         function getScriptData(evt) {
    5790. 

  5790.             //Using currentTarget instead of target for Firefox 2.0's sake. Not
    5791. 

  5791.             //all old browsers will be supported, but this one was easy enough
    5792. 

  5792.             //to support and still makes sense.
    5793. 

  5793.             var node = evt.currentTarget || evt.srcElement;
    5794. 

  5794. 

  5795.             //Remove the listeners once here.
    5796. 

  5796.             removeListener(node, context.onScriptLoad, 'load', 'onreadystatechange');
    5797. 

  5797.             removeListener(node, context.onScriptError, 'error');
    5798. 

  5798. 

  5799.             return {
    5800. 

  5800.                 node: node,
    5801. 

  5801.                 id: node && node.getAttribute('data-requiremodule')
    5802. 

  5802.             };
    5803. 

  5803.         }
    5804. 

  5804. 

  5805.         function intakeDefines() {
    5806. 

  5806.             var args;
    5807. 

  5807. 

  5808.             //Any defined modules in the global queue, intake them now.
    5809. 

  5809.             takeGlobalQueue();
    5810. 

  5810. 

  5811.             //Make sure any remaining defQueue items get properly processed.
    5812. 

  5812.             while (defQueue.length) {
    5813. 

  5813.                 args = defQueue.shift();
    5814. 

  5814.                 if (args[0] === null) {
    5815. 

  5815.                     return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' + args[args.length - 1]));
    5816. 

  5816.                 } else {
    5817. 

  5817.                     //args are id, deps, factory. Should be normalized by the
    5818. 

  5818.                     //define() function.
    5819. 

  5819.                     callGetModule(args);
    5820. 

  5820.                 }
    5821. 

  5821.             }
    5822. 

  5822.         }
    5823. 

  5823. 

  5824.         context = {
    5825. 

  5825.             config: config,
    5826. 

  5826.             contextName: contextName,
    5827. 

  5827.             registry: registry,
    5828. 

  5828.             defined: defined,
    5829. 

  5829.             urlFetched: urlFetched,
    5830. 

  5830.             defQueue: defQueue,
    5831. 

  5831.             Module: Module,
    5832. 

  5832.             makeModuleMap: makeModuleMap,
    5833. 

  5833.             nextTick: req.nextTick,
    5834. 

  5834. 

  5835.             /**
    5836. 

  5836.              * Set a configuration for the context.
    5837. 

  5837.              * @param {Object} cfg config object to integrate.
    5838. 

  5838.              */
    5839. 

  5839.             configure: function (cfg) {
    5840. 

  5840.                 //Make sure the baseUrl ends in a slash.
    5841. 

  5841.                 if (cfg.baseUrl) {
    5842. 

  5842.                     if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {
    5843. 

  5843.                         cfg.baseUrl += '/';
    5844. 

  5844.                     }
    5845. 

  5845.                 }
    5846. 

  5846. 

  5847.                 //Save off the paths and packages since they require special processing,
    5848. 

  5848.                 //they are additive.
    5849. 

  5849.                 var pkgs = config.pkgs,
    5850. 

  5850.                     shim = config.shim,
    5851. 

  5851.                     objs = {
    5852. 

  5852.                         paths: true,
    5853. 

  5853.                         config: true,
    5854. 

  5854.                         map: true
    5855. 

  5855.                     };
    5856. 

  5856. 

  5857.                 eachProp(cfg, function (value, prop) {
    5858. 

  5858.                     if (objs[prop]) {
    5859. 

  5859.                         if (prop === 'map') {
    5860. 

  5860.                             mixin(config[prop], value, true, true);
    5861. 

  5861.                         } else {
    5862. 

  5862.                             mixin(config[prop], value, true);
    5863. 

  5863.                         }
    5864. 

  5864.                     } else {
    5865. 

  5865.                         config[prop] = value;
    5866. 

  5866.                     }
    5867. 

  5867.                 });
    5868. 

  5868. 

  5869.                 //Merge shim
    5870. 

  5870.                 if (cfg.shim) {
    5871. 

  5871.                     eachProp(cfg.shim, function (value, id) {
    5872. 

  5872.                         //Normalize the structure
    5873. 

  5873.                         if (isArray(value)) {
    5874. 

  5874.                             value = {
    5875. 

  5875.                                 deps: value
    5876. 

  5876.                             };
    5877. 

  5877.                         }
    5878. 

  5878.                         if ((value.exports || value.init) && !value.exportsFn) {
    5879. 

  5879.                             value.exportsFn = context.makeShimExports(value);
    5880. 

  5880.                         }
    5881. 

  5881.                         shim[id] = value;
    5882. 

  5882.                     });
    5883. 

  5883.                     config.shim = shim;
    5884. 

  5884.                 }
    5885. 

  5885. 

  5886.                 //Adjust packages if necessary.
    5887. 

  5887.                 if (cfg.packages) {
    5888. 

  5888.                     each(cfg.packages, function (pkgObj) {
    5889. 

  5889.                         var location;
    5890. 

  5890. 

  5891.                         pkgObj = typeof pkgObj === 'string' ? { name: pkgObj } : pkgObj;
    5892. 

  5892.                         location = pkgObj.location;
    5893. 

  5893. 

  5894.                         //Create a brand new object on pkgs, since currentPackages can
    5895. 

  5895.                         //be passed in again, and config.pkgs is the internal transformed
    5896. 

  5896.                         //state for all package configs.
    5897. 

  5897.                         pkgs[pkgObj.name] = {
    5898. 

  5898.                             name: pkgObj.name,
    5899. 

  5899.                             location: location || pkgObj.name,
    5900. 

  5900.                             //Remove leading dot in main, so main paths are normalized,
    5901. 

  5901.                             //and remove any trailing .js, since different package
    5902. 

  5902.                             //envs have different conventions: some use a module name,
    5903. 

  5903.                             //some use a file name.
    5904. 

  5904.                             main: (pkgObj.main || 'main')
    5905. 

  5905.                                   .replace(currDirRegExp, '')
    5906. 

  5906.                                   .replace(jsSuffixRegExp, '')
    5907. 

  5907.                         };
    5908. 

  5908.                     });
    5909. 

  5909. 

  5910.                     //Done with modifications, assing packages back to context config
    5911. 

  5911.                     config.pkgs = pkgs;
    5912. 

  5912.                 }
    5913. 

  5913. 

  5914.                 //If there are any "waiting to execute" modules in the registry,
    5915. 

  5915.                 //update the maps for them, since their info, like URLs to load,
    5916. 

  5916.                 //may have changed.
    5917. 

  5917.                 eachProp(registry, function (mod, id) {
    5918. 

  5918.                     //If module already has init called, since it is too
    5919. 

  5919.                     //late to modify them, and ignore unnormalized ones
    5920. 

  5920.                     //since they are transient.
    5921. 

  5921.                     if (!mod.inited && !mod.map.unnormalized) {
    5922. 

  5922.                         mod.map = makeModuleMap(id);
    5923. 

  5923.                     }
    5924. 

  5924.                 });
    5925. 

  5925. 

  5926.                 //If a deps array or a config callback is specified, then call
    5927. 

  5927.                 //require with those args. This is useful when require is defined as a
    5928. 

  5928.                 //config object before require.js is loaded.
    5929. 

  5929.                 if (cfg.deps || cfg.callback) {
    5930. 

  5930.                     context.require(cfg.deps || [], cfg.callback);
    5931. 

  5931.                 }
    5932. 

  5932.             },
    5933. 

  5933. 

  5934.             makeShimExports: function (value) {
    5935. 

  5935.                 function fn() {
    5936. 

  5936.                     var ret;
    5937. 

  5937.                     if (value.init) {
    5938. 

  5938.                         ret = value.init.apply(global, arguments);
    5939. 

  5939.                     }
    5940. 

  5940.                     return ret || (value.exports && getGlobal(value.exports));
    5941. 

  5941.                 }
    5942. 

  5942.                 return fn;
    5943. 

  5943.             },
    5944. 

  5944. 

  5945.             makeRequire: function (relMap, options) {
    5946. 

  5946.                 options = options || {};
    5947. 

  5947. 

  5948.                 function localRequire(deps, callback, errback) {
    5949. 

  5949.                     var id, map, requireMod;
    5950. 

  5950. 

  5951.                     if (options.enableBuildCallback && callback && isFunction(callback)) {
    5952. 

  5952.                         callback.__requireJsBuild = true;
    5953. 

  5953.                     }
    5954. 

  5954. 

  5955.                     if (typeof deps === 'string') {
    5956. 

  5956.                         if (isFunction(callback)) {
    5957. 

  5957.                             //Invalid call
    5958. 

  5958.                             return onError(makeError('requireargs', 'Invalid require call'), errback);
    5959. 

  5959.                         }
    5960. 

  5960. 

  5961.                         //If require|exports|module are requested, get the
    5962. 

  5962.                         //value for them from the special handlers. Caveat:
    5963. 

  5963.                         //this only works while module is being defined.
    5964. 

  5964.                         if (relMap && hasProp(handlers, deps)) {
    5965. 

  5965.                             return handlers[deps](registry[relMap.id]);
    5966. 

  5966.                         }
    5967. 

  5967. 

  5968.                         //Synchronous access to one module. If require.get is
    5969. 

  5969.                         //available (as in the Node adapter), prefer that.
    5970. 

  5970.                         if (req.get) {
    5971. 

  5971.                             return req.get(context, deps, relMap);
    5972. 

  5972.                         }
    5973. 

  5973. 

  5974.                         //Normalize module name, if it contains . or ..
    5975. 

  5975.                         map = makeModuleMap(deps, relMap, false, true);
    5976. 

  5976.                         id = map.id;
    5977. 

  5977. 

  5978.                         if (!hasProp(defined, id)) {
    5979. 

  5979.                             return onError(makeError('notloaded', 'Module name "' +
    5980. 

  5980.                                         id +
    5981. 

  5981.                                         '" has not been loaded yet for context: ' +
    5982. 

  5982.                                         contextName +
    5983. 

  5983.                                         (relMap ? '' : '. Use require([])')));
    5984. 

  5984.                         }
    5985. 

  5985.                         return defined[id];
    5986. 

  5986.                     }
    5987. 

  5987. 

  5988.                     //Grab defines waiting in the global queue.
    5989. 

  5989.                     intakeDefines();
    5990. 

  5990. 

  5991.                     //Mark all the dependencies as needing to be loaded.
    5992. 

  5992.                     context.nextTick(function () {
    5993. 

  5993.                         //Some defines could have been added since the
    5994. 

  5994.                         //require call, collect them.
    5995. 

  5995.                         intakeDefines();
    5996. 

  5996. 

  5997.                         requireMod = getModule(makeModuleMap(null, relMap));
    5998. 

  5998. 

  5999.                         //Store if map config should be applied to this require
    6000. 

  6000.                         //call for dependencies.
    6001. 

  6001.                         requireMod.skipMap = options.skipMap;
    6002. 

  6002. 

  6003.                         requireMod.init(deps, callback, errback, {
    6004. 

  6004.                             enabled: true
    6005. 

  6005.                         });
    6006. 

  6006. 

  6007.                         checkLoaded();
    6008. 

  6008.                     });
    6009. 

  6009. 

  6010.                     return localRequire;
    6011. 

  6011.                 }
    6012. 

  6012. 

  6013.                 mixin(localRequire, {
    6014. 

  6014.                     isBrowser: isBrowser,
    6015. 

  6015. 

  6016.                     /**
    6017. 

  6017.                      * Converts a module name + .extension into an URL path.
    6018. 

  6018.                      * *Requires* the use of a module name. It does not support using
    6019. 

  6019.                      * plain URLs like nameToUrl.
    6020. 

  6020.                      */
    6021. 

  6021.                     toUrl: function (moduleNamePlusExt) {
    6022. 

  6022.                         var ext, url,
    6023. 

  6023.                             index = moduleNamePlusExt.lastIndexOf('.'),
    6024. 

  6024.                             segment = moduleNamePlusExt.split('/')[0],
    6025. 

  6025.                             isRelative = segment === '.' || segment === '..';
    6026. 

  6026. 

  6027.                         //Have a file extension alias, and it is not the
    6028. 

  6028.                         //dots from a relative path.
    6029. 

  6029.                         if (index !== -1 && (!isRelative || index > 1)) {
    6030. 

  6030.                             ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
    6031. 

  6031.                             moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
    6032. 

  6032.                         }
    6033. 

  6033. 

  6034.                         url = context.nameToUrl(normalize(moduleNamePlusExt,
    6035. 

  6035.                                                 relMap && relMap.id, true), ext || '.fake');
    6036. 

  6036.                         return ext ? url : url.substring(0, url.length - 5);
    6037. 

  6037.                     },
    6038. 

  6038. 

  6039.                     defined: function (id) {
    6040. 

  6040.                         return hasProp(defined, makeModuleMap(id, relMap, false, true).id);
    6041. 

  6041.                     },
    6042. 

  6042. 

  6043.                     specified: function (id) {
    6044. 

  6044.                         id = makeModuleMap(id, relMap, false, true).id;
    6045. 

  6045.                         return hasProp(defined, id) || hasProp(registry, id);
    6046. 

  6046.                     }
    6047. 

  6047.                 });
    6048. 

  6048. 

  6049.                 //Only allow undef on top level require calls
    6050. 

  6050.                 if (!relMap) {
    6051. 

  6051.                     localRequire.undef = function (id) {
    6052. 

  6052.                         //Bind any waiting define() calls to this context,
    6053. 

  6053.                         //fix for #408
    6054. 

  6054.                         takeGlobalQueue();
    6055. 

  6055. 

  6056.                         var map = makeModuleMap(id, relMap, true),
    6057. 

  6057.                             mod = getOwn(registry, id);
    6058. 

  6058. 

  6059.                         delete defined[id];
    6060. 

  6060.                         delete urlFetched[map.url];
    6061. 

  6061.                         delete undefEvents[id];
    6062. 

  6062. 

  6063.                         if (mod) {
    6064. 

  6064.                             //Hold on to listeners in case the
    6065. 

  6065.                             //module will be attempted to be reloaded
    6066. 

  6066.                             //using a different config.
    6067. 

  6067.                             if (mod.events.defined) {
    6068. 

  6068.                                 undefEvents[id] = mod.events;
    6069. 

  6069.                             }
    6070. 

  6070. 

  6071.                             cleanRegistry(id);
    6072. 

  6072.                         }
    6073. 

  6073.                     };
    6074. 

  6074.                 }
    6075. 

  6075. 

  6076.                 return localRequire;
    6077. 

  6077.             },
    6078. 

  6078. 

  6079.             /**
    6080. 

  6080.              * Called to enable a module if it is still in the registry
    6081. 

  6081.              * awaiting enablement. A second arg, parent, the parent module,
    6082. 

  6082.              * is passed in for context, when this method is overriden by
    6083. 

  6083.              * the optimizer. Not shown here to keep code compact.
    6084. 

  6084.              */
    6085. 

  6085.             enable: function (depMap) {
    6086. 

  6086.                 var mod = getOwn(registry, depMap.id);
    6087. 

  6087.                 if (mod) {
    6088. 

  6088.                     getModule(depMap).enable();
    6089. 

  6089.                 }
    6090. 

  6090.             },
    6091. 

  6091. 

  6092.             /**
    6093. 

  6093.              * Internal method used by environment adapters to complete a load event.
    6094. 

  6094.              * A load event could be a script load or just a load pass from a synchronous
    6095. 

  6095.              * load call.
    6096. 

  6096.              * @param {String} moduleName the name of the module to potentially complete.
    6097. 

  6097.              */
    6098. 

  6098.             completeLoad: function (moduleName) {
    6099. 

  6099.                 var found, args, mod,
    6100. 

  6100.                     shim = getOwn(config.shim, moduleName) || {},
    6101. 

  6101.                     shExports = shim.exports;
    6102. 

  6102. 

  6103.                 takeGlobalQueue();
    6104. 

  6104. 

  6105.                 while (defQueue.length) {
    6106. 

  6106.                     args = defQueue.shift();
    6107. 

  6107.                     if (args[0] === null) {
    6108. 

  6108.                         args[0] = moduleName;
    6109. 

  6109.                         //If already found an anonymous module and bound it
    6110. 

  6110.                         //to this name, then this is some other anon module
    6111. 

  6111.                         //waiting for its completeLoad to fire.
    6112. 

  6112.                         if (found) {
    6113. 

  6113.                             break;
    6114. 

  6114.                         }
    6115. 

  6115.                         found = true;
    6116. 

  6116.                     } else if (args[0] === moduleName) {
    6117. 

  6117.                         //Found matching define call for this script!
    6118. 

  6118.                         found = true;
    6119. 

  6119.                     }
    6120. 

  6120. 

  6121.                     callGetModule(args);
    6122. 

  6122.                 }
    6123. 

  6123. 

  6124.                 //Do this after the cycle of callGetModule in case the result
    6125. 

  6125.                 //of those calls/init calls changes the registry.
    6126. 

  6126.                 mod = getOwn(registry, moduleName);
    6127. 

  6127. 

  6128.                 if (!found && !hasProp(defined, moduleName) && mod && !mod.inited) {
    6129. 

  6129.                     if (config.enforceDefine && (!shExports || !getGlobal(shExports))) {
    6130. 

  6130.                         if (hasPathFallback(moduleName)) {
    6131. 

  6131.                             return;
    6132. 

  6132.                         } else {
    6133. 

  6133.                             return onError(makeError('nodefine',
    6134. 

  6134.                                              'No define call for ' + moduleName,
    6135. 

  6135.                                              null,
    6136. 

  6136.                                              [moduleName]));
    6137. 

  6137.                         }
    6138. 

  6138.                     } else {
    6139. 

  6139.                         //A script that does not call define(), so just simulate
    6140. 

  6140.                         //the call for it.
    6141. 

  6141.                         callGetModule([moduleName, (shim.deps || []), shim.exportsFn]);
    6142. 

  6142.                     }
    6143. 

  6143.                 }
    6144. 

  6144. 

  6145.                 checkLoaded();
    6146. 

  6146.             },
    6147. 

  6147. 

  6148.             /**
    6149. 

  6149.              * Converts a module name to a file path. Supports cases where
    6150. 

  6150.              * moduleName may actually be just an URL.
    6151. 

  6151.              * Note that it **does not** call normalize on the moduleName,
    6152. 

  6152.              * it is assumed to have already been normalized. This is an
    6153. 

  6153.              * internal API, not a public one. Use toUrl for the public API.
    6154. 

  6154.              */
    6155. 

  6155.             nameToUrl: function (moduleName, ext) {
    6156. 

  6156.                 var paths, pkgs, pkg, pkgPath, syms, i, parentModule, url,
    6157. 

  6157.                     parentPath;
    6158. 

  6158. 

  6159.                 //If a colon is in the URL, it indicates a protocol is used and it is just
    6160. 

  6160.                 //an URL to a file, or if it starts with a slash, contains a query arg (i.e. ?)
    6161. 

  6161.                 //or ends with .js, then assume the user meant to use an url and not a module id.
    6162. 

  6162.                 //The slash is important for protocol-less URLs as well as full paths.
    6163. 

  6163.                 if (req.jsExtRegExp.test(moduleName)) {
    6164. 

  6164.                     //Just a plain path, not module name lookup, so just return it.
    6165. 

  6165.                     //Add extension if it is included. This is a bit wonky, only non-.js things pass
    6166. 

  6166.                     //an extension, this method probably needs to be reworked.
    6167. 

  6167.                     url = moduleName + (ext || '');
    6168. 

  6168.                 } else {
    6169. 

  6169.                     //A module that needs to be converted to a path.
    6170. 

  6170.                     paths = config.paths;
    6171. 

  6171.                     pkgs = config.pkgs;
    6172. 

  6172. 

  6173.                     syms = moduleName.split('/');
    6174. 

  6174.                     //For each module name segment, see if there is a path
    6175. 

  6175.                     //registered for it. Start with most specific name
    6176. 

  6176.                     //and work up from it.
    6177. 

  6177.                     for (i = syms.length; i > 0; i -= 1) {
    6178. 

  6178.                         parentModule = syms.slice(0, i).join('/');
    6179. 

  6179.                         pkg = getOwn(pkgs, parentModule);
    6180. 

  6180.                         parentPath = getOwn(paths, parentModule);
    6181. 

  6181.                         if (parentPath) {
    6182. 

  6182.                             //If an array, it means there are a few choices,
    6183. 

  6183.                             //Choose the one that is desired
    6184. 

  6184.                             if (isArray(parentPath)) {
    6185. 

  6185.                                 parentPath = parentPath[0];
    6186. 

  6186.                             }
    6187. 

  6187.                             syms.splice(0, i, parentPath);
    6188. 

  6188.                             break;
    6189. 

  6189.                         } else if (pkg) {
    6190. 

  6190.                             //If module name is just the package name, then looking
    6191. 

  6191.                             //for the main module.
    6192. 

  6192.                             if (moduleName === pkg.name) {
    6193. 

  6193.                                 pkgPath = pkg.location + '/' + pkg.main;
    6194. 

  6194.                             } else {
    6195. 

  6195.                                 pkgPath = pkg.location;
    6196. 

  6196.                             }
    6197. 

  6197.                             syms.splice(0, i, pkgPath);
    6198. 

  6198.                             break;
    6199. 

  6199.                         }
    6200. 

  6200.                     }
    6201. 

  6201. 

  6202.                     //Join the path parts together, then figure out if baseUrl is needed.
    6203. 

  6203.                     url = syms.join('/');
    6204. 

  6204.                     url += (ext || (/\?/.test(url) ? '' : '.js'));
    6205. 

  6205.                     url = (url.charAt(0) === '/' || url.match(/^[\w\+\.\-]+:/) ? '' : config.baseUrl) + url;
    6206. 

  6206.                 }
    6207. 

  6207. 

  6208.                 return config.urlArgs ? url +
    6209. 

  6209.                                         ((url.indexOf('?') === -1 ? '?' : '&') +
    6210. 

  6210.                                          config.urlArgs) : url;
    6211. 

  6211.             },
    6212. 

  6212. 

  6213.             //Delegates to req.load. Broken out as a separate function to
    6214. 

  6214.             //allow overriding in the optimizer.
    6215. 

  6215.             load: function (id, url) {
    6216. 

  6216.                 req.load(context, id, url);
    6217. 

  6217.             },
    6218. 

  6218. 

  6219.             /**
    6220. 

  6220.              * Executes a module callack function. Broken out as a separate function
    6221. 

  6221.              * solely to allow the build system to sequence the files in the built
    6222. 

  6222.              * layer in the right sequence.
    6223. 

  6223.              *
    6224. 

  6224.              * @private
    6225. 

  6225.              */
    6226. 

  6226.             execCb: function (name, callback, args, exports) {
    6227. 

  6227.                 return callback.apply(exports, args);
    6228. 

  6228.             },
    6229. 

  6229. 

  6230.             /**
    6231. 

  6231.              * callback for script loads, used to check status of loading.
    6232. 

  6232.              *
    6233. 

  6233.              * @param {Event} evt the event from the browser for the script
    6234. 

  6234.              * that was loaded.
    6235. 

  6235.              */
    6236. 

  6236.             onScriptLoad: function (evt) {
    6237. 

  6237.                 //Using currentTarget instead of target for Firefox 2.0's sake. Not
    6238. 

  6238.                 //all old browsers will be supported, but this one was easy enough
    6239. 

  6239.                 //to support and still makes sense.
    6240. 

  6240.                 if (evt.type === 'load' ||
    6241. 

  6241.                         (readyRegExp.test((evt.currentTarget || evt.srcElement).readyState))) {
    6242. 

  6242.                     //Reset interactive script so a script node is not held onto for
    6243. 

  6243.                     //to long.
    6244. 

  6244.                     interactiveScript = null;
    6245. 

  6245. 

  6246.                     //Pull out the name of the module and the context.
    6247. 

  6247.                     var data = getScriptData(evt);
    6248. 

  6248.                     context.completeLoad(data.id);
    6249. 

  6249.                 }
    6250. 

  6250.             },
    6251. 

  6251. 

  6252.             /**
    6253. 

  6253.              * Callback for script errors.
    6254. 

  6254.              */
    6255. 

  6255.             onScriptError: function (evt) {
    6256. 

  6256.                 var data = getScriptData(evt);
    6257. 

  6257.                 if (!hasPathFallback(data.id)) {
    6258. 

  6258.                     return onError(makeError('scripterror', 'Script error', evt, [data.id]));
    6259. 

  6259.                 }
    6260. 

  6260.             }
    6261. 

  6261.         };
    6262. 

  6262. 

  6263.         context.require = context.makeRequire();
    6264. 

  6264.         return context;
    6265. 

  6265.     }
    6266. 

  6266. 

  6267.     /**
    6268. 

  6268.      * Main entry point.
    6269. 

  6269.      *
    6270. 

  6270.      * If the only argument to require is a string, then the module that
    6271. 

  6271.      * is represented by that string is fetched for the appropriate context.
    6272. 

  6272.      *
    6273. 

  6273.      * If the first argument is an array, then it will be treated as an array
    6274. 

  6274.      * of dependency string names to fetch. An optional function callback can
    6275. 

  6275.      * be specified to execute when all of those dependencies are available.
    6276. 

  6276.      *
    6277. 

  6277.      * Make a local req variable to help Caja compliance (it assumes things
    6278. 

  6278.      * on a require that are not standardized), and to give a short
    6279. 

  6279.      * name for minification/local scope use.
    6280. 

  6280.      */
    6281. 

  6281.     req = requirejs = function (deps, callback, errback, optional) {
    6282. 

  6282. 

  6283.         //Find the right context, use default
    6284. 

  6284.         var context, config,
    6285. 

  6285.             contextName = defContextName;
    6286. 

  6286. 

  6287.         // Determine if have config object in the call.
    6288. 

  6288.         if (!isArray(deps) && typeof deps !== 'string') {
    6289. 

  6289.             // deps is a config object
    6290. 

  6290.             config = deps;
    6291. 

  6291.             if (isArray(callback)) {
    6292. 

  6292.                 // Adjust args if there are dependencies
    6293. 

  6293.                 deps = callback;
    6294. 

  6294.                 callback = errback;
    6295. 

  6295.                 errback = optional;
    6296. 

  6296.             } else {
    6297. 

  6297.                 deps = [];
    6298. 

  6298.             }
    6299. 

  6299.         }
    6300. 

  6300. 

  6301.         if (config && config.context) {
    6302. 

  6302.             contextName = config.context;
    6303. 

  6303.         }
    6304. 

  6304. 

  6305.         context = getOwn(contexts, contextName);
    6306. 

  6306.         if (!context) {
    6307. 

  6307.             context = contexts[contextName] = req.s.newContext(contextName);
    6308. 

  6308.         }
    6309. 

  6309. 

  6310.         if (config) {
    6311. 

  6311.             context.configure(config);
    6312. 

  6312.         }
    6313. 

  6313. 

  6314.         return context.require(deps, callback, errback);
    6315. 

  6315.     };
    6316. 

  6316. 

  6317.     /**
    6318. 

  6318.      * Support require.config() to make it easier to cooperate with other
    6319. 

  6319.      * AMD loaders on globally agreed names.
    6320. 

  6320.      */
    6321. 

  6321.     req.config = function (config) {
    6322. 

  6322.         return req(config);
    6323. 

  6323.     };
    6324. 

  6324. 

  6325.     /**
    6326. 

  6326.      * Execute something after the current tick
    6327. 

  6327.      * of the event loop. Override for other envs
    6328. 

  6328.      * that have a better solution than setTimeout.
    6329. 

  6329.      * @param  {Function} fn function to execute later.
    6330. 

  6330.      */
    6331. 

  6331.     req.nextTick = typeof setTimeout !== 'undefined' ? function (fn) {
    6332. 

  6332.         setTimeout(fn, 4);
    6333. 

  6333.     } : function (fn) { fn(); };
    6334. 

  6334. 

  6335.     /**
    6336. 

  6336.      * Export require as a global, but only if it does not already exist.
    6337. 

  6337.      */
    6338. 

  6338.     if (!require) {
    6339. 

  6339.         require = req;
    6340. 

  6340.     }
    6341. 

  6341. 

  6342.     req.version = version;
    6343. 

  6343. 

  6344.     //Used to filter out dependencies that are already paths.
    6345. 

  6345.     req.jsExtRegExp = /^\/|:|\?|\.js$/;
    6346. 

  6346.     req.isBrowser = isBrowser;
    6347. 

  6347.     s = req.s = {
    6348. 

  6348.         contexts: contexts,
    6349. 

  6349.         newContext: newContext
    6350. 

  6350.     };
    6351. 

  6351. 

  6352.     //Create default context.
    6353. 

  6353.     req({});
    6354. 

  6354. 

  6355.     //Exports some context-sensitive methods on global require.
    6356. 

  6356.     each([
    6357. 

  6357.         'toUrl',
    6358. 

  6358.         'undef',
    6359. 

  6359.         'defined',
    6360. 

  6360.         'specified'
    6361. 

  6361.     ], function (prop) {
    6362. 

  6362.         //Reference from contexts instead of early binding to default context,
    6363. 

  6363.         //so that during builds, the latest instance of the default context
    6364. 

  6364.         //with its config gets used.
    6365. 

  6365.         req[prop] = function () {
    6366. 

  6366.             var ctx = contexts[defContextName];
    6367. 

  6367.             return ctx.require[prop].apply(ctx, arguments);
    6368. 

  6368.         };
    6369. 

  6369.     });
    6370. 

  6370. 

  6371.     if (isBrowser) {
    6372. 

  6372.         head = s.head = document.getElementsByTagName('head')[0];
    6373. 

  6373.         //If BASE tag is in play, using appendChild is a problem for IE6.
    6374. 

  6374.         //When that browser dies, this can be removed. Details in this jQuery bug:
    6375. 

  6375.         //http://dev.jquery.com/ticket/2709
    6376. 

  6376.         baseElement = document.getElementsByTagName('base')[0];
    6377. 

  6377.         if (baseElement) {
    6378. 

  6378.             head = s.head = baseElement.parentNode;
    6379. 

  6379.         }
    6380. 

  6380.     }
    6381. 

  6381. 

  6382.     /**
    6383. 

  6383.      * Any errors that require explicitly generates will be passed to this
    6384. 

  6384.      * function. Intercept/override it if you want custom error handling.
    6385. 

  6385.      * @param {Error} err the error object.
    6386. 

  6386.      */
    6387. 

  6387.     req.onError = function (err) {
    6388. 

  6388.         throw err;
    6389. 

  6389.     };
    6390. 

  6390. 

  6391.     /**
    6392. 

  6392.      * Does the request to load a module for the browser case.
    6393. 

  6393.      * Make this a separate function to allow other environments
    6394. 

  6394.      * to override it.
    6395. 

  6395.      *
    6396. 

  6396.      * @param {Object} context the require context to find state.
    6397. 

  6397.      * @param {String} moduleName the name of the module.
    6398. 

  6398.      * @param {Object} url the URL to the module.
    6399. 

  6399.      */
    6400. 

  6400.     req.load = function (context, moduleName, url) {
    6401. 

  6401.         var config = (context && context.config) || {},
    6402. 

  6402.             node;
    6403. 

  6403.         if (isBrowser) {
    6404. 

  6404.             //In the browser so use a script tag
    6405. 

  6405.             node = config.xhtml ?
    6406. 

  6406.                     document.createElementNS('http://www.w3.org/1999/xhtml', 'html:script') :
    6407. 

  6407.                     document.createElement('script');
    6408. 

  6408.             node.type = config.scriptType || 'text/javascript';
    6409. 

  6409.             node.charset = 'utf-8';
    6410. 

  6410.             node.async = true;
    6411. 

  6411. 

  6412.             node.setAttribute('data-requirecontext', context.contextName);
    6413. 

  6413.             node.setAttribute('data-requiremodule', moduleName);
    6414. 

  6414. 

  6415.             //Set up load listener. Test attachEvent first because IE9 has
    6416. 

  6416.             //a subtle issue in its addEventListener and script onload firings
    6417. 

  6417.             //that do not match the behavior of all other browsers with
    6418. 

  6418.             //addEventListener support, which fire the onload event for a
    6419. 

  6419.             //script right after the script execution. See:
    6420. 

  6420.             //https://connect.microsoft.com/IE/feedback/details/648057/script-onload-event-is-not-fired-immediately-after-script-execution
    6421. 

  6421.             //UNFORTUNATELY Opera implements attachEvent but does not follow the script
    6422. 

  6422.             //script execution mode.
    6423. 

  6423.             if (node.attachEvent &&
    6424. 

  6424.                     //Check if node.attachEvent is artificially added by custom script or
    6425. 

  6425.                     //natively supported by browser
    6426. 

  6426.                     //read https://github.com/jrburke/requirejs/issues/187
    6427. 

  6427.                     //if we can NOT find [native code] then it must NOT natively supported.
    6428. 

  6428.                     //in IE8, node.attachEvent does not have toString()
    6429. 

  6429.                     //Note the test for "[native code" with no closing brace, see:
    6430. 

  6430.                     //https://github.com/jrburke/requirejs/issues/273
    6431. 

  6431.                     !(node.attachEvent.toString && node.attachEvent.toString().indexOf('[native code') < 0) &&
    6432. 

  6432.                     !isOpera) {
    6433. 

  6433.                 //Probably IE. IE (at least 6-8) do not fire
    6434. 

  6434.                 //script onload right after executing the script, so
    6435. 

  6435.                 //we cannot tie the anonymous define call to a name.
    6436. 

  6436.                 //However, IE reports the script as being in 'interactive'
    6437. 

  6437.                 //readyState at the time of the define call.
    6438. 

  6438.                 useInteractive = true;
    6439. 

  6439. 

  6440.                 node.attachEvent('onreadystatechange', context.onScriptLoad);
    6441. 

  6441.                 //It would be great to add an error handler here to catch
    6442. 

  6442.                 //404s in IE9+. However, onreadystatechange will fire before
    6443. 

  6443.                 //the error handler, so that does not help. If addEvenListener
    6444. 

  6444.                 //is used, then IE will fire error before load, but we cannot
    6445. 

  6445.                 //use that pathway given the connect.microsoft.com issue
    6446. 

  6446.                 //mentioned above about not doing the 'script execute,
    6447. 

  6447.                 //then fire the script load event listener before execute
    6448. 

  6448.                 //next script' that other browsers do.
    6449. 

  6449.                 //Best hope: IE10 fixes the issues,
    6450. 

  6450.                 //and then destroys all installs of IE 6-9.
    6451. 

  6451.                 //node.attachEvent('onerror', context.onScriptError);
    6452. 

  6452.             } else {
    6453. 

  6453.                 node.addEventListener('load', context.onScriptLoad, false);
    6454. 

  6454.                 node.addEventListener('error', context.onScriptError, false);
    6455. 

  6455.             }
    6456. 

  6456.             node.src = url;
    6457. 

  6457. 

  6458.             //For some cache cases in IE 6-8, the script executes before the end
    6459. 

  6459.             //of the appendChild execution, so to tie an anonymous define
    6460. 

  6460.             //call to the module name (which is stored on the node), hold on
    6461. 

  6461.             //to a reference to this node, but clear after the DOM insertion.
    6462. 

  6462.             currentlyAddingScript = node;
    6463. 

  6463.             if (baseElement) {
    6464. 

  6464.                 head.insertBefore(node, baseElement);
    6465. 

  6465.             } else {
    6466. 

  6466.                 head.appendChild(node);
    6467. 

  6467.             }
    6468. 

  6468.             currentlyAddingScript = null;
    6469. 

  6469. 

  6470.             return node;
    6471. 

  6471.         } else if (isWebWorker) {
    6472. 

  6472.             //In a web worker, use importScripts. This is not a very
    6473. 

  6473.             //efficient use of importScripts, importScripts will block until
    6474. 

  6474.             //its script is downloaded and evaluated. However, if web workers
    6475. 

  6475.             //are in play, the expectation that a build has been done so that
    6476. 

  6476.             //only one script needs to be loaded anyway. This may need to be
    6477. 

  6477.             //reevaluated if other use cases become common.
    6478. 

  6478.             importScripts(url);
    6479. 

  6479. 

  6480.             //Account for anonymous modules
    6481. 

  6481.             context.completeLoad(moduleName);
    6482. 

  6482.         }
    6483. 

  6483.     };
    6484. 

  6484. 

  6485.     function getInteractiveScript() {
    6486. 

  6486.         if (interactiveScript && interactiveScript.readyState === 'interactive') {
    6487. 

  6487.             return interactiveScript;
    6488. 

  6488.         }
    6489. 

  6489. 

  6490.         eachReverse(scripts(), function (script) {
    6491. 

  6491.             if (script.readyState === 'interactive') {
    6492. 

  6492.                 return (interactiveScript = script);
    6493. 

  6493.             }
    6494. 

  6494.         });
    6495. 

  6495.         return interactiveScript;
    6496. 

  6496.     }
    6497. 

  6497. 

  6498.     //Look for a data-main script attribute, which could also adjust the baseUrl.
    6499. 

  6499.     if (isBrowser) {
    6500. 

  6500.         //Figure out baseUrl. Get it from the script tag with require.js in it.
    6501. 

  6501.         eachReverse(scripts(), function (script) {
    6502. 

  6502.             //Set the 'head' where we can append children by
    6503. 

  6503.             //using the script's parent.
    6504. 

  6504.             if (!head) {
    6505. 

  6505.                 head = script.parentNode;
    6506. 

  6506.             }
    6507. 

  6507. 

  6508.             //Look for a data-main attribute to set main script for the page
    6509. 

  6509.             //to load. If it is there, the path to data main becomes the
    6510. 

  6510.             //baseUrl, if it is not already set.
    6511. 

  6511.             dataMain = script.getAttribute('data-main');
    6512. 

  6512.             if (dataMain) {
    6513. 

  6513.                 //Set final baseUrl if there is not already an explicit one.
    6514. 

  6514.                 if (!cfg.baseUrl) {
    6515. 

  6515.                     //Pull off the directory of data-main for use as the
    6516. 

  6516.                     //baseUrl.
    6517. 

  6517.                     src = dataMain.split('/');
    6518. 

  6518.                     mainScript = src.pop();
    6519. 

  6519.                     subPath = src.length ? src.join('/')  + '/' : './';
    6520. 

  6520. 

  6521.                     cfg.baseUrl = subPath;
    6522. 

  6522.                     dataMain = mainScript;
    6523. 

  6523.                 }
    6524. 

  6524. 

  6525.                 //Strip off any trailing .js since dataMain is now
    6526. 

  6526.                 //like a module name.
    6527. 

  6527.                 dataMain = dataMain.replace(jsSuffixRegExp, '');
    6528. 

  6528. 

  6529.                 //Put the data-main script in the files to load.
    6530. 

  6530.                 cfg.deps = cfg.deps ? cfg.deps.concat(dataMain) : [dataMain];
    6531. 

  6531. 

  6532.                 return true;
    6533. 

  6533.             }
    6534. 

  6534.         });
    6535. 

  6535.     }
    6536. 

  6536. 

  6537.     /**
    6538. 

  6538.      * The function that handles definitions of modules. Differs from
    6539. 

  6539.      * require() in that a string for the module should be the first argument,
    6540. 

  6540.      * and the function to execute after dependencies are loaded should
    6541. 

  6541.      * return a value to define the module corresponding to the first argument's
    6542. 

  6542.      * name.
    6543. 

  6543.      */
    6544. 

  6544.     define = function (name, deps, callback) {
    6545. 

  6545.         var node, context;
    6546. 

  6546. 

  6547.         //Allow for anonymous modules
    6548. 

  6548.         if (typeof name !== 'string') {
    6549. 

  6549.             //Adjust args appropriately
    6550. 

  6550.             callback = deps;
    6551. 

  6551.             deps = name;
    6552. 

  6552.             name = null;
    6553. 

  6553.         }
    6554. 

  6554. 

  6555.         //This module may not have dependencies
    6556. 

  6556.         if (!isArray(deps)) {
    6557. 

  6557.             callback = deps;
    6558. 

  6558.             deps = [];
    6559. 

  6559.         }
    6560. 

  6560. 

  6561.         //If no name, and callback is a function, then figure out if it a
    6562. 

  6562.         //CommonJS thing with dependencies.
    6563. 

  6563.         if (!deps.length && isFunction(callback)) {
    6564. 

  6564.             //Remove comments from the callback string,
    6565. 

  6565.             //look for require calls, and pull them into the dependencies,
    6566. 

  6566.             //but only if there are function args.
    6567. 

  6567.             if (callback.length) {
    6568. 

  6568.                 callback
    6569. 

  6569.                     .toString()
    6570. 

  6570.                     .replace(commentRegExp, '')
    6571. 

  6571.                     .replace(cjsRequireRegExp, function (match, dep) {
    6572. 

  6572.                         deps.push(dep);
    6573. 

  6573.                     });
    6574. 

  6574. 

  6575.                 //May be a CommonJS thing even without require calls, but still
    6576. 

  6576.                 //could use exports, and module. Avoid doing exports and module
    6577. 

  6577.                 //work though if it just needs require.
    6578. 

  6578.                 //REQUIRES the function to expect the CommonJS variables in the
    6579. 

  6579.                 //order listed below.
    6580. 

  6580.                 deps = (callback.length === 1 ? ['require'] : ['require', 'exports', 'module']).concat(deps);
    6581. 

  6581.             }
    6582. 

  6582.         }
    6583. 

  6583. 

  6584.         //If in IE 6-8 and hit an anonymous define() call, do the interactive
    6585. 

  6585.         //work.
    6586. 

  6586.         if (useInteractive) {
    6587. 

  6587.             node = currentlyAddingScript || getInteractiveScript();
    6588. 

  6588.             if (node) {
    6589. 

  6589.                 if (!name) {
    6590. 

  6590.                     name = node.getAttribute('data-requiremodule');
    6591. 

  6591.                 }
    6592. 

  6592.                 context = contexts[node.getAttribute('data-requirecontext')];
    6593. 

  6593.             }
    6594. 

  6594.         }
    6595. 

  6595. 

  6596.         //Always save off evaluating the def call until the script onload handler.
    6597. 

  6597.         //This allows multiple modules to be in a file without prematurely
    6598. 

  6598.         //tracing dependencies, and allows for anonymous module support,
    6599. 

  6599.         //where the module name is not known until the script onload event
    6600. 

  6600.         //occurs. If no context, use the global queue, and get it processed
    6601. 

  6601.         //in the onscript load callback.
    6602. 

  6602.         (context ? context.defQueue : globalDefQueue).push([name, deps, callback]);
    6603. 

  6603.     };
    6604. 

  6604. 

  6605.     define.amd = {
    6606. 

  6606.         jQuery: true
    6607. 

  6607.     };
    6608. 

  6608. 

  6609. 

  6610.     /**
    6611. 

  6611.      * Executes the text. Normally just uses eval, but can be modified
    6612. 

  6612.      * to use a better, environment-specific call. Only used for transpiling
    6613. 

  6613.      * loader plugins, not for plain JS modules.
    6614. 

  6614.      * @param {String} text the text to execute/evaluate.
    6615. 

  6615.      */
    6616. 

  6616.     req.exec = function (text) {
    6617. 

  6617.         /*jslint evil: true */
    6618. 

  6618.         return eval(text);
    6619. 

  6619.     };
    6620. 

  6620. 

  6621.     //Set up with config info.
    6622. 

  6622.     req(cfg);
    6623. 

  6623. }(this));
    6624. 

  6624. 

  6625. context.require=require; context.define=define; context.requirejs=requirejs; };
    6626. 

  6626. 

  6627. blanket.defaultReporter = function(coverage){
    6628. 

  6628.     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;}",
    6629. 

  6629.         successRate = 60,
    6630. 

  6630.         head = document.head,
    6631. 

  6631.         fileNumber = 0,
    6632. 

  6632.         body = document.body,
    6633. 

  6633.         headerContent,
    6634. 

  6634.         hasBranchTracking = Object.keys(coverage.files).some(function(elem){
    6635. 

  6635.           return typeof coverage.files[elem].branchData !== 'undefined';
    6636. 

  6636.         }),
    6637. 

  6637.         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>",
    6638. 

  6638.         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>";
    6639. 

  6639.         grandTotalTemplate = "<div class='blanket grand-total {{statusclass}}'><div class='bl-cl'>Totals</div><div class='bl-cl rs'>{{percentage}} %</div>"+( hasBranchTracking ? "<div class='bl-cl rs'>{{passedBranches}}/{{totalBranches}}</div>" : "" )+"<div class='bl-cl rs'>{{numberCovered}}/{{totalSmts}}</div><div style='clear:both;'></div></div>";
    6640. 

  6640. 

  6641.     function blanket_toggleSource(id) {
    6642. 

  6642.         var element = document.getElementById(id);
    6643. 

  6643.         if(element.style.display === 'block') {
    6644. 

  6644.             element.style.display = 'none';
    6645. 

  6645.         } else {
    6646. 

  6646.             element.style.display = 'block';
    6647. 

  6647.         }
    6648. 

  6648.     }
    6649. 

  6649. 

  6650. 

  6651.     var script = document.createElement("script");
    6652. 

  6652.     script.type = "text/javascript";
    6653. 

  6653.     script.text = blanket_toggleSource.toString().replace('function ' + blanket_toggleSource.name, 'function blanket_toggleSource');
    6654. 

  6654.     body.appendChild(script);
    6655. 

  6655. 

  6656.     var percentage = function(number, total) {
    6657. 

  6657.         return (Math.round(((number/total) * 100)*100)/100);
    6658. 

  6658.     };
    6659. 

  6659. 

  6660.     var appendTag = function (type, el, str) {
    6661. 

  6661.         var dom = document.createElement(type);
    6662. 

  6662.         dom.innerHTML = str;
    6663. 

  6663.         el.appendChild(dom);
    6664. 

  6664.     };
    6665. 

  6665. 

  6666.     function escapeInvalidXmlChars(str) {
    6667. 

  6667.         return str.replace(/\&/g, "&amp;")
    6668. 

  6668.             .replace(/</g, "&lt;")
    6669. 

  6669.             .replace(/\>/g, "&gt;")
    6670. 

  6670.             .replace(/\"/g, "&quot;")
    6671. 

  6671.             .replace(/\'/g, "&apos;");
    6672. 

  6672.     }
    6673. 

  6673. 

  6674.     function isBranchFollowed(data,bool){
    6675. 

  6675.         var mode = bool ? 0 : 1;
    6676. 

  6676.         if (typeof data === 'undefined' ||
    6677. 

  6677.             typeof data === null ||
    6678. 

  6678.             typeof data[mode] === 'undefined'){
    6679. 

  6679.             return false;
    6680. 

  6680.         }
    6681. 

  6681.         return data[mode].length > 0;
    6682. 

  6682.     }
    6683. 

  6683. 

  6684.     var branchStack = [];
    6685. 

  6685. 

  6686.     function branchReport(colsIndex,src,cols,offset,lineNum){
    6687. 

  6687.       var newsrc="";
    6688. 

  6688.        var postfix="";
    6689. 

  6689.       if (branchStack.length > 0){
    6690. 

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

  6691.         if (branchStack[0][0].end.line === lineNum){
    6692. 

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

  6693.           src = src.slice(branchStack[0][0].end.column);
    6694. 

  6694.           branchStack.shift();
    6695. 

  6695.           if (branchStack.length > 0){
    6696. 

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

  6697.             if (branchStack[0][0].end.line === lineNum){
    6698. 

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

  6699.               src = src.slice(branchStack[0][0].end.column);
    6700. 

  6700.               branchStack.shift();
    6701. 

  6701.               if (!cols){
    6702. 

  6702.                 return {src: newsrc + escapeInvalidXmlChars(src) ,cols:cols};
    6703. 

  6703.               }
    6704. 

  6704.             }
    6705. 

  6705.             else if (!cols){
    6706. 

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

  6707.             }
    6708. 

  6708.             else{
    6709. 

  6709.               postfix = "</span>";
    6710. 

  6710.             }
    6711. 

  6711.           }else if (!cols){
    6712. 

  6712.             return {src: newsrc + escapeInvalidXmlChars(src) ,cols:cols};
    6713. 

  6713.           }
    6714. 

  6714.         }else if(!cols){
    6715. 

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

  6716.         }else{
    6717. 

  6717.           postfix = "</span>";
    6718. 

  6718.         }
    6719. 

  6719.       }
    6720. 

  6720.       var thisline = cols[colsIndex];
    6721. 

  6721.       //consequent
    6722. 

  6722.       
    6723. 

  6723.       var cons = thisline.consequent;
    6724. 

  6724.       if (cons.start.line > lineNum){
    6725. 

  6725.         branchStack.unshift([thisline.alternate,thisline]);
    6726. 

  6726.         branchStack.unshift([cons,thisline]);
    6727. 

  6727.         src = escapeInvalidXmlChars(src);
    6728. 

  6728.       }else{
    6729. 

  6729.         var style = "<span class='" + (isBranchFollowed(thisline,true) ? 'branchOkay' : 'branchWarning') + "'>";
    6730. 

  6730.         newsrc += escapeInvalidXmlChars(src.slice(0,cons.start.column-offset)) + style;
    6731. 

  6731.         
    6732. 

  6732.         if (cols.length > colsIndex+1 &&
    6733. 

  6733.           cols[colsIndex+1].consequent.start.line === lineNum &&
    6734. 

  6734.           cols[colsIndex+1].consequent.start.column-offset < cols[colsIndex].consequent.end.column-offset)
    6735. 

  6735.         {
    6736. 

  6736.           var res = branchReport(colsIndex+1,src.slice(cons.start.column-offset,cons.end.column-offset),cols,cons.start.column-offset,lineNum);
    6737. 

  6737.           newsrc += res.src;
    6738. 

  6738.           cols = res.cols;
    6739. 

  6739.           cols[colsIndex+1] = cols[colsIndex+2];
    6740. 

  6740.           cols.length--;
    6741. 

  6741.         }else{
    6742. 

  6742.           newsrc += escapeInvalidXmlChars(src.slice(cons.start.column-offset,cons.end.column-offset));
    6743. 

  6743.         }
    6744. 

  6744.         newsrc += "</span>";
    6745. 

  6745. 

  6746.         var alt = thisline.alternate;
    6747. 

  6747.         if (alt.start.line > lineNum){
    6748. 

  6748.           newsrc += escapeInvalidXmlChars(src.slice(cons.end.column-offset));
    6749. 

  6749.           branchStack.unshift([alt,thisline]);
    6750. 

  6750.         }else{
    6751. 

  6751.           newsrc += escapeInvalidXmlChars(src.slice(cons.end.column-offset,alt.start.column-offset));
    6752. 

  6752.           style = "<span class='" + (isBranchFollowed(thisline,false) ? 'branchOkay' : 'branchWarning') + "'>";
    6753. 

  6753.           newsrc +=  style;
    6754. 

  6754.           if (cols.length > colsIndex+1 &&
    6755. 

  6755.             cols[colsIndex+1].consequent.start.line === lineNum &&
    6756. 

  6756.             cols[colsIndex+1].consequent.start.column-offset < cols[colsIndex].alternate.end.column-offset)
    6757. 

  6757.           {
    6758. 

  6758.             var res2 = branchReport(colsIndex+1,src.slice(alt.start.column-offset,alt.end.column-offset),cols,alt.start.column-offset,lineNum);
    6759. 

  6759.             newsrc += res2.src;
    6760. 

  6760.             cols = res2.cols;
    6761. 

  6761.             cols[colsIndex+1] = cols[colsIndex+2];
    6762. 

  6762.             cols.length--;
    6763. 

  6763.           }else{
    6764. 

  6764.             newsrc += escapeInvalidXmlChars(src.slice(alt.start.column-offset,alt.end.column-offset));
    6765. 

  6765.           }
    6766. 

  6766.           newsrc += "</span>";
    6767. 

  6767.           newsrc += escapeInvalidXmlChars(src.slice(alt.end.column-offset));
    6768. 

  6768.           src = newsrc;
    6769. 

  6769.         }
    6770. 

  6770.       }
    6771. 

  6771.       return {src:src+postfix, cols:cols};
    6772. 

  6772.     }
    6773. 

  6773. 

  6774.     var isUndefined =  function(item){
    6775. 

  6775.             return typeof item !== 'undefined';
    6776. 

  6776.       };
    6777. 

  6777. 

  6778.     var files = coverage.files;
    6779. 

  6779.     var totals = {
    6780. 

  6780.       totalSmts: 0,
    6781. 

  6781.       numberOfFilesCovered: 0
    6782. 

  6782.     };
    6783. 

  6783.     for(var file in files)
    6784. 

  6784.     {
    6785. 

  6785.         fileNumber++;
    6786. 

  6786. 

  6787.         var statsForFile = files[file],
    6788. 

  6788.             totalSmts = 0,
    6789. 

  6789.             numberOfFilesCovered = 0,
    6790. 

  6790.             code = [],
    6791. 

  6791.             i;
    6792. 

  6792.         
    6793. 

  6793. 

  6794.         var end = [];
    6795. 

  6795.         for(i = 0; i < statsForFile.source.length; i +=1){
    6796. 

  6796.             var src = statsForFile.source[i];
    6797. 

  6797.             
    6798. 

  6798.             if (branchStack.length > 0 ||
    6799. 

  6799.                 typeof statsForFile.branchData !== 'undefined')
    6800. 

  6800.             {
    6801. 

  6801.                 if (typeof statsForFile.branchData[i+1] !== 'undefined')
    6802. 

  6802.                 {
    6803. 

  6803.                   var cols = statsForFile.branchData[i+1].filter(isUndefined);
    6804. 

  6804.                   var colsIndex=0;
    6805. 

  6805.                   
    6806. 

  6806.                     
    6807. 

  6807.                   src = branchReport(colsIndex,src,cols,0,i+1).src;
    6808. 

  6808.                   
    6809. 

  6809.                 }else if (branchStack.length){
    6810. 

  6810.                   src = branchReport(0,src,null,0,i+1).src;
    6811. 

  6811.                 }else{
    6812. 

  6812.                   src = escapeInvalidXmlChars(src);
    6813. 

  6813.                 }
    6814. 

  6814.               }else{
    6815. 

  6815.                 src = escapeInvalidXmlChars(src);
    6816. 

  6816.               }
    6817. 

  6817.               var lineClass="";
    6818. 

  6818.               if(statsForFile[i+1]) {
    6819. 

  6819.                 numberOfFilesCovered += 1;
    6820. 

  6820.                 totalSmts += 1;
    6821. 

  6821.                 lineClass = 'hit';
    6822. 

  6822.               }else{
    6823. 

  6823.                 if(statsForFile[i+1] === 0){
    6824. 

  6824.                     totalSmts++;
    6825. 

  6825.                     lineClass = 'miss';
    6826. 

  6826.                 }
    6827. 

  6827.               }
    6828. 

  6828.               code[i + 1] = "<div class='"+lineClass+"'><span class=''>"+(i + 1)+"</span>"+src+"</div>";
    6829. 

  6829.               totals.totalSmts += totalSmts;
    6830. 

  6830.               totals.numberOfFilesCovered += numberOfFilesCovered;
    6831. 

  6831.         }
    6832. 

  6832.         var totalBranches=0;
    6833. 

  6833.         var passedBranches=0;
    6834. 

  6834.         if (typeof statsForFile.branchData !== 'undefined'){
    6835. 

  6835.           for(var j=0;j<statsForFile.branchData.length;j++){
    6836. 

  6836.             if (typeof statsForFile.branchData[j] !== 'undefined'){
    6837. 

  6837.               for(var k=0;k<statsForFile.branchData[j].length;k++){
    6838. 

  6838.                 if (typeof statsForFile.branchData[j][k] !== 'undefined'){
    6839. 

  6839.                   totalBranches++;
    6840. 

  6840.                   if (typeof statsForFile.branchData[j][k][0] !== 'undefined' &&
    6841. 

  6841.                     statsForFile.branchData[j][k][0].length > 0 &&
    6842. 

  6842.                     typeof statsForFile.branchData[j][k][1] !== 'undefined' &&
    6843. 

  6843.                     statsForFile.branchData[j][k][1].length > 0){
    6844. 

  6844.                     passedBranches++;
    6845. 

  6845.                   }
    6846. 

  6846.                 }
    6847. 

  6847.               }
    6848. 

  6848.             }
    6849. 

  6849.           }
    6850. 

  6850.         }
    6851. 

  6851.         var result = percentage(numberOfFilesCovered, totalSmts);
    6852. 

  6852. 

  6853.         var output = fileTemplate.replace("{{file}}", file)
    6854. 

  6854.                                  .replace("{{percentage}}",result)
    6855. 

  6855.                                  .replace("{{numberCovered}}", numberOfFilesCovered)
    6856. 

  6856.                                  .replace(/\{\{fileNumber\}\}/g, fileNumber)
    6857. 

  6857.                                  .replace("{{totalSmts}}", totalSmts)
    6858. 

  6858.                                  .replace("{{totalBranches}}", totalBranches)
    6859. 

  6859.                                  .replace("{{passedBranches}}", passedBranches)
    6860. 

  6860.                                  .replace("{{source}}", code.join(" "));
    6861. 

  6861.         if(result < successRate)
    6862. 

  6862.         {
    6863. 

  6863.             output = output.replace("{{statusclass}}", "bl-error");
    6864. 

  6864.         } else {
    6865. 

  6865.             output = output.replace("{{statusclass}}", "bl-success");
    6866. 

  6866.         }
    6867. 

  6867.         bodyContent += output;
    6868. 

  6868.     }
    6869. 

  6869. 

  6870.     var totalPercent = percentage(totals.numberOfFilesCovered, totals.totalSmts);
    6871. 

  6871.     var statusClass = totalPercent < successRate ? "bl-error" : "bl-success";
    6872. 

  6872.     var totalsOutput = grandTotalTemplate.replace("{{percentage}}", totalPercent)
    6873. 

  6873.                                .replace("{{numberCovered}}", totals.numberOfFilesCovered)
    6874. 

  6874.                                .replace("{{totalSmts}}", totals.totalSmts)
    6875. 

  6875.                                .replace("{{statusclass}}", statusClass);
    6876. 

  6876. 

  6877.     bodyContent += totalsOutput;
    6878. 

  6878.     bodyContent += "</div>"; //closing main
    6879. 

  6879. 

  6880. 

  6881.     appendTag('style', head, cssSytle);
    6882. 

  6882.     //appendStyle(body, headerContent);
    6883. 

  6883.     if (document.getElementById("blanket-main")){
    6884. 

  6884.         document.getElementById("blanket-main").innerHTML=
    6885. 

  6885.             bodyContent.slice(23,-6);
    6886. 

  6886.     }else{
    6887. 

  6887.         appendTag('div', body, bodyContent);
    6888. 

  6888.     }
    6889. 

  6889.     //appendHtml(body, '</div>');
    6890. 

  6890. };
    6891. 

  6891. 

  6892. (function(){
    6893. 

  6893.     var newOptions={};
    6894. 

  6894.     //http://stackoverflow.com/a/2954896
    6895. 

  6895.     var toArray =Array.prototype.slice;
    6896. 

  6896.     var scripts = toArray.call(document.scripts);
    6897. 

  6897.     toArray.call(scripts[scripts.length - 1].attributes)
    6898. 

  6898.                     .forEach(function(es){
    6899. 

  6899.                         if(es.nodeName === "data-cover-only"){
    6900. 

  6900.                             newOptions.filter = es.nodeValue;
    6901. 

  6901.                         }
    6902. 

  6902.                         if(es.nodeName === "data-cover-never"){
    6903. 

  6903.                             newOptions.antifilter = es.nodeValue;
    6904. 

  6904.                         }
    6905. 

  6905.                         if(es.nodeName === "data-cover-reporter"){
    6906. 

  6906.                             newOptions.reporter = es.nodeValue;
    6907. 

  6907.                         }
    6908. 

  6908.                         if (es.nodeName === "data-cover-adapter"){
    6909. 

  6909.                             newOptions.adapter = es.nodeValue;
    6910. 

  6910.                         }
    6911. 

  6911.                         if (es.nodeName === "data-cover-loader"){
    6912. 

  6912.                             newOptions.loader = es.nodeValue;
    6913. 

  6913.                         }
    6914. 

  6914.                         if (es.nodeName === "data-cover-timeout"){
    6915. 

  6915.                             newOptions.timeout = es.nodeValue;
    6916. 

  6916.                         }
    6917. 

  6917.                         if (es.nodeName === "data-cover-reporter-options"){
    6918. 

  6918.                             try{
    6919. 

  6919.                                 newOptions.reporter_options = JSON.parse(es.nodeValue);
    6920. 

  6920.                             }catch(e){
    6921. 

  6921.                                 if (blanket.options("debug")){
    6922. 

  6922.                                     throw new Error("Invalid reporter options.  Must be a valid stringified JSON object.");
    6923. 

  6923.                                 }
    6924. 

  6924.                             }
    6925. 

  6925.                         }
    6926. 

  6926.                         if (es.nodeName === "data-cover-testReadyCallback"){
    6927. 

  6927.                             newOptions.testReadyCallback = es.nodeValue;
    6928. 

  6928.                         }
    6929. 

  6929.                         if (es.nodeName === "data-cover-customVariable"){
    6930. 

  6930.                             newOptions.customVariable = es.nodeValue;
    6931. 

  6931.                         }
    6932. 

  6932.                         if (es.nodeName === "data-cover-flags"){
    6933. 

  6933.                             var flags = " "+es.nodeValue+" ";
    6934. 

  6934.                             if (flags.indexOf(" unordered ") > -1){
    6935. 

  6935.                                 newOptions.order = false;
    6936. 

  6936.                             }
    6937. 

  6937.                             if (flags.indexOf(" ignoreError ") > -1){
    6938. 

  6938.                                 newOptions.ignoreScriptError = true;
    6939. 

  6939.                             }
    6940. 

  6940.                             if (flags.indexOf(" autoStart ") > -1){
    6941. 

  6941.                                 newOptions.autoStart = true;
    6942. 

  6942.                             }
    6943. 

  6943.                             if (flags.indexOf(" ignoreCors ") > -1){
    6944. 

  6944.                                 newOptions.ignoreCors = true;
    6945. 

  6945.                             }
    6946. 

  6946.                             if (flags.indexOf(" branchTracking ") > -1){
    6947. 

  6947.                                 newOptions.branchTracking = true;
    6948. 

  6948.                             }
    6949. 

  6949.                             if (flags.indexOf(" sourceURL ") > -1){
    6950. 

  6950.                                 newOptions.sourceURL = true;
    6951. 

  6951.                             }
    6952. 

  6952.                             if (flags.indexOf(" debug ") > -1){
    6953. 

  6953.                                 newOptions.debug = true;
    6954. 

  6954.                             }
    6955. 

  6955.                             if (flags.indexOf(" engineOnly ") > -1){
    6956. 

  6956.                                 newOptions.engineOnly = true;
    6957. 

  6957.                             }
    6958. 

  6958.                             if (flags.indexOf(" commonJS ") > -1){
    6959. 

  6959.                                 newOptions.commonJS = true;
    6960. 

  6960.                             }
    6961. 

  6961.                              if (flags.indexOf(" instrumentCache ") > -1){
    6962. 

  6962.                                 newOptions.instrumentCache = true;
    6963. 

  6963.                             }
    6964. 

  6964.                         }
    6965. 

  6965.                     });
    6966. 

  6966.     blanket.options(newOptions);
    6967. 

  6967. 

  6968.     if (typeof requirejs !== 'undefined'){
    6969. 

  6969.         blanket.options("existingRequireJS",true);
    6970. 

  6970.     }
    6971. 

  6971.     /* setup requirejs loader, if needed */
    6972. 

  6972.     if (!blanket.options("existingRequireJS") ){
    6973. 

  6973.         if (typeof window["define"] !== "undefined"){
    6974. 

  6974.             window["__blanket_old_define"]=window["define"];
    6975. 

  6975.             window["define"]=void 0;
    6976. 

  6976.         }
    6977. 

  6977.         if (blanket.options("commonJS")){
    6978. 

  6978.             blanket._commonjs = {};
    6979. 

  6979.             blanket.setupRequireJS(blanket._commonjs);
    6980. 

  6980.         }else{
    6981. 

  6981.             blanket.setupRequireJS(window);
    6982. 

  6982.         }
    6983. 

  6983.         if (typeof window["__blanket_old_define"] !== "undefined"){
    6984. 

  6984.             window["define"] = window["__blanket_old_define"];
    6985. 

  6985.         }
    6986. 

  6986.     }
    6987. 

  6987. })();
    6988. 

  6988. (function(_blanket){
    6989. 

  6989. _blanket.extend({
    6990. 

  6990.     utils: {
    6991. 

  6991.     normalizeBackslashes: function(str) {
    6992. 

  6992.         return str.replace(/\\/g, '/');
    6993. 

  6993.     },
    6994. 

  6994.     matchPatternAttribute: function(filename,pattern){
    6995. 

  6995.         if (typeof pattern === 'string'){
    6996. 

  6996.             if (pattern.indexOf("[") === 0){
    6997. 

  6997.                 //treat as array
    6998. 

  6998.                 var pattenArr = pattern.slice(1,pattern.length-1).split(",");
    6999. 

  6999.                 return pattenArr.some(function(elem){
    7000. 

  7000.                     return _blanket.utils.matchPatternAttribute(filename,_blanket.utils.normalizeBackslashes(elem.slice(1,-1)));
    7001. 

  7001.                     //return filename.indexOf(_blanket.utils.normalizeBackslashes(elem.slice(1,-1))) > -1;
    7002. 

  7002.                 });
    7003. 

  7003.             }else if ( pattern.indexOf("//") === 0){
    7004. 

  7004.                 var ex = pattern.slice(2,pattern.lastIndexOf('/'));
    7005. 

  7005.                 var mods = pattern.slice(pattern.lastIndexOf('/')+1);
    7006. 

  7006.                 var regex = new RegExp(ex,mods);
    7007. 

  7007.                 return regex.test(filename);
    7008. 

  7008.             }else if (pattern.indexOf("#") === 0){
    7009. 

  7009.                 return window[pattern.slice(1)].call(window,filename);
    7010. 

  7010.             }else{
    7011. 

  7011.                 return filename.indexOf(_blanket.utils.normalizeBackslashes(pattern)) > -1;
    7012. 

  7012.             }
    7013. 

  7013.         }else if ( pattern instanceof Array ){
    7014. 

  7014.             return pattern.some(function(elem){
    7015. 

  7015.                 return _blanket.utils.matchPatternAttribute(filename,elem);
    7016. 

  7016.             });
    7017. 

  7017.         }else if (pattern instanceof RegExp){
    7018. 

  7018.             return pattern.test(filename);
    7019. 

  7019.         }else if (typeof pattern === "function"){
    7020. 

  7020.             return pattern.call(window,filename);
    7021. 

  7021.         }
    7022. 

  7022.     },
    7023. 

  7023.     blanketEval: function(data){
    7024. 

  7024.         return ( window.execScript || function( data ) {
    7025. 

  7025.             //borrowed from jquery
    7026. 

  7026.             window[ "eval" ].call( window, data );
    7027. 

  7027.         } )( data );
    7028. 

  7028.     },
    7029. 

  7029.     collectPageScripts: function(){
    7030. 

  7030.         console.log("cps1:"+new Date().getTime());
    7031. 

  7031.         var toArray = Array.prototype.slice;
    7032. 

  7032.         var scripts = toArray.call(document.scripts);
    7033. 

  7033.         var selectedScripts=[],scriptNames=[];
    7034. 

  7034.         var filter = _blanket.options("filter");
    7035. 

  7035.         if(filter != null){
    7036. 

  7036.             //global filter in place, data-cover-only
    7037. 

  7037.             var antimatch = _blanket.options("antifilter");
    7038. 

  7038.             selectedScripts = toArray.call(document.scripts)
    7039. 

  7039.                             .filter(function(s){
    7040. 

  7040.                                 return toArray.call(s.attributes).filter(function(sn){
    7041. 

  7041.                                     return sn.nodeName === "src" && _blanket.utils.matchPatternAttribute(sn.nodeValue,filter) &&
    7042. 

  7042.                                         (typeof antimatch === "undefined" || !_blanket.utils.matchPatternAttribute(sn.nodeValue,antimatch));
    7043. 

  7043.                                 }).length === 1;
    7044. 

  7044.                             });
    7045. 

  7045.         }else{
    7046. 

  7046.             selectedScripts = toArray.call(document.querySelectorAll("script[data-cover]"));
    7047. 

  7047.         }
    7048. 

  7048.         scriptNames = selectedScripts.map(function(s){
    7049. 

  7049.                                 return _blanket.utils.qualifyURL(
    7050. 

  7050.                                     toArray.call(s.attributes).filter(
    7051. 

  7051.                                         function(sn){
    7052. 

  7052.                                             return sn.nodeName === "src";
    7053. 

  7053.                                         })[0].nodeValue).replace(".js","");
    7054. 

  7054.                                 });
    7055. 

  7055.         if (!filter){
    7056. 

  7056.             _blanket.options("filter","['"+scriptNames.join("','")+"']");
    7057. 

  7057.         }
    7058. 

  7058.         return scriptNames;
    7059. 

  7059.     }
    7060. 

  7060. }
    7061. 

  7061. });
    7062. 

  7062. (function(){
    7063. 

  7063.     var require = blanket.options("commonJS") ? blanket._commonjs.require : window.require;
    7064. 

  7064.     var requirejs = blanket.options("commonJS") ? blanket._commonjs.requirejs : window.requirejs;
    7065. 

  7065.     if (!_blanket.options("engineOnly")){
    7066. 

  7066. 

  7067.         _blanket.utils.oldloader = requirejs.load;
    7068. 

  7068.         console.log("cps2:"+new Date().getTime());
    7069. 

  7069. 

  7070.         requirejs.load = function (context, moduleName, url) {
    7071. 

  7071.             _blanket.requiringFile(url);
    7072. 

  7072.             requirejs.cget(url, function (content) {
    7073. 

  7073. 

  7074.                 var match = _blanket.options("filter");
    7075. 

  7075.                 //we check the never matches first
    7076. 

  7076.                 var antimatch = _blanket.options("antifilter");
    7077. 

  7077.                 if (typeof antimatch !== "undefined" &&
    7078. 

  7078.                         _blanket.utils.matchPatternAttribute(url.replace(".js",""),antimatch)
    7079. 

  7079.                     ){
    7080. 

  7080.                     _blanket.utils.oldloader(context, moduleName, url);
    7081. 

  7081.                     if (_blanket.options("debug")) {console.log("BLANKET-File will never be instrumented:"+url);}
    7082. 

  7082.                     _blanket.requiringFile(url,true);
    7083. 

  7083.                 }else if (_blanket.utils.matchPatternAttribute(url.replace(".js",""),match)){
    7084. 

  7084.                     if (_blanket.options("debug")) {console.log("BLANKET-Attempting instrument of:"+url);}
    7085. 

  7085.                     _blanket.instrument({
    7086. 

  7086.                         inputFile: content,
    7087. 

  7087.                         inputFileName: url
    7088. 

  7088.                     },function(instrumented){
    7089. 

  7089.                         try{
    7090. 

  7090.                             _blanket.utils.blanketEval(instrumented);
    7091. 

  7091.                             context.completeLoad(moduleName);
    7092. 

  7092.                             _blanket.requiringFile(url,true);
    7093. 

  7093.                         }
    7094. 

  7094.                         catch(err){
    7095. 

  7095.                             if (_blanket.options("ignoreScriptError")){
    7096. 

  7096.                                 //we can continue like normal if
    7097. 

  7097.                                 //we're ignoring script errors,
    7098. 

  7098.                                 //but otherwise we don't want
    7099. 

  7099.                                 //to completeLoad or the error might be
    7100. 

  7100.                                 //missed.
    7101. 

  7101.                                 if (_blanket.options("debug")) { console.log("BLANKET-There was an error loading the file:"+url); }
    7102. 

  7102.                                 context.completeLoad(moduleName);
    7103. 

  7103.                                 _blanket.requiringFile(url,true);
    7104. 

  7104.                             }else{
    7105. 

  7105.                                 throw new Error("Error parsing instrumented code: "+err);
    7106. 

  7106.                             }
    7107. 

  7107.                         }
    7108. 

  7108.                     });
    7109. 

  7109.                 }else{
    7110. 

  7110.                     if (_blanket.options("debug")) { console.log("BLANKET-Loading (without instrumenting) the file:"+url);}
    7111. 

  7111.                     _blanket.utils.oldloader(context, moduleName, url);
    7112. 

  7112.                     _blanket.requiringFile(url,true);
    7113. 

  7113.                 }
    7114. 

  7114. 

  7115.             }, function (err) {
    7116. 

  7116.                 _blanket.requiringFile();
    7117. 

  7117.                 throw err;
    7118. 

  7118.             });
    7119. 

  7119.         };
    7120. 

  7120. 

  7121. 

  7122.         requirejs.createXhr = function () {
    7123. 

  7123.             //Would love to dump the ActiveX crap in here. Need IE 6 to die first.
    7124. 

  7124.             var xhr, i, progId;
    7125. 

  7125.             if (typeof XMLHttpRequest !== "undefined") {
    7126. 

  7126.                 return new XMLHttpRequest();
    7127. 

  7127.             } else if (typeof ActiveXObject !== "undefined") {
    7128. 

  7128.                 for (i = 0; i < 3; i += 1) {
    7129. 

  7129.                     progId = progIds[i];
    7130. 

  7130.                     try {
    7131. 

  7131.                         xhr = new ActiveXObject(progId);
    7132. 

  7132.                     } catch (e) {}
    7133. 

  7133. 

  7134.                     if (xhr) {
    7135. 

  7135.                         progIds = [progId];  // so faster next time
    7136. 

  7136.                         break;
    7137. 

  7137.                     }
    7138. 

  7138.                 }
    7139. 

  7139.             }
    7140. 

  7140. 

  7141.             return xhr;
    7142. 

  7142.         };
    7143. 

  7143. 

  7144. 

  7145.         requirejs.cget = function (url, callback, errback, onXhr) {
    7146. 

  7146.             var foundInSession = false;
    7147. 

  7147.             if (_blanket.blanketSession){
    7148. 

  7148.                 var files = Object.keys(_blanket.blanketSession);
    7149. 

  7149.                 for (var i=0; i<files.length;i++ ){
    7150. 

  7150.                     var key = files[i];
    7151. 

  7151.                     if (url.indexOf(key) > -1){
    7152. 

  7152.                         callback(_blanket.blanketSession[key]);
    7153. 

  7153.                         foundInSession=true;
    7154. 

  7154.                         return;
    7155. 

  7155.                     }
    7156. 

  7156.                 }
    7157. 

  7157.             }
    7158. 

  7158.             if (!foundInSession){
    7159. 

  7159.                 var xhr = requirejs.createXhr();
    7160. 

  7160.                 xhr.open('GET', url, true);
    7161. 

  7161. 

  7162.                 //Allow overrides specified in config
    7163. 

  7163.                 if (onXhr) {
    7164. 

  7164.                     onXhr(xhr, url);
    7165. 

  7165.                 }
    7166. 

  7166. 

  7167.                 xhr.onreadystatechange = function (evt) {
    7168. 

  7168.                     var status, err;
    7169. 

  7169.                     
    7170. 

  7170.                     //Do not explicitly handle errors, those should be
    7171. 

  7171.                     //visible via console output in the browser.
    7172. 

  7172.                     if (xhr.readyState === 4) {
    7173. 

  7173.                         status = xhr.status;
    7174. 

  7174.                         if ((status > 399 && status < 600) /*||
    7175. 

  7175.                             (status === 0 &&
    7176. 

  7176.                                 navigator.userAgent.toLowerCase().indexOf('firefox') > -1)
    7177. 

  7177.                            */ ) {
    7178. 

  7178.                             //An http 4xx or 5xx error. Signal an error.
    7179. 

  7179.                             err = new Error(url + ' HTTP status: ' + status);
    7180. 

  7180.                             err.xhr = xhr;
    7181. 

  7181.                             errback(err);
    7182. 

  7182.                         } else {
    7183. 

  7183.                             callback(xhr.responseText);
    7184. 

  7184.                         }
    7185. 

  7185.                     }
    7186. 

  7186.                 };
    7187. 

  7187.                 try{
    7188. 

  7188.                     xhr.send(null);
    7189. 

  7189.                 }catch(e){
    7190. 

  7190.                     if (e.code && (e.code === 101 || e.code === 1012) && _blanket.options("ignoreCors") === false){
    7191. 

  7191.                         //running locally and getting error from browser
    7192. 

  7192.                         _blanket.showManualLoader();
    7193. 

  7193.                     } else {
    7194. 

  7194.                         throw e;
    7195. 

  7195.                     }
    7196. 

  7196.                 }
    7197. 

  7197.             }
    7198. 

  7198.         };
    7199. 

  7199.     }
    7200. 

  7200. })();
    7201. 

  7201. })(blanket);
    7202. 

  7202. 

  7203. (function() {
    7204. 

  7204. 

  7205.     if (! jasmine) {
    7206. 

  7206.         throw new Exception("jasmine library does not exist in global namespace!");
    7207. 

  7207.     }
    7208. 

  7208. 

  7209.     function elapsed(startTime, endTime) {
    7210. 

  7210.         return (endTime - startTime)/1000;
    7211. 

  7211.     }
    7212. 

  7212. 

  7213.     function ISODateString(d) {
    7214. 

  7214.         function pad(n) { return n < 10 ? '0'+n : n; }
    7215. 

  7215. 

  7216.         return d.getFullYear() + '-' +
    7217. 

  7217.             pad(d.getMonth()+1) + '-' +
    7218. 

  7218.             pad(d.getDate()) + 'T' +
    7219. 

  7219.             pad(d.getHours()) + ':' +
    7220. 

  7220.             pad(d.getMinutes()) + ':' +
    7221. 

  7221.             pad(d.getSeconds());
    7222. 

  7222.     }
    7223. 

  7223. 

  7224.     function trim(str) {
    7225. 

  7225.         return str.replace(/^\s+/, "" ).replace(/\s+$/, "" );
    7226. 

  7226.     }
    7227. 

  7227. 

  7228.     function escapeInvalidXmlChars(str) {
    7229. 

  7229.         return str.replace(/\&/g, "&amp;")
    7230. 

  7230.             .replace(/</g, "&lt;")
    7231. 

  7231.             .replace(/\>/g, "&gt;")
    7232. 

  7232.             .replace(/\"/g, "&quot;")
    7233. 

  7233.             .replace(/\'/g, "&apos;");
    7234. 

  7234.     }
    7235. 

  7235. 

  7236.     /**
    7237. 

  7237.      * based on https://raw.github.com/larrymyers/jasmine-reporters/master/src/jasmine.junit_reporter.js
    7238. 

  7238.      */
    7239. 

  7239.     var BlanketReporter = function(savePath, consolidate, useDotNotation) {
    7240. 

  7240.         
    7241. 

  7241.         blanket.setupCoverage();
    7242. 

  7242.     };
    7243. 

  7243.     BlanketReporter.finished_at = null; // will be updated after all files have been written
    7244. 

  7244. 

  7245.     BlanketReporter.prototype = {
    7246. 

  7246.         reportSpecStarting: function(spec) {
    7247. 

  7247.             blanket.onTestStart();
    7248. 

  7248.         },
    7249. 

  7249. 

  7250.         reportSpecResults: function(suite) {
    7251. 

  7251.             var results = suite.results();
    7252. 

  7252. 

  7253.             blanket.onTestDone(results.totalCount,results.passed());
    7254. 

  7254.         },
    7255. 

  7255. 

  7256.         reportRunnerResults: function(runner) {
    7257. 

  7257.             blanket.onTestsDone();
    7258. 

  7258.         },
    7259. 

  7259. 

  7260.         log: function(str) {
    7261. 

  7261.             var console = jasmine.getGlobal().console;
    7262. 

  7262. 

  7263.             if (console && console.log) {
    7264. 

  7264.                 console.log(str);
    7265. 

  7265.             }
    7266. 

  7266.         }
    7267. 

  7267.     };
    7268. 

  7268. 

  7269. 

  7270.     // export public
    7271. 

  7271.     jasmine.BlanketReporter = BlanketReporter;
    7272. 

  7272. 

  7273.     //override existing jasmine execute
    7274. 

  7274.     jasmine.getEnv().execute = function(){ console.log("waiting for blanket..."); };
    7275. 

  7275.     
    7276. 

  7276.     //check to make sure requirejs is completed before we start the test runner
    7277. 

  7277.     var allLoaded = function() {
    7278. 

  7278.         return window.jasmine.getEnv().currentRunner().specs().length > 0 && blanket.requireFilesLoaded();
    7279. 

  7279.     };
    7280. 

  7280. 

  7281.     blanket.beforeStartTestRunner({
    7282. 

  7282.         checkRequirejs:true,
    7283. 

  7283.         condition: allLoaded,
    7284. 

  7284.         callback:function(){
    7285. 

  7285.             jasmine.getEnv().addReporter(new jasmine.BlanketReporter());
    7286. 

  7286.             window.jasmine.getEnv().currentRunner().execute();
    7287. 

  7287.             jasmine.getEnv().execute = function () {
    7288. 

  7288.                 jasmine.getEnv().currentRunner().execute;   
    7289. 

  7289.             };  
    7290. 

  7290.         }
    7291. 

  7291.     });
    7292. 

  7292. })();
    7293.