PageRenderTime 87ms CodeModel.GetById 1ms RepoModel.GetById 1ms app.codeStats 1ms

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

https://bitbucket.org/kolbyjAFK/cdnjs
JavaScript | 7280 lines | 6371 code | 701 blank | 208 comment | 796 complexity | 857bfaf7873960b2529b544b28661f14 MD5 | raw file
Possible License(s): MPL-2.0-no-copyleft-exception 
    

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

  2. 

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

  4. (function(define){
    5. 

  5. 

  6. /*
    7. 

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

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

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

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

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

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

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

    15. 

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

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

    18. 

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

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

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

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

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

    24. 

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

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

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

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

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

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

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

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

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

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

  34. */
    35. 

  35. 

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

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

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

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

  40. parseFunctionDeclaration: true, parseFunctionExpression: true,
    41. 

  41. parseFunctionSourceElements: true, parseVariableIdentifier: true,
    42. 

  42. parseLeftHandSideExpression: true,
    43. 

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

  44. 

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

  46.     'use strict';
    47. 

  47. 

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

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

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

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

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

  53.         factory(exports);
    54. 

  54.     } else {
    55. 

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

  56.     }
    57. 

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

  58.     'use strict';
    59. 

  59. 

  60.     var Token,
    61. 

  61.         TokenName,
    62. 

  62.         Syntax,
    63. 

  63.         PropertyKind,
    64. 

  64.         Messages,
    65. 

  65.         Regex,
    66. 

  66.         source,
    67. 

  67.         strict,
    68. 

  68.         index,
    69. 

  69.         lineNumber,
    70. 

  70.         lineStart,
    71. 

  71.         length,
    72. 

  72.         buffer,
    73. 

  73.         state,
    74. 

  74.         extra;
    75. 

  75. 

  76.     Token = {
    77. 

  77.         BooleanLiteral: 1,
    78. 

  78.         EOF: 2,
    79. 

  79.         Identifier: 3,
    80. 

  80.         Keyword: 4,
    81. 

  81.         NullLiteral: 5,
    82. 

  82.         NumericLiteral: 6,
    83. 

  83.         Punctuator: 7,
    84. 

  84.         StringLiteral: 8
    85. 

  85.     };
    86. 

  86. 

  87.     TokenName = {};
    88. 

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

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

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

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

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

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

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

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

  96. 

  97.     Syntax = {
    98. 

  98.         AssignmentExpression: 'AssignmentExpression',
    99. 

  99.         ArrayExpression: 'ArrayExpression',
    100. 

  100.         BlockStatement: 'BlockStatement',
    101. 

  101.         BinaryExpression: 'BinaryExpression',
    102. 

  102.         BreakStatement: 'BreakStatement',
    103. 

  103.         CallExpression: 'CallExpression',
    104. 

  104.         CatchClause: 'CatchClause',
    105. 

  105.         ConditionalExpression: 'ConditionalExpression',
    106. 

  106.         ContinueStatement: 'ContinueStatement',
    107. 

  107.         DoWhileStatement: 'DoWhileStatement',
    108. 

  108.         DebuggerStatement: 'DebuggerStatement',
    109. 

  109.         EmptyStatement: 'EmptyStatement',
    110. 

  110.         ExpressionStatement: 'ExpressionStatement',
    111. 

  111.         ForStatement: 'ForStatement',
    112. 

  112.         ForInStatement: 'ForInStatement',
    113. 

  113.         FunctionDeclaration: 'FunctionDeclaration',
    114. 

  114.         FunctionExpression: 'FunctionExpression',
    115. 

  115.         Identifier: 'Identifier',
    116. 

  116.         IfStatement: 'IfStatement',
    117. 

  117.         Literal: 'Literal',
    118. 

  118.         LabeledStatement: 'LabeledStatement',
    119. 

  119.         LogicalExpression: 'LogicalExpression',
    120. 

  120.         MemberExpression: 'MemberExpression',
    121. 

  121.         NewExpression: 'NewExpression',
    122. 

  122.         ObjectExpression: 'ObjectExpression',
    123. 

  123.         Program: 'Program',
    124. 

  124.         Property: 'Property',
    125. 

  125.         ReturnStatement: 'ReturnStatement',
    126. 

  126.         SequenceExpression: 'SequenceExpression',
    127. 

  127.         SwitchStatement: 'SwitchStatement',
    128. 

  128.         SwitchCase: 'SwitchCase',
    129. 

  129.         ThisExpression: 'ThisExpression',
    130. 

  130.         ThrowStatement: 'ThrowStatement',
    131. 

  131.         TryStatement: 'TryStatement',
    132. 

  132.         UnaryExpression: 'UnaryExpression',
    133. 

  133.         UpdateExpression: 'UpdateExpression',
    134. 

  134.         VariableDeclaration: 'VariableDeclaration',
    135. 

  135.         VariableDeclarator: 'VariableDeclarator',
    136. 

  136.         WhileStatement: 'WhileStatement',
    137. 

  137.         WithStatement: 'WithStatement'
    138. 

  138.     };
    139. 

  139. 

  140.     PropertyKind = {
    141. 

  141.         Data: 1,
    142. 

  142.         Get: 2,
    143. 

  143.         Set: 4
    144. 

  144.     };
    145. 

  145. 

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

  147.     Messages = {
    148. 

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

  149.         UnexpectedNumber:  'Unexpected number',
    150. 

  150.         UnexpectedString:  'Unexpected string',
    151. 

  151.         UnexpectedIdentifier:  'Unexpected identifier',
    152. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  181.     };
    182. 

  182. 

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

  184.     Regex = {
    185. 

  185.         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]'),
    186. 

  186.         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]')
    187. 

  187.     };
    188. 

  188. 

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

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

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

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

  193. 

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

  195.         if (!condition) {
    196. 

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

  197.         }
    198. 

  198.     }
    199. 

  199. 

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

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

  202.     }
    203. 

  203. 

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

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

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

  207.         };
    208. 

  208.     }
    209. 

  209. 

  210.     function isDecimalDigit(ch) {
    211. 

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

  212.     }
    213. 

  213. 

  214.     function isHexDigit(ch) {
    215. 

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

  216.     }
    217. 

  217. 

  218.     function isOctalDigit(ch) {
    219. 

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

  220.     }
    221. 

  221. 

  222. 

  223.     // 7.2 White Space
    224. 

  224. 

  225.     function isWhiteSpace(ch) {
    226. 

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

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

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

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

  230.     }
    231. 

  231. 

  232.     // 7.3 Line Terminators
    233. 

  233. 

  234.     function isLineTerminator(ch) {
    235. 

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

  236.     }
    237. 

  237. 

  238.     // 7.6 Identifier Names and Identifiers
    239. 

  239. 

  240.     function isIdentifierStart(ch) {
    241. 

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

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

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

  244.     }
    245. 

  245. 

  246.     function isIdentifierPart(ch) {
    247. 

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

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

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

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

  251.     }
    252. 

  252. 

  253.     // 7.6.1.2 Future Reserved Words
    254. 

  254. 

  255.     function isFutureReservedWord(id) {
    256. 

  256.         switch (id) {
    257. 

  257. 

  258.         // Future reserved words.
    259. 

  259.         case 'class':
    260. 

  260.         case 'enum':
    261. 

  261.         case 'export':
    262. 

  262.         case 'extends':
    263. 

  263.         case 'import':
    264. 

  264.         case 'super':
    265. 

  265.             return true;
    266. 

  266.         }
    267. 

  267. 

  268.         return false;
    269. 

  269.     }
    270. 

  270. 

  271.     function isStrictModeReservedWord(id) {
    272. 

  272.         switch (id) {
    273. 

  273. 

  274.         // Strict Mode reserved words.
    275. 

  275.         case 'implements':
    276. 

  276.         case 'interface':
    277. 

  277.         case 'package':
    278. 

  278.         case 'private':
    279. 

  279.         case 'protected':
    280. 

  280.         case 'public':
    281. 

  281.         case 'static':
    282. 

  282.         case 'yield':
    283. 

  283.         case 'let':
    284. 

  284.             return true;
    285. 

  285.         }
    286. 

  286. 

  287.         return false;
    288. 

  288.     }
    289. 

  289. 

  290.     function isRestrictedWord(id) {
    291. 

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

  292.     }
    293. 

  293. 

  294.     // 7.6.1.1 Keywords
    295. 

  295. 

  296.     function isKeyword(id) {
    297. 

  297.         var keyword = false;
    298. 

  298.         switch (id.length) {
    299. 

  299.         case 2:
    300. 

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

  301.             break;
    302. 

  302.         case 3:
    303. 

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

  304.             break;
    305. 

  305.         case 4:
    306. 

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

  307.             break;
    308. 

  308.         case 5:
    309. 

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

  310.             break;
    311. 

  311.         case 6:
    312. 

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

  313.             break;
    314. 

  314.         case 7:
    315. 

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

  316.             break;
    317. 

  317.         case 8:
    318. 

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

  319.             break;
    320. 

  320.         case 10:
    321. 

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

  322.             break;
    323. 

  323.         }
    324. 

  324. 

  325.         if (keyword) {
    326. 

  326.             return true;
    327. 

  327.         }
    328. 

  328. 

  329.         switch (id) {
    330. 

  330.         // Future reserved words.
    331. 

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

  332.         case 'const':
    333. 

  333.             return true;
    334. 

  334. 

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

  336.         case 'yield':
    337. 

  337.         case 'let':
    338. 

  338.             return true;
    339. 

  339.         }
    340. 

  340. 

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

  342.             return true;
    343. 

  343.         }
    344. 

  344. 

  345.         return isFutureReservedWord(id);
    346. 

  346.     }
    347. 

  347. 

  348.     // 7.4 Comments
    349. 

  349. 

  350.     function skipComment() {
    351. 

  351.         var ch, blockComment, lineComment;
    352. 

  352. 

  353.         blockComment = false;
    354. 

  354.         lineComment = false;
    355. 

  355. 

  356.         while (index < length) {
    357. 

  357.             ch = source[index];
    358. 

  358. 

  359.             if (lineComment) {
    360. 

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

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

  362.                     lineComment = false;
    363. 

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

  364.                         ++index;
    365. 

  365.                     }
    366. 

  366.                     ++lineNumber;
    367. 

  367.                     lineStart = index;
    368. 

  368.                 }
    369. 

  369.             } else if (blockComment) {
    370. 

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

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

  372.                         ++index;
    373. 

  373.                     }
    374. 

  374.                     ++lineNumber;
    375. 

  375.                     ++index;
    376. 

  376.                     lineStart = index;
    377. 

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

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

  379.                     }
    380. 

  380.                 } else {
    381. 

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

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

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

  384.                     }
    385. 

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

  386.                         ch = source[index];
    387. 

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

  388.                             ++index;
    389. 

  389.                             blockComment = false;
    390. 

  390.                         }
    391. 

  391.                     }
    392. 

  392.                 }
    393. 

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

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

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

  396.                     index += 2;
    397. 

  397.                     lineComment = true;
    398. 

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

  399.                     index += 2;
    400. 

  400.                     blockComment = true;
    401. 

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

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

  403.                     }
    404. 

  404.                 } else {
    405. 

  405.                     break;
    406. 

  406.                 }
    407. 

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

  408.                 ++index;
    409. 

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

  410.                 ++index;
    411. 

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

  412.                     ++index;
    413. 

  413.                 }
    414. 

  414.                 ++lineNumber;
    415. 

  415.                 lineStart = index;
    416. 

  416.             } else {
    417. 

  417.                 break;
    418. 

  418.             }
    419. 

  419.         }
    420. 

  420.     }
    421. 

  421. 

  422.     function scanHexEscape(prefix) {
    423. 

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

  424. 

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

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

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

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

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

  430.             } else {
    431. 

  431.                 return '';
    432. 

  432.             }
    433. 

  433.         }
    434. 

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

  435.     }
    436. 

  436. 

  437.     function scanIdentifier() {
    438. 

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

  439. 

  440.         ch = source[index];
    441. 

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

  442.             return;
    443. 

  443.         }
    444. 

  444. 

  445.         start = index;
    446. 

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

  447.             ++index;
    448. 

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

  449.                 return;
    450. 

  450.             }
    451. 

  451.             ++index;
    452. 

  452.             restore = index;
    453. 

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

  454.             if (ch) {
    455. 

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

  456.                     return;
    457. 

  457.                 }
    458. 

  458.                 id = ch;
    459. 

  459.             } else {
    460. 

  460.                 index = restore;
    461. 

  461.                 id = 'u';
    462. 

  462.             }
    463. 

  463.         } else {
    464. 

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

  465.         }
    466. 

  466. 

  467.         while (index < length) {
    468. 

  468.             ch = source[index];
    469. 

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

  470.                 break;
    471. 

  471.             }
    472. 

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

  473.                 ++index;
    474. 

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

  475.                     return;
    476. 

  476.                 }
    477. 

  477.                 ++index;
    478. 

  478.                 restore = index;
    479. 

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

  480.                 if (ch) {
    481. 

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

  482.                         return;
    483. 

  483.                     }
    484. 

  484.                     id += ch;
    485. 

  485.                 } else {
    486. 

  486.                     index = restore;
    487. 

  487.                     id += 'u';
    488. 

  488.                 }
    489. 

  489.             } else {
    490. 

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

  491.             }
    492. 

  492.         }
    493. 

  493. 

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

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

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

  497.             return {
    498. 

  498.                 type: Token.Identifier,
    499. 

  499.                 value: id,
    500. 

  500.                 lineNumber: lineNumber,
    501. 

  501.                 lineStart: lineStart,
    502. 

  502.                 range: [start, index]
    503. 

  503.             };
    504. 

  504.         }
    505. 

  505. 

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

  507.             return {
    508. 

  508.                 type: Token.Keyword,
    509. 

  509.                 value: id,
    510. 

  510.                 lineNumber: lineNumber,
    511. 

  511.                 lineStart: lineStart,
    512. 

  512.                 range: [start, index]
    513. 

  513.             };
    514. 

  514.         }
    515. 

  515. 

  516.         // 7.8.1 Null Literals
    517. 

  517. 

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

  519.             return {
    520. 

  520.                 type: Token.NullLiteral,
    521. 

  521.                 value: id,
    522. 

  522.                 lineNumber: lineNumber,
    523. 

  523.                 lineStart: lineStart,
    524. 

  524.                 range: [start, index]
    525. 

  525.             };
    526. 

  526.         }
    527. 

  527. 

  528.         // 7.8.2 Boolean Literals
    529. 

  529. 

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

  531.             return {
    532. 

  532.                 type: Token.BooleanLiteral,
    533. 

  533.                 value: id,
    534. 

  534.                 lineNumber: lineNumber,
    535. 

  535.                 lineStart: lineStart,
    536. 

  536.                 range: [start, index]
    537. 

  537.             };
    538. 

  538.         }
    539. 

  539. 

  540.         return {
    541. 

  541.             type: Token.Identifier,
    542. 

  542.             value: id,
    543. 

  543.             lineNumber: lineNumber,
    544. 

  544.             lineStart: lineStart,
    545. 

  545.             range: [start, index]
    546. 

  546.         };
    547. 

  547.     }
    548. 

  548. 

  549.     // 7.7 Punctuators
    550. 

  550. 

  551.     function scanPunctuator() {
    552. 

  552.         var start = index,
    553. 

  553.             ch1 = source[index],
    554. 

  554.             ch2,
    555. 

  555.             ch3,
    556. 

  556.             ch4;
    557. 

  557. 

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

  559. 

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

  561.             ++index;
    562. 

  562.             return {
    563. 

  563.                 type: Token.Punctuator,
    564. 

  564.                 value: ch1,
    565. 

  565.                 lineNumber: lineNumber,
    566. 

  566.                 lineStart: lineStart,
    567. 

  567.                 range: [start, index]
    568. 

  568.             };
    569. 

  569.         }
    570. 

  570. 

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

  572.             ++index;
    573. 

  573.             return {
    574. 

  574.                 type: Token.Punctuator,
    575. 

  575.                 value: ch1,
    576. 

  576.                 lineNumber: lineNumber,
    577. 

  577.                 lineStart: lineStart,
    578. 

  578.                 range: [start, index]
    579. 

  579.             };
    580. 

  580.         }
    581. 

  581. 

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

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

  584. 

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

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

  587.             return {
    588. 

  588.                 type: Token.Punctuator,
    589. 

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

  590.                 lineNumber: lineNumber,
    591. 

  591.                 lineStart: lineStart,
    592. 

  592.                 range: [start, index]
    593. 

  593.             };
    594. 

  594.         }
    595. 

  595. 

  596.         // Peek more characters.
    597. 

  597. 

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

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

  600. 

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

  602. 

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

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

  605.                 index += 4;
    606. 

  606.                 return {
    607. 

  607.                     type: Token.Punctuator,
    608. 

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

  609.                     lineNumber: lineNumber,
    610. 

  610.                     lineStart: lineStart,
    611. 

  611.                     range: [start, index]
    612. 

  612.                 };
    613. 

  613.             }
    614. 

  614.         }
    615. 

  615. 

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

  617. 

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

  619.             index += 3;
    620. 

  620.             return {
    621. 

  621.                 type: Token.Punctuator,
    622. 

  622.                 value: '===',
    623. 

  623.                 lineNumber: lineNumber,
    624. 

  624.                 lineStart: lineStart,
    625. 

  625.                 range: [start, index]
    626. 

  626.             };
    627. 

  627.         }
    628. 

  628. 

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

  630.             index += 3;
    631. 

  631.             return {
    632. 

  632.                 type: Token.Punctuator,
    633. 

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

  634.                 lineNumber: lineNumber,
    635. 

  635.                 lineStart: lineStart,
    636. 

  636.                 range: [start, index]
    637. 

  637.             };
    638. 

  638.         }
    639. 

  639. 

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

  641.             index += 3;
    642. 

  642.             return {
    643. 

  643.                 type: Token.Punctuator,
    644. 

  644.                 value: '>>>',
    645. 

  645.                 lineNumber: lineNumber,
    646. 

  646.                 lineStart: lineStart,
    647. 

  647.                 range: [start, index]
    648. 

  648.             };
    649. 

  649.         }
    650. 

  650. 

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

  652.             index += 3;
    653. 

  653.             return {
    654. 

  654.                 type: Token.Punctuator,
    655. 

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

  656.                 lineNumber: lineNumber,
    657. 

  657.                 lineStart: lineStart,
    658. 

  658.                 range: [start, index]
    659. 

  659.             };
    660. 

  660.         }
    661. 

  661. 

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

  663.             index += 3;
    664. 

  664.             return {
    665. 

  665.                 type: Token.Punctuator,
    666. 

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

  667.                 lineNumber: lineNumber,
    668. 

  668.                 lineStart: lineStart,
    669. 

  669.                 range: [start, index]
    670. 

  670.             };
    671. 

  671.         }
    672. 

  672. 

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

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

  675. 

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

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

  678.                 index += 2;
    679. 

  679.                 return {
    680. 

  680.                     type: Token.Punctuator,
    681. 

  681.                     value: ch1 + ch2,
    682. 

  682.                     lineNumber: lineNumber,
    683. 

  683.                     lineStart: lineStart,
    684. 

  684.                     range: [start, index]
    685. 

  685.                 };
    686. 

  686.             }
    687. 

  687.         }
    688. 

  688. 

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

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

  691.                 index += 2;
    692. 

  692.                 return {
    693. 

  693.                     type: Token.Punctuator,
    694. 

  694.                     value: ch1 + ch2,
    695. 

  695.                     lineNumber: lineNumber,
    696. 

  696.                     lineStart: lineStart,
    697. 

  697.                     range: [start, index]
    698. 

  698.                 };
    699. 

  699.             }
    700. 

  700.         }
    701. 

  701. 

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

  703. 

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

  705.             return {
    706. 

  706.                 type: Token.Punctuator,
    707. 

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

  708.                 lineNumber: lineNumber,
    709. 

  709.                 lineStart: lineStart,
    710. 

  710.                 range: [start, index]
    711. 

  711.             };
    712. 

  712.         }
    713. 

  713.     }
    714. 

  714. 

  715.     // 7.8.3 Numeric Literals
    716. 

  716. 

  717.     function scanNumericLiteral() {
    718. 

  718.         var number, start, ch;
    719. 

  719. 

  720.         ch = source[index];
    721. 

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

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

  723. 

  724.         start = index;
    725. 

  725.         number = '';
    726. 

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

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

  728.             ch = source[index];
    729. 

  729. 

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

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

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

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

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

  735.                     while (index < length) {
    736. 

  736.                         ch = source[index];
    737. 

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

  738.                             break;
    739. 

  739.                         }
    740. 

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

  741.                     }
    742. 

  742. 

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

  744.                         // only 0x
    745. 

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

  746.                     }
    747. 

  747. 

  748.                     if (index < length) {
    749. 

  749.                         ch = source[index];
    750. 

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

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

  752.                         }
    753. 

  753.                     }
    754. 

  754.                     return {
    755. 

  755.                         type: Token.NumericLiteral,
    756. 

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

  757.                         lineNumber: lineNumber,
    758. 

  758.                         lineStart: lineStart,
    759. 

  759.                         range: [start, index]
    760. 

  760.                     };
    761. 

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

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

  763.                     while (index < length) {
    764. 

  764.                         ch = source[index];
    765. 

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

  766.                             break;
    767. 

  767.                         }
    768. 

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

  769.                     }
    770. 

  770. 

  771.                     if (index < length) {
    772. 

  772.                         ch = source[index];
    773. 

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

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

  775.                         }
    776. 

  776.                     }
    777. 

  777.                     return {
    778. 

  778.                         type: Token.NumericLiteral,
    779. 

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

  780.                         octal: true,
    781. 

  781.                         lineNumber: lineNumber,
    782. 

  782.                         lineStart: lineStart,
    783. 

  783.                         range: [start, index]
    784. 

  784.                     };
    785. 

  785.                 }
    786. 

  786. 

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

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

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

  790.                 }
    791. 

  791.             }
    792. 

  792. 

  793.             while (index < length) {
    794. 

  794.                 ch = source[index];
    795. 

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

  796.                     break;
    797. 

  797.                 }
    798. 

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

  799.             }
    800. 

  800.         }
    801. 

  801. 

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

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

  804.             while (index < length) {
    805. 

  805.                 ch = source[index];
    806. 

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

  807.                     break;
    808. 

  808.                 }
    809. 

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

  810.             }
    811. 

  811.         }
    812. 

  812. 

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

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

  815. 

  816.             ch = source[index];
    817. 

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

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

  819.             }
    820. 

  820. 

  821.             ch = source[index];
    822. 

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

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

  824.                 while (index < length) {
    825. 

  825.                     ch = source[index];
    826. 

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

  827.                         break;
    828. 

  828.                     }
    829. 

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

  830.                 }
    831. 

  831.             } else {
    832. 

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

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

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

  835.                 }
    836. 

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

  837.             }
    838. 

  838.         }
    839. 

  839. 

  840.         if (index < length) {
    841. 

  841.             ch = source[index];
    842. 

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

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

  844.             }
    845. 

  845.         }
    846. 

  846. 

  847.         return {
    848. 

  848.             type: Token.NumericLiteral,
    849. 

  849.             value: parseFloat(number),
    850. 

  850.             lineNumber: lineNumber,
    851. 

  851.             lineStart: lineStart,
    852. 

  852.             range: [start, index]
    853. 

  853.         };
    854. 

  854.     }
    855. 

  855. 

  856.     // 7.8.4 String Literals
    857. 

  857. 

  858.     function scanStringLiteral() {
    859. 

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

  860. 

  861.         quote = source[index];
    862. 

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

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

  864. 

  865.         start = index;
    866. 

  866.         ++index;
    867. 

  867. 

  868.         while (index < length) {
    869. 

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

  870. 

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

  872.                 quote = '';
    873. 

  873.                 break;
    874. 

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

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

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

  877.                     switch (ch) {
    878. 

  878.                     case 'n':
    879. 

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

  880.                         break;
    881. 

  881.                     case 'r':
    882. 

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

  883.                         break;
    884. 

  884.                     case 't':
    885. 

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

  886.                         break;
    887. 

  887.                     case 'u':
    888. 

  888.                     case 'x':
    889. 

  889.                         restore = index;
    890. 

  890.                         unescaped = scanHexEscape(ch);
    891. 

  891.                         if (unescaped) {
    892. 

  892.                             str += unescaped;
    893. 

  893.                         } else {
    894. 

  894.                             index = restore;
    895. 

  895.                             str += ch;
    896. 

  896.                         }
    897. 

  897.                         break;
    898. 

  898.                     case 'b':
    899. 

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

  900.                         break;
    901. 

  901.                     case 'f':
    902. 

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

  903.                         break;
    904. 

  904.                     case 'v':
    905. 

  905.                         str += '\v';
    906. 

  906.                         break;
    907. 

  907. 

  908.                     default:
    909. 

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

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

  911. 

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

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

  914.                                 octal = true;
    915. 

  915.                             }
    916. 

  916. 

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

  918.                                 octal = true;
    919. 

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

  920. 

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

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

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

  924.                                         index < length &&
    925. 

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

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

  927.                                 }
    928. 

  928.                             }
    929. 

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

  930.                         } else {
    931. 

  931.                             str += ch;
    932. 

  932.                         }
    933. 

  933.                         break;
    934. 

  934.                     }
    935. 

  935.                 } else {
    936. 

  936.                     ++lineNumber;
    937. 

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

  938.                         ++index;
    939. 

  939.                     }
    940. 

  940.                 }
    941. 

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

  942.                 break;
    943. 

  943.             } else {
    944. 

  944.                 str += ch;
    945. 

  945.             }
    946. 

  946.         }
    947. 

  947. 

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

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

  950.         }
    951. 

  951. 

  952.         return {
    953. 

  953.             type: Token.StringLiteral,
    954. 

  954.             value: str,
    955. 

  955.             octal: octal,
    956. 

  956.             lineNumber: lineNumber,
    957. 

  957.             lineStart: lineStart,
    958. 

  958.             range: [start, index]
    959. 

  959.         };
    960. 

  960.     }
    961. 

  961. 

  962.     function scanRegExp() {
    963. 

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

  964. 

  965.         buffer = null;
    966. 

  966.         skipComment();
    967. 

  967. 

  968.         start = index;
    969. 

  969.         ch = source[index];
    970. 

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

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

  972. 

  973.         while (index < length) {
    974. 

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

  975.             str += ch;
    976. 

  976.             if (classMarker) {
    977. 

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

  978.                     classMarker = false;
    979. 

  979.                 }
    980. 

  980.             } else {
    981. 

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

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

  983.                     // ECMA-262 7.8.5
    984. 

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

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

  986.                     }
    987. 

  987.                     str += ch;
    988. 

  988.                 } else if (ch === '/') {
    989. 

  989.                     terminated = true;
    990. 

  990.                     break;
    991. 

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

  992.                     classMarker = true;
    993. 

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

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

  995.                 }
    996. 

  996.             }
    997. 

  997.         }
    998. 

  998. 

  999.         if (!terminated) {
    1000. 

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

  1001.         }
    1002. 

  1002. 

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

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

  1005. 

  1006.         flags = '';
    1007. 

  1007.         while (index < length) {
    1008. 

  1008.             ch = source[index];
    1009. 

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

  1010.                 break;
    1011. 

  1011.             }
    1012. 

  1012. 

  1013.             ++index;
    1014. 

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

  1015.                 ch = source[index];
    1016. 

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

  1017.                     ++index;
    1018. 

  1018.                     restore = index;
    1019. 

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

  1020.                     if (ch) {
    1021. 

  1021.                         flags += ch;
    1022. 

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

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

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

  1025.                         }
    1026. 

  1026.                     } else {
    1027. 

  1027.                         index = restore;
    1028. 

  1028.                         flags += 'u';
    1029. 

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

  1030.                     }
    1031. 

  1031.                 } else {
    1032. 

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

  1033.                 }
    1034. 

  1034.             } else {
    1035. 

  1035.                 flags += ch;
    1036. 

  1036.                 str += ch;
    1037. 

  1037.             }
    1038. 

  1038.         }
    1039. 

  1039. 

  1040.         try {
    1041. 

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

  1042.         } catch (e) {
    1043. 

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

  1044.         }
    1045. 

  1045. 

  1046.         return {
    1047. 

  1047.             literal: str,
    1048. 

  1048.             value: value,
    1049. 

  1049.             range: [start, index]
    1050. 

  1050.         };
    1051. 

  1051.     }
    1052. 

  1052. 

  1053.     function isIdentifierName(token) {
    1054. 

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

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

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

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

  1058.     }
    1059. 

  1059. 

  1060.     function advance() {
    1061. 

  1061.         var ch, token;
    1062. 

  1062. 

  1063.         skipComment();
    1064. 

  1064. 

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

  1066.             return {
    1067. 

  1067.                 type: Token.EOF,
    1068. 

  1068.                 lineNumber: lineNumber,
    1069. 

  1069.                 lineStart: lineStart,
    1070. 

  1070.                 range: [index, index]
    1071. 

  1071.             };
    1072. 

  1072.         }
    1073. 

  1073. 

  1074.         token = scanPunctuator();
    1075. 

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

  1076.             return token;
    1077. 

  1077.         }
    1078. 

  1078. 

  1079.         ch = source[index];
    1080. 

  1080. 

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

  1082.             return scanStringLiteral();
    1083. 

  1083.         }
    1084. 

  1084. 

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

  1086.             return scanNumericLiteral();
    1087. 

  1087.         }
    1088. 

  1088. 

  1089.         token = scanIdentifier();
    1090. 

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

  1091.             return token;
    1092. 

  1092.         }
    1093. 

  1093. 

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

  1095.     }
    1096. 

  1096. 

  1097.     function lex() {
    1098. 

  1098.         var token;
    1099. 

  1099. 

  1100.         if (buffer) {
    1101. 

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

  1102.             lineNumber = buffer.lineNumber;
    1103. 

  1103.             lineStart = buffer.lineStart;
    1104. 

  1104.             token = buffer;
    1105. 

  1105.             buffer = null;
    1106. 

  1106.             return token;
    1107. 

  1107.         }
    1108. 

  1108. 

  1109.         buffer = null;
    1110. 

  1110.         return advance();
    1111. 

  1111.     }
    1112. 

  1112. 

  1113.     function lookahead() {
    1114. 

  1114.         var pos, line, start;
    1115. 

  1115. 

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

  1117.             return buffer;
    1118. 

  1118.         }
    1119. 

  1119. 

  1120.         pos = index;
    1121. 

  1121.         line = lineNumber;
    1122. 

  1122.         start = lineStart;
    1123. 

  1123.         buffer = advance();
    1124. 

  1124.         index = pos;
    1125. 

  1125.         lineNumber = line;
    1126. 

  1126.         lineStart = start;
    1127. 

  1127. 

  1128.         return buffer;
    1129. 

  1129.     }
    1130. 

  1130. 

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

  1132. 

  1133.     function peekLineTerminator() {
    1134. 

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

  1135. 

  1136.         pos = index;
    1137. 

  1137.         line = lineNumber;
    1138. 

  1138.         start = lineStart;
    1139. 

  1139.         skipComment();
    1140. 

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

  1141.         index = pos;
    1142. 

  1142.         lineNumber = line;
    1143. 

  1143.         lineStart = start;
    1144. 

  1144. 

  1145.         return found;
    1146. 

  1146.     }
    1147. 

  1147. 

  1148.     // Throw an exception
    1149. 

  1149. 

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

  1151.         var error,
    1152. 

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

  1153.             msg = messageFormat.replace(
    1154. 

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

  1155.                 function (whole, index) {
    1156. 

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

  1157.                 }
    1158. 

  1158.             );
    1159. 

  1159. 

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

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

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

  1163.             error.lineNumber = token.lineNumber;
    1164. 

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

  1165.         } else {
    1166. 

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

  1167.             error.index = index;
    1168. 

  1168.             error.lineNumber = lineNumber;
    1169. 

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

  1170.         }
    1171. 

  1171. 

  1172.         throw error;
    1173. 

  1173.     }
    1174. 

  1174. 

  1175.     function throwErrorTolerant() {
    1176. 

  1176.         try {
    1177. 

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

  1178.         } catch (e) {
    1179. 

  1179.             if (extra.errors) {
    1180. 

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

  1181.             } else {
    1182. 

  1182.                 throw e;
    1183. 

  1183.             }
    1184. 

  1184.         }
    1185. 

  1185.     }
    1186. 

  1186. 

  1187. 

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

  1189. 

  1190.     function throwUnexpected(token) {
    1191. 

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

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

  1193.         }
    1194. 

  1194. 

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

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

  1197.         }
    1198. 

  1198. 

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

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

  1201.         }
    1202. 

  1202. 

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

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

  1205.         }
    1206. 

  1206. 

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

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

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

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

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

  1212.                 return;
    1213. 

  1213.             }
    1214. 

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

  1215.         }
    1216. 

  1216. 

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

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

  1219.     }
    1220. 

  1220. 

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

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

  1223. 

  1224.     function expect(value) {
    1225. 

  1225.         var token = lex();
    1226. 

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

  1227.             throwUnexpected(token);
    1228. 

  1228.         }
    1229. 

  1229.     }
    1230. 

  1230. 

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

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

  1233. 

  1234.     function expectKeyword(keyword) {
    1235. 

  1235.         var token = lex();
    1236. 

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

  1237.             throwUnexpected(token);
    1238. 

  1238.         }
    1239. 

  1239.     }
    1240. 

  1240. 

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

  1242. 

  1243.     function match(value) {
    1244. 

  1244.         var token = lookahead();
    1245. 

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

  1246.     }
    1247. 

  1247. 

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

  1249. 

  1250.     function matchKeyword(keyword) {
    1251. 

  1251.         var token = lookahead();
    1252. 

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

  1253.     }
    1254. 

  1254. 

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

  1256. 

  1257.     function matchAssign() {
    1258. 

  1258.         var token = lookahead(),
    1259. 

  1259.             op = token.value;
    1260. 

  1260. 

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

  1262.             return false;
    1263. 

  1263.         }
    1264. 

  1264.         return 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.             op === '|=';
    1276. 

  1276.     }
    1277. 

  1277. 

  1278.     function consumeSemicolon() {
    1279. 

  1279.         var token, line;
    1280. 

  1280. 

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

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

  1283.             lex();
    1284. 

  1284.             return;
    1285. 

  1285.         }
    1286. 

  1286. 

  1287.         line = lineNumber;
    1288. 

  1288.         skipComment();
    1289. 

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

  1290.             return;
    1291. 

  1291.         }
    1292. 

  1292. 

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

  1294.             lex();
    1295. 

  1295.             return;
    1296. 

  1296.         }
    1297. 

  1297. 

  1298.         token = lookahead();
    1299. 

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

  1300.             throwUnexpected(token);
    1301. 

  1301.         }
    1302. 

  1302.     }
    1303. 

  1303. 

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

  1305. 

  1306.     function isLeftHandSide(expr) {
    1307. 

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

  1308.     }
    1309. 

  1309. 

  1310.     // 11.1.4 Array Initialiser
    1311. 

  1311. 

  1312.     function parseArrayInitialiser() {
    1313. 

  1313.         var elements = [];
    1314. 

  1314. 

  1315.         expect('[');
    1316. 

  1316. 

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

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

  1319.                 lex();
    1320. 

  1320.                 elements.push(null);
    1321. 

  1321.             } else {
    1322. 

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

  1323. 

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

  1325.                     expect(',');
    1326. 

  1326.                 }
    1327. 

  1327.             }
    1328. 

  1328.         }
    1329. 

  1329. 

  1330.         expect(']');
    1331. 

  1331. 

  1332.         return {
    1333. 

  1333.             type: Syntax.ArrayExpression,
    1334. 

  1334.             elements: elements
    1335. 

  1335.         };
    1336. 

  1336.     }
    1337. 

  1337. 

  1338.     // 11.1.5 Object Initialiser
    1339. 

  1339. 

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

  1341.         var previousStrict, body;
    1342. 

  1342. 

  1343.         previousStrict = strict;
    1344. 

  1344.         body = parseFunctionSourceElements();
    1345. 

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

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

  1347.         }
    1348. 

  1348.         strict = previousStrict;
    1349. 

  1349. 

  1350.         return {
    1351. 

  1351.             type: Syntax.FunctionExpression,
    1352. 

  1352.             id: null,
    1353. 

  1353.             params: param,
    1354. 

  1354.             defaults: [],
    1355. 

  1355.             body: body,
    1356. 

  1356.             rest: null,
    1357. 

  1357.             generator: false,
    1358. 

  1358.             expression: false
    1359. 

  1359.         };
    1360. 

  1360.     }
    1361. 

  1361. 

  1362.     function parseObjectPropertyKey() {
    1363. 

  1363.         var token = lex();
    1364. 

  1364. 

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

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

  1367. 

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

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

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

  1371.             }
    1372. 

  1372.             return createLiteral(token);
    1373. 

  1373.         }
    1374. 

  1374. 

  1375.         return {
    1376. 

  1376.             type: Syntax.Identifier,
    1377. 

  1377.             name: token.value
    1378. 

  1378.         };
    1379. 

  1379.     }
    1380. 

  1380. 

  1381.     function parseObjectProperty() {
    1382. 

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

  1383. 

  1384.         token = lookahead();
    1385. 

  1385. 

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

  1387. 

  1388.             id = parseObjectPropertyKey();
    1389. 

  1389. 

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

  1391. 

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

  1393.                 key = parseObjectPropertyKey();
    1394. 

  1394.                 expect('(');
    1395. 

  1395.                 expect(')');
    1396. 

  1396.                 return {
    1397. 

  1397.                     type: Syntax.Property,
    1398. 

  1398.                     key: key,
    1399. 

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

  1400.                     kind: 'get'
    1401. 

  1401.                 };
    1402. 

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

  1403.                 key = parseObjectPropertyKey();
    1404. 

  1404.                 expect('(');
    1405. 

  1405.                 token = lookahead();
    1406. 

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

  1407.                     throwUnexpected(lex());
    1408. 

  1408.                 }
    1409. 

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

  1410.                 expect(')');
    1411. 

  1411.                 return {
    1412. 

  1412.                     type: Syntax.Property,
    1413. 

  1413.                     key: key,
    1414. 

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

  1415.                     kind: 'set'
    1416. 

  1416.                 };
    1417. 

  1417.             } else {
    1418. 

  1418.                 expect(':');
    1419. 

  1419.                 return {
    1420. 

  1420.                     type: Syntax.Property,
    1421. 

  1421.                     key: id,
    1422. 

  1422.                     value: parseAssignmentExpression(),
    1423. 

  1423.                     kind: 'init'
    1424. 

  1424.                 };
    1425. 

  1425.             }
    1426. 

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

  1427.             throwUnexpected(token);
    1428. 

  1428.         } else {
    1429. 

  1429.             key = parseObjectPropertyKey();
    1430. 

  1430.             expect(':');
    1431. 

  1431.             return {
    1432. 

  1432.                 type: Syntax.Property,
    1433. 

  1433.                 key: key,
    1434. 

  1434.                 value: parseAssignmentExpression(),
    1435. 

  1435.                 kind: 'init'
    1436. 

  1436.             };
    1437. 

  1437.         }
    1438. 

  1438.     }
    1439. 

  1439. 

  1440.     function parseObjectInitialiser() {
    1441. 

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

  1442. 

  1443.         expect('{');
    1444. 

  1444. 

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

  1446.             property = parseObjectProperty();
    1447. 

  1447. 

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

  1449.                 name = property.key.name;
    1450. 

  1450.             } else {
    1451. 

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

  1452.             }
    1453. 

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

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

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

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

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

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

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

  1460.                     }
    1461. 

  1461.                 } else {
    1462. 

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

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

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

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

  1466.                     }
    1467. 

  1467.                 }
    1468. 

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

  1469.             } else {
    1470. 

  1470.                 map[name] = kind;
    1471. 

  1471.             }
    1472. 

  1472. 

  1473.             properties.push(property);
    1474. 

  1474. 

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

  1476.                 expect(',');
    1477. 

  1477.             }
    1478. 

  1478.         }
    1479. 

  1479. 

  1480.         expect('}');
    1481. 

  1481. 

  1482.         return {
    1483. 

  1483.             type: Syntax.ObjectExpression,
    1484. 

  1484.             properties: properties
    1485. 

  1485.         };
    1486. 

  1486.     }
    1487. 

  1487. 

  1488.     // 11.1.6 The Grouping Operator
    1489. 

  1489. 

  1490.     function parseGroupExpression() {
    1491. 

  1491.         var expr;
    1492. 

  1492. 

  1493.         expect('(');
    1494. 

  1494. 

  1495.         expr = parseExpression();
    1496. 

  1496. 

  1497.         expect(')');
    1498. 

  1498. 

  1499.         return expr;
    1500. 

  1500.     }
    1501. 

  1501. 

  1502. 

  1503.     // 11.1 Primary Expressions
    1504. 

  1504. 

  1505.     function parsePrimaryExpression() {
    1506. 

  1506.         var token = lookahead(),
    1507. 

  1507.             type = token.type;
    1508. 

  1508. 

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

  1510.             return {
    1511. 

  1511.                 type: Syntax.Identifier,
    1512. 

  1512.                 name: lex().value
    1513. 

  1513.             };
    1514. 

  1514.         }
    1515. 

  1515. 

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

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

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

  1519.             }
    1520. 

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

  1521.         }
    1522. 

  1522. 

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

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

  1525.                 lex();
    1526. 

  1526.                 return {
    1527. 

  1527.                     type: Syntax.ThisExpression
    1528. 

  1528.                 };
    1529. 

  1529.             }
    1530. 

  1530. 

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

  1532.                 return parseFunctionExpression();
    1533. 

  1533.             }
    1534. 

  1534.         }
    1535. 

  1535. 

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

  1537.             lex();
    1538. 

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

  1539.             return createLiteral(token);
    1540. 

  1540.         }
    1541. 

  1541. 

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

  1543.             lex();
    1544. 

  1544.             token.value = null;
    1545. 

  1545.             return createLiteral(token);
    1546. 

  1546.         }
    1547. 

  1547. 

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

  1549.             return parseArrayInitialiser();
    1550. 

  1550.         }
    1551. 

  1551. 

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

  1553.             return parseObjectInitialiser();
    1554. 

  1554.         }
    1555. 

  1555. 

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

  1557.             return parseGroupExpression();
    1558. 

  1558.         }
    1559. 

  1559. 

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

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

  1562.         }
    1563. 

  1563. 

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

  1565.     }
    1566. 

  1566. 

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

  1568. 

  1569.     function parseArguments() {
    1570. 

  1570.         var args = [];
    1571. 

  1571. 

  1572.         expect('(');
    1573. 

  1573. 

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

  1575.             while (index < length) {
    1576. 

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

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

  1578.                     break;
    1579. 

  1579.                 }
    1580. 

  1580.                 expect(',');
    1581. 

  1581.             }
    1582. 

  1582.         }
    1583. 

  1583. 

  1584.         expect(')');
    1585. 

  1585. 

  1586.         return args;
    1587. 

  1587.     }
    1588. 

  1588. 

  1589.     function parseNonComputedProperty() {
    1590. 

  1590.         var token = lex();
    1591. 

  1591. 

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

  1593.             throwUnexpected(token);
    1594. 

  1594.         }
    1595. 

  1595. 

  1596.         return {
    1597. 

  1597.             type: Syntax.Identifier,
    1598. 

  1598.             name: token.value
    1599. 

  1599.         };
    1600. 

  1600.     }
    1601. 

  1601. 

  1602.     function parseNonComputedMember() {
    1603. 

  1603.         expect('.');
    1604. 

  1604. 

  1605.         return parseNonComputedProperty();
    1606. 

  1606.     }
    1607. 

  1607. 

  1608.     function parseComputedMember() {
    1609. 

  1609.         var expr;
    1610. 

  1610. 

  1611.         expect('[');
    1612. 

  1612. 

  1613.         expr = parseExpression();
    1614. 

  1614. 

  1615.         expect(']');
    1616. 

  1616. 

  1617.         return expr;
    1618. 

  1618.     }
    1619. 

  1619. 

  1620.     function parseNewExpression() {
    1621. 

  1621.         var expr;
    1622. 

  1622. 

  1623.         expectKeyword('new');
    1624. 

  1624. 

  1625.         expr = {
    1626. 

  1626.             type: Syntax.NewExpression,
    1627. 

  1627.             callee: parseLeftHandSideExpression(),
    1628. 

  1628.             'arguments': []
    1629. 

  1629.         };
    1630. 

  1630. 

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

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

  1633.         }
    1634. 

  1634. 

  1635.         return expr;
    1636. 

  1636.     }
    1637. 

  1637. 

  1638.     function parseLeftHandSideExpressionAllowCall() {
    1639. 

  1639.         var expr;
    1640. 

  1640. 

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

  1642. 

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

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

  1645.                 expr = {
    1646. 

  1646.                     type: Syntax.CallExpression,
    1647. 

  1647.                     callee: expr,
    1648. 

  1648.                     'arguments': parseArguments()
    1649. 

  1649.                 };
    1650. 

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

  1651.                 expr = {
    1652. 

  1652.                     type: Syntax.MemberExpression,
    1653. 

  1653.                     computed: true,
    1654. 

  1654.                     object: expr,
    1655. 

  1655.                     property: parseComputedMember()
    1656. 

  1656.                 };
    1657. 

  1657.             } else {
    1658. 

  1658.                 expr = {
    1659. 

  1659.                     type: Syntax.MemberExpression,
    1660. 

  1660.                     computed: false,
    1661. 

  1661.                     object: expr,
    1662. 

  1662.                     property: parseNonComputedMember()
    1663. 

  1663.                 };
    1664. 

  1664.             }
    1665. 

  1665.         }
    1666. 

  1666. 

  1667.         return expr;
    1668. 

  1668.     }
    1669. 

  1669. 

  1670. 

  1671.     function parseLeftHandSideExpression() {
    1672. 

  1672.         var expr;
    1673. 

  1673. 

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

  1675. 

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

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

  1678.                 expr = {
    1679. 

  1679.                     type: Syntax.MemberExpression,
    1680. 

  1680.                     computed: true,
    1681. 

  1681.                     object: expr,
    1682. 

  1682.                     property: parseComputedMember()
    1683. 

  1683.                 };
    1684. 

  1684.             } else {
    1685. 

  1685.                 expr = {
    1686. 

  1686.                     type: Syntax.MemberExpression,
    1687. 

  1687.                     computed: false,
    1688. 

  1688.                     object: expr,
    1689. 

  1689.                     property: parseNonComputedMember()
    1690. 

  1690.                 };
    1691. 

  1691.             }
    1692. 

  1692.         }
    1693. 

  1693. 

  1694.         return expr;
    1695. 

  1695.     }
    1696. 

  1696. 

  1697.     // 11.3 Postfix Expressions
    1698. 

  1698. 

  1699.     function parsePostfixExpression() {
    1700. 

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

  1701. 

  1702.         token = lookahead();
    1703. 

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

  1704.             return expr;
    1705. 

  1705.         }
    1706. 

  1706. 

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

  1708.             // 11.3.1, 11.3.2
    1709. 

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

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

  1711.             }
    1712. 

  1712. 

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

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

  1715.             }
    1716. 

  1716. 

  1717.             expr = {
    1718. 

  1718.                 type: Syntax.UpdateExpression,
    1719. 

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

  1720.                 argument: expr,
    1721. 

  1721.                 prefix: false
    1722. 

  1722.             };
    1723. 

  1723.         }
    1724. 

  1724. 

  1725.         return expr;
    1726. 

  1726.     }
    1727. 

  1727. 

  1728.     // 11.4 Unary Operators
    1729. 

  1729. 

  1730.     function parseUnaryExpression() {
    1731. 

  1731.         var token, expr;
    1732. 

  1732. 

  1733.         token = lookahead();
    1734. 

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

  1735.             return parsePostfixExpression();
    1736. 

  1736.         }
    1737. 

  1737. 

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

  1739.             token = lex();
    1740. 

  1740.             expr = parseUnaryExpression();
    1741. 

  1741.             // 11.4.4, 11.4.5
    1742. 

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

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

  1744.             }
    1745. 

  1745. 

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

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

  1748.             }
    1749. 

  1749. 

  1750.             expr = {
    1751. 

  1751.                 type: Syntax.UpdateExpression,
    1752. 

  1752.                 operator: token.value,
    1753. 

  1753.                 argument: expr,
    1754. 

  1754.                 prefix: true
    1755. 

  1755.             };
    1756. 

  1756.             return expr;
    1757. 

  1757.         }
    1758. 

  1758. 

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

  1760.             expr = {
    1761. 

  1761.                 type: Syntax.UnaryExpression,
    1762. 

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

  1763.                 argument: parseUnaryExpression()
    1764. 

  1764.             };
    1765. 

  1765.             return expr;
    1766. 

  1766.         }
    1767. 

  1767. 

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

  1769.             expr = {
    1770. 

  1770.                 type: Syntax.UnaryExpression,
    1771. 

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

  1772.                 argument: parseUnaryExpression()
    1773. 

  1773.             };
    1774. 

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

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

  1776.             }
    1777. 

  1777.             return expr;
    1778. 

  1778.         }
    1779. 

  1779. 

  1780.         return parsePostfixExpression();
    1781. 

  1781.     }
    1782. 

  1782. 

  1783.     // 11.5 Multiplicative Operators
    1784. 

  1784. 

  1785.     function parseMultiplicativeExpression() {
    1786. 

  1786.         var expr = parseUnaryExpression();
    1787. 

  1787. 

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

  1789.             expr = {
    1790. 

  1790.                 type: Syntax.BinaryExpression,
    1791. 

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

  1792.                 left: expr,
    1793. 

  1793.                 right: parseUnaryExpression()
    1794. 

  1794.             };
    1795. 

  1795.         }
    1796. 

  1796. 

  1797.         return expr;
    1798. 

  1798.     }
    1799. 

  1799. 

  1800.     // 11.6 Additive Operators
    1801. 

  1801. 

  1802.     function parseAdditiveExpression() {
    1803. 

  1803.         var expr = parseMultiplicativeExpression();
    1804. 

  1804. 

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

  1806.             expr = {
    1807. 

  1807.                 type: Syntax.BinaryExpression,
    1808. 

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

  1809.                 left: expr,
    1810. 

  1810.                 right: parseMultiplicativeExpression()
    1811. 

  1811.             };
    1812. 

  1812.         }
    1813. 

  1813. 

  1814.         return expr;
    1815. 

  1815.     }
    1816. 

  1816. 

  1817.     // 11.7 Bitwise Shift Operators
    1818. 

  1818. 

  1819.     function parseShiftExpression() {
    1820. 

  1820.         var expr = parseAdditiveExpression();
    1821. 

  1821. 

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

  1823.             expr = {
    1824. 

  1824.                 type: Syntax.BinaryExpression,
    1825. 

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

  1826.                 left: expr,
    1827. 

  1827.                 right: parseAdditiveExpression()
    1828. 

  1828.             };
    1829. 

  1829.         }
    1830. 

  1830. 

  1831.         return expr;
    1832. 

  1832.     }
    1833. 

  1833.     // 11.8 Relational Operators
    1834. 

  1834. 

  1835.     function parseRelationalExpression() {
    1836. 

  1836.         var expr, previousAllowIn;
    1837. 

  1837. 

  1838.         previousAllowIn = state.allowIn;
    1839. 

  1839.         state.allowIn = true;
    1840. 

  1840. 

  1841.         expr = parseShiftExpression();
    1842. 

  1842. 

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

  1844.             expr = {
    1845. 

  1845.                 type: Syntax.BinaryExpression,
    1846. 

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

  1847.                 left: expr,
    1848. 

  1848.                 right: parseShiftExpression()
    1849. 

  1849.             };
    1850. 

  1850.         }
    1851. 

  1851. 

  1852.         state.allowIn = previousAllowIn;
    1853. 

  1853.         return expr;
    1854. 

  1854.     }
    1855. 

  1855. 

  1856.     // 11.9 Equality Operators
    1857. 

  1857. 

  1858.     function parseEqualityExpression() {
    1859. 

  1859.         var expr = parseRelationalExpression();
    1860. 

  1860. 

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

  1862.             expr = {
    1863. 

  1863.                 type: Syntax.BinaryExpression,
    1864. 

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

  1865.                 left: expr,
    1866. 

  1866.                 right: parseRelationalExpression()
    1867. 

  1867.             };
    1868. 

  1868.         }
    1869. 

  1869. 

  1870.         return expr;
    1871. 

  1871.     }
    1872. 

  1872. 

  1873.     // 11.10 Binary Bitwise Operators
    1874. 

  1874. 

  1875.     function parseBitwiseANDExpression() {
    1876. 

  1876.         var expr = parseEqualityExpression();
    1877. 

  1877. 

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

  1879.             lex();
    1880. 

  1880.             expr = {
    1881. 

  1881.                 type: Syntax.BinaryExpression,
    1882. 

  1882.                 operator: '&',
    1883. 

  1883.                 left: expr,
    1884. 

  1884.                 right: parseEqualityExpression()
    1885. 

  1885.             };
    1886. 

  1886.         }
    1887. 

  1887. 

  1888.         return expr;
    1889. 

  1889.     }
    1890. 

  1890. 

  1891.     function parseBitwiseXORExpression() {
    1892. 

  1892.         var expr = parseBitwiseANDExpression();
    1893. 

  1893. 

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

  1895.             lex();
    1896. 

  1896.             expr = {
    1897. 

  1897.                 type: Syntax.BinaryExpression,
    1898. 

  1898.                 operator: '^',
    1899. 

  1899.                 left: expr,
    1900. 

  1900.                 right: parseBitwiseANDExpression()
    1901. 

  1901.             };
    1902. 

  1902.         }
    1903. 

  1903. 

  1904.         return expr;
    1905. 

  1905.     }
    1906. 

  1906. 

  1907.     function parseBitwiseORExpression() {
    1908. 

  1908.         var expr = parseBitwiseXORExpression();
    1909. 

  1909. 

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

  1911.             lex();
    1912. 

  1912.             expr = {
    1913. 

  1913.                 type: Syntax.BinaryExpression,
    1914. 

  1914.                 operator: '|',
    1915. 

  1915.                 left: expr,
    1916. 

  1916.                 right: parseBitwiseXORExpression()
    1917. 

  1917.             };
    1918. 

  1918.         }
    1919. 

  1919. 

  1920.         return expr;
    1921. 

  1921.     }
    1922. 

  1922. 

  1923.     // 11.11 Binary Logical Operators
    1924. 

  1924. 

  1925.     function parseLogicalANDExpression() {
    1926. 

  1926.         var expr = parseBitwiseORExpression();
    1927. 

  1927. 

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

  1929.             lex();
    1930. 

  1930.             expr = {
    1931. 

  1931.                 type: Syntax.LogicalExpression,
    1932. 

  1932.                 operator: '&&',
    1933. 

  1933.                 left: expr,
    1934. 

  1934.                 right: parseBitwiseORExpression()
    1935. 

  1935.             };
    1936. 

  1936.         }
    1937. 

  1937. 

  1938.         return expr;
    1939. 

  1939.     }
    1940. 

  1940. 

  1941.     function parseLogicalORExpression() {
    1942. 

  1942.         var expr = parseLogicalANDExpression();
    1943. 

  1943. 

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

  1945.             lex();
    1946. 

  1946.             expr = {
    1947. 

  1947.                 type: Syntax.LogicalExpression,
    1948. 

  1948.                 operator: '||',
    1949. 

  1949.                 left: expr,
    1950. 

  1950.                 right: parseLogicalANDExpression()
    1951. 

  1951.             };
    1952. 

  1952.         }
    1953. 

  1953. 

  1954.         return expr;
    1955. 

  1955.     }
    1956. 

  1956. 

  1957.     // 11.12 Conditional Operator
    1958. 

  1958. 

  1959.     function parseConditionalExpression() {
    1960. 

  1960.         var expr, previousAllowIn, consequent;
    1961. 

  1961. 

  1962.         expr = parseLogicalORExpression();
    1963. 

  1963. 

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

  1965.             lex();
    1966. 

  1966.             previousAllowIn = state.allowIn;
    1967. 

  1967.             state.allowIn = true;
    1968. 

  1968.             consequent = parseAssignmentExpression();
    1969. 

  1969.             state.allowIn = previousAllowIn;
    1970. 

  1970.             expect(':');
    1971. 

  1971. 

  1972.             expr = {
    1973. 

  1973.                 type: Syntax.ConditionalExpression,
    1974. 

  1974.                 test: expr,
    1975. 

  1975.                 consequent: consequent,
    1976. 

  1976.                 alternate: parseAssignmentExpression()
    1977. 

  1977.             };
    1978. 

  1978.         }
    1979. 

  1979. 

  1980.         return expr;
    1981. 

  1981.     }
    1982. 

  1982. 

  1983.     // 11.13 Assignment Operators
    1984. 

  1984. 

  1985.     function parseAssignmentExpression() {
    1986. 

  1986.         var token, expr;
    1987. 

  1987. 

  1988.         token = lookahead();
    1989. 

  1989.         expr = parseConditionalExpression();
    1990. 

  1990. 

  1991.         if (matchAssign()) {
    1992. 

  1992.             // LeftHandSideExpression
    1993. 

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

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

  1995.             }
    1996. 

  1996. 

  1997.             // 11.13.1
    1998. 

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

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

  2000.             }
    2001. 

  2001. 

  2002.             expr = {
    2003. 

  2003.                 type: Syntax.AssignmentExpression,
    2004. 

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

  2005.                 left: expr,
    2006. 

  2006.                 right: parseAssignmentExpression()
    2007. 

  2007.             };
    2008. 

  2008.         }
    2009. 

  2009. 

  2010.         return expr;
    2011. 

  2011.     }
    2012. 

  2012. 

  2013.     // 11.14 Comma Operator
    2014. 

  2014. 

  2015.     function parseExpression() {
    2016. 

  2016.         var expr = parseAssignmentExpression();
    2017. 

  2017. 

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

  2019.             expr = {
    2020. 

  2020.                 type: Syntax.SequenceExpression,
    2021. 

  2021.                 expressions: [ expr ]
    2022. 

  2022.             };
    2023. 

  2023. 

  2024.             while (index < length) {
    2025. 

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

  2026.                     break;
    2027. 

  2027.                 }
    2028. 

  2028.                 lex();
    2029. 

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

  2030.             }
    2031. 

  2031. 

  2032.         }
    2033. 

  2033.         return expr;
    2034. 

  2034.     }
    2035. 

  2035. 

  2036.     // 12.1 Block
    2037. 

  2037. 

  2038.     function parseStatementList() {
    2039. 

  2039.         var list = [],
    2040. 

  2040.             statement;
    2041. 

  2041. 

  2042.         while (index < length) {
    2043. 

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

  2044.                 break;
    2045. 

  2045.             }
    2046. 

  2046.             statement = parseSourceElement();
    2047. 

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

  2048.                 break;
    2049. 

  2049.             }
    2050. 

  2050.             list.push(statement);
    2051. 

  2051.         }
    2052. 

  2052. 

  2053.         return list;
    2054. 

  2054.     }
    2055. 

  2055. 

  2056.     function parseBlock() {
    2057. 

  2057.         var block;
    2058. 

  2058. 

  2059.         expect('{');
    2060. 

  2060. 

  2061.         block = parseStatementList();
    2062. 

  2062. 

  2063.         expect('}');
    2064. 

  2064. 

  2065.         return {
    2066. 

  2066.             type: Syntax.BlockStatement,
    2067. 

  2067.             body: block
    2068. 

  2068.         };
    2069. 

  2069.     }
    2070. 

  2070. 

  2071.     // 12.2 Variable Statement
    2072. 

  2072. 

  2073.     function parseVariableIdentifier() {
    2074. 

  2074.         var token = lex();
    2075. 

  2075. 

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

  2077.             throwUnexpected(token);
    2078. 

  2078.         }
    2079. 

  2079. 

  2080.         return {
    2081. 

  2081.             type: Syntax.Identifier,
    2082. 

  2082.             name: token.value
    2083. 

  2083.         };
    2084. 

  2084.     }
    2085. 

  2085. 

  2086.     function parseVariableDeclaration(kind) {
    2087. 

  2087.         var id = parseVariableIdentifier(),
    2088. 

  2088.             init = null;
    2089. 

  2089. 

  2090.         // 12.2.1
    2091. 

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

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

  2093.         }
    2094. 

  2094. 

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

  2096.             expect('=');
    2097. 

  2097.             init = parseAssignmentExpression();
    2098. 

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

  2099.             lex();
    2100. 

  2100.             init = parseAssignmentExpression();
    2101. 

  2101.         }
    2102. 

  2102. 

  2103.         return {
    2104. 

  2104.             type: Syntax.VariableDeclarator,
    2105. 

  2105.             id: id,
    2106. 

  2106.             init: init
    2107. 

  2107.         };
    2108. 

  2108.     }
    2109. 

  2109. 

  2110.     function parseVariableDeclarationList(kind) {
    2111. 

  2111.         var list = [];
    2112. 

  2112. 

  2113.         while (index < length) {
    2114. 

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

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

  2116.                 break;
    2117. 

  2117.             }
    2118. 

  2118.             lex();
    2119. 

  2119.         }
    2120. 

  2120. 

  2121.         return list;
    2122. 

  2122.     }
    2123. 

  2123. 

  2124.     function parseVariableStatement() {
    2125. 

  2125.         var declarations;
    2126. 

  2126. 

  2127.         expectKeyword('var');
    2128. 

  2128. 

  2129.         declarations = parseVariableDeclarationList();
    2130. 

  2130. 

  2131.         consumeSemicolon();
    2132. 

  2132. 

  2133.         return {
    2134. 

  2134.             type: Syntax.VariableDeclaration,
    2135. 

  2135.             declarations: declarations,
    2136. 

  2136.             kind: 'var'
    2137. 

  2137.         };
    2138. 

  2138.     }
    2139. 

  2139. 

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

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

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

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

  2144.     function parseConstLetDeclaration(kind) {
    2145. 

  2145.         var declarations;
    2146. 

  2146. 

  2147.         expectKeyword(kind);
    2148. 

  2148. 

  2149.         declarations = parseVariableDeclarationList(kind);
    2150. 

  2150. 

  2151.         consumeSemicolon();
    2152. 

  2152. 

  2153.         return {
    2154. 

  2154.             type: Syntax.VariableDeclaration,
    2155. 

  2155.             declarations: declarations,
    2156. 

  2156.             kind: kind
    2157. 

  2157.         };
    2158. 

  2158.     }
    2159. 

  2159. 

  2160.     // 12.3 Empty Statement
    2161. 

  2161. 

  2162.     function parseEmptyStatement() {
    2163. 

  2163.         expect(';');
    2164. 

  2164. 

  2165.         return {
    2166. 

  2166.             type: Syntax.EmptyStatement
    2167. 

  2167.         };
    2168. 

  2168.     }
    2169. 

  2169. 

  2170.     // 12.4 Expression Statement
    2171. 

  2171. 

  2172.     function parseExpressionStatement() {
    2173. 

  2173.         var expr = parseExpression();
    2174. 

  2174. 

  2175.         consumeSemicolon();
    2176. 

  2176. 

  2177.         return {
    2178. 

  2178.             type: Syntax.ExpressionStatement,
    2179. 

  2179.             expression: expr
    2180. 

  2180.         };
    2181. 

  2181.     }
    2182. 

  2182. 

  2183.     // 12.5 If statement
    2184. 

  2184. 

  2185.     function parseIfStatement() {
    2186. 

  2186.         var test, consequent, alternate;
    2187. 

  2187. 

  2188.         expectKeyword('if');
    2189. 

  2189. 

  2190.         expect('(');
    2191. 

  2191. 

  2192.         test = parseExpression();
    2193. 

  2193. 

  2194.         expect(')');
    2195. 

  2195. 

  2196.         consequent = parseStatement();
    2197. 

  2197. 

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

  2199.             lex();
    2200. 

  2200.             alternate = parseStatement();
    2201. 

  2201.         } else {
    2202. 

  2202.             alternate = null;
    2203. 

  2203.         }
    2204. 

  2204. 

  2205.         return {
    2206. 

  2206.             type: Syntax.IfStatement,
    2207. 

  2207.             test: test,
    2208. 

  2208.             consequent: consequent,
    2209. 

  2209.             alternate: alternate
    2210. 

  2210.         };
    2211. 

  2211.     }
    2212. 

  2212. 

  2213.     // 12.6 Iteration Statements
    2214. 

  2214. 

  2215.     function parseDoWhileStatement() {
    2216. 

  2216.         var body, test, oldInIteration;
    2217. 

  2217. 

  2218.         expectKeyword('do');
    2219. 

  2219. 

  2220.         oldInIteration = state.inIteration;
    2221. 

  2221.         state.inIteration = true;
    2222. 

  2222. 

  2223.         body = parseStatement();
    2224. 

  2224. 

  2225.         state.inIteration = oldInIteration;
    2226. 

  2226. 

  2227.         expectKeyword('while');
    2228. 

  2228. 

  2229.         expect('(');
    2230. 

  2230. 

  2231.         test = parseExpression();
    2232. 

  2232. 

  2233.         expect(')');
    2234. 

  2234. 

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

  2236.             lex();
    2237. 

  2237.         }
    2238. 

  2238. 

  2239.         return {
    2240. 

  2240.             type: Syntax.DoWhileStatement,
    2241. 

  2241.             body: body,
    2242. 

  2242.             test: test
    2243. 

  2243.         };
    2244. 

  2244.     }
    2245. 

  2245. 

  2246.     function parseWhileStatement() {
    2247. 

  2247.         var test, body, oldInIteration;
    2248. 

  2248. 

  2249.         expectKeyword('while');
    2250. 

  2250. 

  2251.         expect('(');
    2252. 

  2252. 

  2253.         test = parseExpression();
    2254. 

  2254. 

  2255.         expect(')');
    2256. 

  2256. 

  2257.         oldInIteration = state.inIteration;
    2258. 

  2258.         state.inIteration = true;
    2259. 

  2259. 

  2260.         body = parseStatement();
    2261. 

  2261. 

  2262.         state.inIteration = oldInIteration;
    2263. 

  2263. 

  2264.         return {
    2265. 

  2265.             type: Syntax.WhileStatement,
    2266. 

  2266.             test: test,
    2267. 

  2267.             body: body
    2268. 

  2268.         };
    2269. 

  2269.     }
    2270. 

  2270. 

  2271.     function parseForVariableDeclaration() {
    2272. 

  2272.         var token = lex();
    2273. 

  2273. 

  2274.         return {
    2275. 

  2275.             type: Syntax.VariableDeclaration,
    2276. 

  2276.             declarations: parseVariableDeclarationList(),
    2277. 

  2277.             kind: token.value
    2278. 

  2278.         };
    2279. 

  2279.     }
    2280. 

  2280. 

  2281.     function parseForStatement() {
    2282. 

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

  2283. 

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

  2285. 

  2286.         expectKeyword('for');
    2287. 

  2287. 

  2288.         expect('(');
    2289. 

  2289. 

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

  2291.             lex();
    2292. 

  2292.         } else {
    2293. 

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

  2294.                 state.allowIn = false;
    2295. 

  2295.                 init = parseForVariableDeclaration();
    2296. 

  2296.                 state.allowIn = true;
    2297. 

  2297. 

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

  2299.                     lex();
    2300. 

  2300.                     left = init;
    2301. 

  2301.                     right = parseExpression();
    2302. 

  2302.                     init = null;
    2303. 

  2303.                 }
    2304. 

  2304.             } else {
    2305. 

  2305.                 state.allowIn = false;
    2306. 

  2306.                 init = parseExpression();
    2307. 

  2307.                 state.allowIn = true;
    2308. 

  2308. 

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

  2310.                     // LeftHandSideExpression
    2311. 

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

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

  2313.                     }
    2314. 

  2314. 

  2315.                     lex();
    2316. 

  2316.                     left = init;
    2317. 

  2317.                     right = parseExpression();
    2318. 

  2318.                     init = null;
    2319. 

  2319.                 }
    2320. 

  2320.             }
    2321. 

  2321. 

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

  2323.                 expect(';');
    2324. 

  2324.             }
    2325. 

  2325.         }
    2326. 

  2326. 

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

  2328. 

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

  2330.                 test = parseExpression();
    2331. 

  2331.             }
    2332. 

  2332.             expect(';');
    2333. 

  2333. 

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

  2335.                 update = parseExpression();
    2336. 

  2336.             }
    2337. 

  2337.         }
    2338. 

  2338. 

  2339.         expect(')');
    2340. 

  2340. 

  2341.         oldInIteration = state.inIteration;
    2342. 

  2342.         state.inIteration = true;
    2343. 

  2343. 

  2344.         body = parseStatement();
    2345. 

  2345. 

  2346.         state.inIteration = oldInIteration;
    2347. 

  2347. 

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

  2349.             return {
    2350. 

  2350.                 type: Syntax.ForStatement,
    2351. 

  2351.                 init: init,
    2352. 

  2352.                 test: test,
    2353. 

  2353.                 update: update,
    2354. 

  2354.                 body: body
    2355. 

  2355.             };
    2356. 

  2356.         }
    2357. 

  2357. 

  2358.         return {
    2359. 

  2359.             type: Syntax.ForInStatement,
    2360. 

  2360.             left: left,
    2361. 

  2361.             right: right,
    2362. 

  2362.             body: body,
    2363. 

  2363.             each: false
    2364. 

  2364.         };
    2365. 

  2365.     }
    2366. 

  2366. 

  2367.     // 12.7 The continue statement
    2368. 

  2368. 

  2369.     function parseContinueStatement() {
    2370. 

  2370.         var token, label = null;
    2371. 

  2371. 

  2372.         expectKeyword('continue');
    2373. 

  2373. 

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

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

  2376.             lex();
    2377. 

  2377. 

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

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

  2380.             }
    2381. 

  2381. 

  2382.             return {
    2383. 

  2383.                 type: Syntax.ContinueStatement,
    2384. 

  2384.                 label: null
    2385. 

  2385.             };
    2386. 

  2386.         }
    2387. 

  2387. 

  2388.         if (peekLineTerminator()) {
    2389. 

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

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

  2391.             }
    2392. 

  2392. 

  2393.             return {
    2394. 

  2394.                 type: Syntax.ContinueStatement,
    2395. 

  2395.                 label: null
    2396. 

  2396.             };
    2397. 

  2397.         }
    2398. 

  2398. 

  2399.         token = lookahead();
    2400. 

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

  2401.             label = parseVariableIdentifier();
    2402. 

  2402. 

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

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

  2405.             }
    2406. 

  2406.         }
    2407. 

  2407. 

  2408.         consumeSemicolon();
    2409. 

  2409. 

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

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

  2412.         }
    2413. 

  2413. 

  2414.         return {
    2415. 

  2415.             type: Syntax.ContinueStatement,
    2416. 

  2416.             label: label
    2417. 

  2417.         };
    2418. 

  2418.     }
    2419. 

  2419. 

  2420.     // 12.8 The break statement
    2421. 

  2421. 

  2422.     function parseBreakStatement() {
    2423. 

  2423.         var token, label = null;
    2424. 

  2424. 

  2425.         expectKeyword('break');
    2426. 

  2426. 

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

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

  2429.             lex();
    2430. 

  2430. 

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

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

  2433.             }
    2434. 

  2434. 

  2435.             return {
    2436. 

  2436.                 type: Syntax.BreakStatement,
    2437. 

  2437.                 label: null
    2438. 

  2438.             };
    2439. 

  2439.         }
    2440. 

  2440. 

  2441.         if (peekLineTerminator()) {
    2442. 

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

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

  2444.             }
    2445. 

  2445. 

  2446.             return {
    2447. 

  2447.                 type: Syntax.BreakStatement,
    2448. 

  2448.                 label: null
    2449. 

  2449.             };
    2450. 

  2450.         }
    2451. 

  2451. 

  2452.         token = lookahead();
    2453. 

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

  2454.             label = parseVariableIdentifier();
    2455. 

  2455. 

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

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

  2458.             }
    2459. 

  2459.         }
    2460. 

  2460. 

  2461.         consumeSemicolon();
    2462. 

  2462. 

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

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

  2465.         }
    2466. 

  2466. 

  2467.         return {
    2468. 

  2468.             type: Syntax.BreakStatement,
    2469. 

  2469.             label: label
    2470. 

  2470.         };
    2471. 

  2471.     }
    2472. 

  2472. 

  2473.     // 12.9 The return statement
    2474. 

  2474. 

  2475.     function parseReturnStatement() {
    2476. 

  2476.         var token, argument = null;
    2477. 

  2477. 

  2478.         expectKeyword('return');
    2479. 

  2479. 

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

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

  2482.         }
    2483. 

  2483. 

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

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

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

  2487.                 argument = parseExpression();
    2488. 

  2488.                 consumeSemicolon();
    2489. 

  2489.                 return {
    2490. 

  2490.                     type: Syntax.ReturnStatement,
    2491. 

  2491.                     argument: argument
    2492. 

  2492.                 };
    2493. 

  2493.             }
    2494. 

  2494.         }
    2495. 

  2495. 

  2496.         if (peekLineTerminator()) {
    2497. 

  2497.             return {
    2498. 

  2498.                 type: Syntax.ReturnStatement,
    2499. 

  2499.                 argument: null
    2500. 

  2500.             };
    2501. 

  2501.         }
    2502. 

  2502. 

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

  2504.             token = lookahead();
    2505. 

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

  2506.                 argument = parseExpression();
    2507. 

  2507.             }
    2508. 

  2508.         }
    2509. 

  2509. 

  2510.         consumeSemicolon();
    2511. 

  2511. 

  2512.         return {
    2513. 

  2513.             type: Syntax.ReturnStatement,
    2514. 

  2514.             argument: argument
    2515. 

  2515.         };
    2516. 

  2516.     }
    2517. 

  2517. 

  2518.     // 12.10 The with statement
    2519. 

  2519. 

  2520.     function parseWithStatement() {
    2521. 

  2521.         var object, body;
    2522. 

  2522. 

  2523.         if (strict) {
    2524. 

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

  2525.         }
    2526. 

  2526. 

  2527.         expectKeyword('with');
    2528. 

  2528. 

  2529.         expect('(');
    2530. 

  2530. 

  2531.         object = parseExpression();
    2532. 

  2532. 

  2533.         expect(')');
    2534. 

  2534. 

  2535.         body = parseStatement();
    2536. 

  2536. 

  2537.         return {
    2538. 

  2538.             type: Syntax.WithStatement,
    2539. 

  2539.             object: object,
    2540. 

  2540.             body: body
    2541. 

  2541.         };
    2542. 

  2542.     }
    2543. 

  2543. 

  2544.     // 12.10 The swith statement
    2545. 

  2545. 

  2546.     function parseSwitchCase() {
    2547. 

  2547.         var test,
    2548. 

  2548.             consequent = [],
    2549. 

  2549.             statement;
    2550. 

  2550. 

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

  2552.             lex();
    2553. 

  2553.             test = null;
    2554. 

  2554.         } else {
    2555. 

  2555.             expectKeyword('case');
    2556. 

  2556.             test = parseExpression();
    2557. 

  2557.         }
    2558. 

  2558.         expect(':');
    2559. 

  2559. 

  2560.         while (index < length) {
    2561. 

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

  2562.                 break;
    2563. 

  2563.             }
    2564. 

  2564.             statement = parseStatement();
    2565. 

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

  2566.                 break;
    2567. 

  2567.             }
    2568. 

  2568.             consequent.push(statement);
    2569. 

  2569.         }
    2570. 

  2570. 

  2571.         return {
    2572. 

  2572.             type: Syntax.SwitchCase,
    2573. 

  2573.             test: test,
    2574. 

  2574.             consequent: consequent
    2575. 

  2575.         };
    2576. 

  2576.     }
    2577. 

  2577. 

  2578.     function parseSwitchStatement() {
    2579. 

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

  2580. 

  2581.         expectKeyword('switch');
    2582. 

  2582. 

  2583.         expect('(');
    2584. 

  2584. 

  2585.         discriminant = parseExpression();
    2586. 

  2586. 

  2587.         expect(')');
    2588. 

  2588. 

  2589.         expect('{');
    2590. 

  2590. 

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

  2592.             lex();
    2593. 

  2593.             return {
    2594. 

  2594.                 type: Syntax.SwitchStatement,
    2595. 

  2595.                 discriminant: discriminant
    2596. 

  2596.             };
    2597. 

  2597.         }
    2598. 

  2598. 

  2599.         cases = [];
    2600. 

  2600. 

  2601.         oldInSwitch = state.inSwitch;
    2602. 

  2602.         state.inSwitch = true;
    2603. 

  2603.         defaultFound = false;
    2604. 

  2604. 

  2605.         while (index < length) {
    2606. 

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

  2607.                 break;
    2608. 

  2608.             }
    2609. 

  2609.             clause = parseSwitchCase();
    2610. 

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

  2611.                 if (defaultFound) {
    2612. 

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

  2613.                 }
    2614. 

  2614.                 defaultFound = true;
    2615. 

  2615.             }
    2616. 

  2616.             cases.push(clause);
    2617. 

  2617.         }
    2618. 

  2618. 

  2619.         state.inSwitch = oldInSwitch;
    2620. 

  2620. 

  2621.         expect('}');
    2622. 

  2622. 

  2623.         return {
    2624. 

  2624.             type: Syntax.SwitchStatement,
    2625. 

  2625.             discriminant: discriminant,
    2626. 

  2626.             cases: cases
    2627. 

  2627.         };
    2628. 

  2628.     }
    2629. 

  2629. 

  2630.     // 12.13 The throw statement
    2631. 

  2631. 

  2632.     function parseThrowStatement() {
    2633. 

  2633.         var argument;
    2634. 

  2634. 

  2635.         expectKeyword('throw');
    2636. 

  2636. 

  2637.         if (peekLineTerminator()) {
    2638. 

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

  2639.         }
    2640. 

  2640. 

  2641.         argument = parseExpression();
    2642. 

  2642. 

  2643.         consumeSemicolon();
    2644. 

  2644. 

  2645.         return {
    2646. 

  2646.             type: Syntax.ThrowStatement,
    2647. 

  2647.             argument: argument
    2648. 

  2648.         };
    2649. 

  2649.     }
    2650. 

  2650. 

  2651.     // 12.14 The try statement
    2652. 

  2652. 

  2653.     function parseCatchClause() {
    2654. 

  2654.         var param;
    2655. 

  2655. 

  2656.         expectKeyword('catch');
    2657. 

  2657. 

  2658.         expect('(');
    2659. 

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

  2660.             param = parseExpression();
    2661. 

  2661.             // 12.14.1
    2662. 

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

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

  2664.             }
    2665. 

  2665.         }
    2666. 

  2666.         expect(')');
    2667. 

  2667. 

  2668.         return {
    2669. 

  2669.             type: Syntax.CatchClause,
    2670. 

  2670.             param: param,
    2671. 

  2671.             body: parseBlock()
    2672. 

  2672.         };
    2673. 

  2673.     }
    2674. 

  2674. 

  2675.     function parseTryStatement() {
    2676. 

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

  2677. 

  2678.         expectKeyword('try');
    2679. 

  2679. 

  2680.         block = parseBlock();
    2681. 

  2681. 

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

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

  2684.         }
    2685. 

  2685. 

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

  2687.             lex();
    2688. 

  2688.             finalizer = parseBlock();
    2689. 

  2689.         }
    2690. 

  2690. 

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

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

  2693.         }
    2694. 

  2694. 

  2695.         return {
    2696. 

  2696.             type: Syntax.TryStatement,
    2697. 

  2697.             block: block,
    2698. 

  2698.             guardedHandlers: [],
    2699. 

  2699.             handlers: handlers,
    2700. 

  2700.             finalizer: finalizer
    2701. 

  2701.         };
    2702. 

  2702.     }
    2703. 

  2703. 

  2704.     // 12.15 The debugger statement
    2705. 

  2705. 

  2706.     function parseDebuggerStatement() {
    2707. 

  2707.         expectKeyword('debugger');
    2708. 

  2708. 

  2709.         consumeSemicolon();
    2710. 

  2710. 

  2711.         return {
    2712. 

  2712.             type: Syntax.DebuggerStatement
    2713. 

  2713.         };
    2714. 

  2714.     }
    2715. 

  2715. 

  2716.     // 12 Statements
    2717. 

  2717. 

  2718.     function parseStatement() {
    2719. 

  2719.         var token = lookahead(),
    2720. 

  2720.             expr,
    2721. 

  2721.             labeledBody;
    2722. 

  2722. 

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

  2724.             throwUnexpected(token);
    2725. 

  2725.         }
    2726. 

  2726. 

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

  2728.             switch (token.value) {
    2729. 

  2729.             case ';':
    2730. 

  2730.                 return parseEmptyStatement();
    2731. 

  2731.             case '{':
    2732. 

  2732.                 return parseBlock();
    2733. 

  2733.             case '(':
    2734. 

  2734.                 return parseExpressionStatement();
    2735. 

  2735.             default:
    2736. 

  2736.                 break;
    2737. 

  2737.             }
    2738. 

  2738.         }
    2739. 

  2739. 

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

  2741.             switch (token.value) {
    2742. 

  2742.             case 'break':
    2743. 

  2743.                 return parseBreakStatement();
    2744. 

  2744.             case 'continue':
    2745. 

  2745.                 return parseContinueStatement();
    2746. 

  2746.             case 'debugger':
    2747. 

  2747.                 return parseDebuggerStatement();
    2748. 

  2748.             case 'do':
    2749. 

  2749.                 return parseDoWhileStatement();
    2750. 

  2750.             case 'for':
    2751. 

  2751.                 return parseForStatement();
    2752. 

  2752.             case 'function':
    2753. 

  2753.                 return parseFunctionDeclaration();
    2754. 

  2754.             case 'if':
    2755. 

  2755.                 return parseIfStatement();
    2756. 

  2756.             case 'return':
    2757. 

  2757.                 return parseReturnStatement();
    2758. 

  2758.             case 'switch':
    2759. 

  2759.                 return parseSwitchStatement();
    2760. 

  2760.             case 'throw':
    2761. 

  2761.                 return parseThrowStatement();
    2762. 

  2762.             case 'try':
    2763. 

  2763.                 return parseTryStatement();
    2764. 

  2764.             case 'var':
    2765. 

  2765.                 return parseVariableStatement();
    2766. 

  2766.             case 'while':
    2767. 

  2767.                 return parseWhileStatement();
    2768. 

  2768.             case 'with':
    2769. 

  2769.                 return parseWithStatement();
    2770. 

  2770.             default:
    2771. 

  2771.                 break;
    2772. 

  2772.             }
    2773. 

  2773.         }
    2774. 

  2774. 

  2775.         expr = parseExpression();
    2776. 

  2776. 

  2777.         // 12.12 Labelled Statements
    2778. 

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

  2779.             lex();
    2780. 

  2780. 

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

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

  2783.             }
    2784. 

  2784. 

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

  2786.             labeledBody = parseStatement();
    2787. 

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

  2788. 

  2789.             return {
    2790. 

  2790.                 type: Syntax.LabeledStatement,
    2791. 

  2791.                 label: expr,
    2792. 

  2792.                 body: labeledBody
    2793. 

  2793.             };
    2794. 

  2794.         }
    2795. 

  2795. 

  2796.         consumeSemicolon();
    2797. 

  2797. 

  2798.         return {
    2799. 

  2799.             type: Syntax.ExpressionStatement,
    2800. 

  2800.             expression: expr
    2801. 

  2801.         };
    2802. 

  2802.     }
    2803. 

  2803. 

  2804.     // 13 Function Definition
    2805. 

  2805. 

  2806.     function parseFunctionSourceElements() {
    2807. 

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

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

  2809. 

  2810.         expect('{');
    2811. 

  2811. 

  2812.         while (index < length) {
    2813. 

  2813.             token = lookahead();
    2814. 

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

  2815.                 break;
    2816. 

  2816.             }
    2817. 

  2817. 

  2818.             sourceElement = parseSourceElement();
    2819. 

  2819.             sourceElements.push(sourceElement);
    2820. 

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

  2821.                 // this is not directive
    2822. 

  2822.                 break;
    2823. 

  2823.             }
    2824. 

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

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

  2826.                 strict = true;
    2827. 

  2827.                 if (firstRestricted) {
    2828. 

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

  2829.                 }
    2830. 

  2830.             } else {
    2831. 

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

  2832.                     firstRestricted = token;
    2833. 

  2833.                 }
    2834. 

  2834.             }
    2835. 

  2835.         }
    2836. 

  2836. 

  2837.         oldLabelSet = state.labelSet;
    2838. 

  2838.         oldInIteration = state.inIteration;
    2839. 

  2839.         oldInSwitch = state.inSwitch;
    2840. 

  2840.         oldInFunctionBody = state.inFunctionBody;
    2841. 

  2841. 

  2842.         state.labelSet = {};
    2843. 

  2843.         state.inIteration = false;
    2844. 

  2844.         state.inSwitch = false;
    2845. 

  2845.         state.inFunctionBody = true;
    2846. 

  2846. 

  2847.         while (index < length) {
    2848. 

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

  2849.                 break;
    2850. 

  2850.             }
    2851. 

  2851.             sourceElement = parseSourceElement();
    2852. 

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

  2853.                 break;
    2854. 

  2854.             }
    2855. 

  2855.             sourceElements.push(sourceElement);
    2856. 

  2856.         }
    2857. 

  2857. 

  2858.         expect('}');
    2859. 

  2859. 

  2860.         state.labelSet = oldLabelSet;
    2861. 

  2861.         state.inIteration = oldInIteration;
    2862. 

  2862.         state.inSwitch = oldInSwitch;
    2863. 

  2863.         state.inFunctionBody = oldInFunctionBody;
    2864. 

  2864. 

  2865.         return {
    2866. 

  2866.             type: Syntax.BlockStatement,
    2867. 

  2867.             body: sourceElements
    2868. 

  2868.         };
    2869. 

  2869.     }
    2870. 

  2870. 

  2871.     function parseFunctionDeclaration() {
    2872. 

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

  2873. 

  2874.         expectKeyword('function');
    2875. 

  2875.         token = lookahead();
    2876. 

  2876.         id = parseVariableIdentifier();
    2877. 

  2877.         if (strict) {
    2878. 

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

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

  2880.             }
    2881. 

  2881.         } else {
    2882. 

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

  2883.                 firstRestricted = token;
    2884. 

  2884.                 message = Messages.StrictFunctionName;
    2885. 

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

  2886.                 firstRestricted = token;
    2887. 

  2887.                 message = Messages.StrictReservedWord;
    2888. 

  2888.             }
    2889. 

  2889.         }
    2890. 

  2890. 

  2891.         expect('(');
    2892. 

  2892. 

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

  2894.             paramSet = {};
    2895. 

  2895.             while (index < length) {
    2896. 

  2896.                 token = lookahead();
    2897. 

  2897.                 param = parseVariableIdentifier();
    2898. 

  2898.                 if (strict) {
    2899. 

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

  2900.                         stricted = token;
    2901. 

  2901.                         message = Messages.StrictParamName;
    2902. 

  2902.                     }
    2903. 

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

  2904.                         stricted = token;
    2905. 

  2905.                         message = Messages.StrictParamDupe;
    2906. 

  2906.                     }
    2907. 

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

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

  2909.                         firstRestricted = token;
    2910. 

  2910.                         message = Messages.StrictParamName;
    2911. 

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

  2912.                         firstRestricted = token;
    2913. 

  2913.                         message = Messages.StrictReservedWord;
    2914. 

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

  2915.                         firstRestricted = token;
    2916. 

  2916.                         message = Messages.StrictParamDupe;
    2917. 

  2917.                     }
    2918. 

  2918.                 }
    2919. 

  2919.                 params.push(param);
    2920. 

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

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

  2922.                     break;
    2923. 

  2923.                 }
    2924. 

  2924.                 expect(',');
    2925. 

  2925.             }
    2926. 

  2926.         }
    2927. 

  2927. 

  2928.         expect(')');
    2929. 

  2929. 

  2930.         previousStrict = strict;
    2931. 

  2931.         body = parseFunctionSourceElements();
    2932. 

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

  2933.             throwError(firstRestricted, message);
    2934. 

  2934.         }
    2935. 

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

  2936.             throwErrorTolerant(stricted, message);
    2937. 

  2937.         }
    2938. 

  2938.         strict = previousStrict;
    2939. 

  2939. 

  2940.         return {
    2941. 

  2941.             type: Syntax.FunctionDeclaration,
    2942. 

  2942.             id: id,
    2943. 

  2943.             params: params,
    2944. 

  2944.             defaults: [],
    2945. 

  2945.             body: body,
    2946. 

  2946.             rest: null,
    2947. 

  2947.             generator: false,
    2948. 

  2948.             expression: false
    2949. 

  2949.         };
    2950. 

  2950.     }
    2951. 

  2951. 

  2952.     function parseFunctionExpression() {
    2953. 

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

  2954. 

  2955.         expectKeyword('function');
    2956. 

  2956. 

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

  2958.             token = lookahead();
    2959. 

  2959.             id = parseVariableIdentifier();
    2960. 

  2960.             if (strict) {
    2961. 

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

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

  2963.                 }
    2964. 

  2964.             } else {
    2965. 

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

  2966.                     firstRestricted = token;
    2967. 

  2967.                     message = Messages.StrictFunctionName;
    2968. 

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

  2969.                     firstRestricted = token;
    2970. 

  2970.                     message = Messages.StrictReservedWord;
    2971. 

  2971.                 }
    2972. 

  2972.             }
    2973. 

  2973.         }
    2974. 

  2974. 

  2975.         expect('(');
    2976. 

  2976. 

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

  2978.             paramSet = {};
    2979. 

  2979.             while (index < length) {
    2980. 

  2980.                 token = lookahead();
    2981. 

  2981.                 param = parseVariableIdentifier();
    2982. 

  2982.                 if (strict) {
    2983. 

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

  2984.                         stricted = token;
    2985. 

  2985.                         message = Messages.StrictParamName;
    2986. 

  2986.                     }
    2987. 

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

  2988.                         stricted = token;
    2989. 

  2989.                         message = Messages.StrictParamDupe;
    2990. 

  2990.                     }
    2991. 

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

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

  2993.                         firstRestricted = token;
    2994. 

  2994.                         message = Messages.StrictParamName;
    2995. 

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

  2996.                         firstRestricted = token;
    2997. 

  2997.                         message = Messages.StrictReservedWord;
    2998. 

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

  2999.                         firstRestricted = token;
    3000. 

  3000.                         message = Messages.StrictParamDupe;
    3001. 

  3001.                     }
    3002. 

  3002.                 }
    3003. 

  3003.                 params.push(param);
    3004. 

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

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

  3006.                     break;
    3007. 

  3007.                 }
    3008. 

  3008.                 expect(',');
    3009. 

  3009.             }
    3010. 

  3010.         }
    3011. 

  3011. 

  3012.         expect(')');
    3013. 

  3013. 

  3014.         previousStrict = strict;
    3015. 

  3015.         body = parseFunctionSourceElements();
    3016. 

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

  3017.             throwError(firstRestricted, message);
    3018. 

  3018.         }
    3019. 

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

  3020.             throwErrorTolerant(stricted, message);
    3021. 

  3021.         }
    3022. 

  3022.         strict = previousStrict;
    3023. 

  3023. 

  3024.         return {
    3025. 

  3025.             type: Syntax.FunctionExpression,
    3026. 

  3026.             id: id,
    3027. 

  3027.             params: params,
    3028. 

  3028.             defaults: [],
    3029. 

  3029.             body: body,
    3030. 

  3030.             rest: null,
    3031. 

  3031.             generator: false,
    3032. 

  3032.             expression: false
    3033. 

  3033.         };
    3034. 

  3034.     }
    3035. 

  3035. 

  3036.     // 14 Program
    3037. 

  3037. 

  3038.     function parseSourceElement() {
    3039. 

  3039.         var token = lookahead();
    3040. 

  3040. 

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

  3042.             switch (token.value) {
    3043. 

  3043.             case 'const':
    3044. 

  3044.             case 'let':
    3045. 

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

  3046.             case 'function':
    3047. 

  3047.                 return parseFunctionDeclaration();
    3048. 

  3048.             default:
    3049. 

  3049.                 return parseStatement();
    3050. 

  3050.             }
    3051. 

  3051.         }
    3052. 

  3052. 

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

  3054.             return parseStatement();
    3055. 

  3055.         }
    3056. 

  3056.     }
    3057. 

  3057. 

  3058.     function parseSourceElements() {
    3059. 

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

  3060. 

  3061.         while (index < length) {
    3062. 

  3062.             token = lookahead();
    3063. 

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

  3064.                 break;
    3065. 

  3065.             }
    3066. 

  3066. 

  3067.             sourceElement = parseSourceElement();
    3068. 

  3068.             sourceElements.push(sourceElement);
    3069. 

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

  3070.                 // this is not directive
    3071. 

  3071.                 break;
    3072. 

  3072.             }
    3073. 

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

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

  3075.                 strict = true;
    3076. 

  3076.                 if (firstRestricted) {
    3077. 

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

  3078.                 }
    3079. 

  3079.             } else {
    3080. 

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

  3081.                     firstRestricted = token;
    3082. 

  3082.                 }
    3083. 

  3083.             }
    3084. 

  3084.         }
    3085. 

  3085. 

  3086.         while (index < length) {
    3087. 

  3087.             sourceElement = parseSourceElement();
    3088. 

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

  3089.                 break;
    3090. 

  3090.             }
    3091. 

  3091.             sourceElements.push(sourceElement);
    3092. 

  3092.         }
    3093. 

  3093.         return sourceElements;
    3094. 

  3094.     }
    3095. 

  3095. 

  3096.     function parseProgram() {
    3097. 

  3097.         var program;
    3098. 

  3098.         strict = false;
    3099. 

  3099.         program = {
    3100. 

  3100.             type: Syntax.Program,
    3101. 

  3101.             body: parseSourceElements()
    3102. 

  3102.         };
    3103. 

  3103.         return program;
    3104. 

  3104.     }
    3105. 

  3105. 

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

  3107.     // the comments is active.
    3108. 

  3108. 

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

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

  3111. 

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

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

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

  3115.         // handled it.
    3116. 

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

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

  3118.                 return;
    3119. 

  3119.             }
    3120. 

  3120.         }
    3121. 

  3121. 

  3122.         extra.comments.push({
    3123. 

  3123.             type: type,
    3124. 

  3124.             value: value,
    3125. 

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

  3126.             loc: loc
    3127. 

  3127.         });
    3128. 

  3128.     }
    3129. 

  3129. 

  3130.     function scanComment() {
    3131. 

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

  3132. 

  3133.         comment = '';
    3134. 

  3134.         blockComment = false;
    3135. 

  3135.         lineComment = false;
    3136. 

  3136. 

  3137.         while (index < length) {
    3138. 

  3138.             ch = source[index];
    3139. 

  3139. 

  3140.             if (lineComment) {
    3141. 

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

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

  3143.                     loc.end = {
    3144. 

  3144.                         line: lineNumber,
    3145. 

  3145.                         column: index - lineStart - 1
    3146. 

  3146.                     };
    3147. 

  3147.                     lineComment = false;
    3148. 

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

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

  3150.                         ++index;
    3151. 

  3151.                     }
    3152. 

  3152.                     ++lineNumber;
    3153. 

  3153.                     lineStart = index;
    3154. 

  3154.                     comment = '';
    3155. 

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

  3156.                     lineComment = false;
    3157. 

  3157.                     comment += ch;
    3158. 

  3158.                     loc.end = {
    3159. 

  3159.                         line: lineNumber,
    3160. 

  3160.                         column: length - lineStart
    3161. 

  3161.                     };
    3162. 

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

  3163.                 } else {
    3164. 

  3164.                     comment += ch;
    3165. 

  3165.                 }
    3166. 

  3166.             } else if (blockComment) {
    3167. 

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

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

  3169.                         ++index;
    3170. 

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

  3171.                     } else {
    3172. 

  3172.                         comment += ch;
    3173. 

  3173.                     }
    3174. 

  3174.                     ++lineNumber;
    3175. 

  3175.                     ++index;
    3176. 

  3176.                     lineStart = index;
    3177. 

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

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

  3179.                     }
    3180. 

  3180.                 } else {
    3181. 

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

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

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

  3184.                     }
    3185. 

  3185.                     comment += ch;
    3186. 

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

  3187.                         ch = source[index];
    3188. 

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

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

  3190.                             blockComment = false;
    3191. 

  3191.                             ++index;
    3192. 

  3192.                             loc.end = {
    3193. 

  3193.                                 line: lineNumber,
    3194. 

  3194.                                 column: index - lineStart
    3195. 

  3195.                             };
    3196. 

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

  3197.                             comment = '';
    3198. 

  3198.                         }
    3199. 

  3199.                     }
    3200. 

  3200.                 }
    3201. 

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

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

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

  3204.                     loc = {
    3205. 

  3205.                         start: {
    3206. 

  3206.                             line: lineNumber,
    3207. 

  3207.                             column: index - lineStart
    3208. 

  3208.                         }
    3209. 

  3209.                     };
    3210. 

  3210.                     start = index;
    3211. 

  3211.                     index += 2;
    3212. 

  3212.                     lineComment = true;
    3213. 

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

  3214.                         loc.end = {
    3215. 

  3215.                             line: lineNumber,
    3216. 

  3216.                             column: index - lineStart
    3217. 

  3217.                         };
    3218. 

  3218.                         lineComment = false;
    3219. 

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

  3220.                     }
    3221. 

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

  3222.                     start = index;
    3223. 

  3223.                     index += 2;
    3224. 

  3224.                     blockComment = true;
    3225. 

  3225.                     loc = {
    3226. 

  3226.                         start: {
    3227. 

  3227.                             line: lineNumber,
    3228. 

  3228.                             column: index - lineStart - 2
    3229. 

  3229.                         }
    3230. 

  3230.                     };
    3231. 

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

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

  3233.                     }
    3234. 

  3234.                 } else {
    3235. 

  3235.                     break;
    3236. 

  3236.                 }
    3237. 

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

  3238.                 ++index;
    3239. 

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

  3240.                 ++index;
    3241. 

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

  3242.                     ++index;
    3243. 

  3243.                 }
    3244. 

  3244.                 ++lineNumber;
    3245. 

  3245.                 lineStart = index;
    3246. 

  3246.             } else {
    3247. 

  3247.                 break;
    3248. 

  3248.             }
    3249. 

  3249.         }
    3250. 

  3250.     }
    3251. 

  3251. 

  3252.     function filterCommentLocation() {
    3253. 

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

  3254. 

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

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

  3257.             comment = {
    3258. 

  3258.                 type: entry.type,
    3259. 

  3259.                 value: entry.value
    3260. 

  3260.             };
    3261. 

  3261.             if (extra.range) {
    3262. 

  3262.                 comment.range = entry.range;
    3263. 

  3263.             }
    3264. 

  3264.             if (extra.loc) {
    3265. 

  3265.                 comment.loc = entry.loc;
    3266. 

  3266.             }
    3267. 

  3267.             comments.push(comment);
    3268. 

  3268.         }
    3269. 

  3269. 

  3270.         extra.comments = comments;
    3271. 

  3271.     }
    3272. 

  3272. 

  3273.     function collectToken() {
    3274. 

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

  3275. 

  3276.         skipComment();
    3277. 

  3277.         start = index;
    3278. 

  3278.         loc = {
    3279. 

  3279.             start: {
    3280. 

  3280.                 line: lineNumber,
    3281. 

  3281.                 column: index - lineStart
    3282. 

  3282.             }
    3283. 

  3283.         };
    3284. 

  3284. 

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

  3286.         loc.end = {
    3287. 

  3287.             line: lineNumber,
    3288. 

  3288.             column: index - lineStart
    3289. 

  3289.         };
    3290. 

  3290. 

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

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

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

  3294.             extra.tokens.push({
    3295. 

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

  3296.                 value: value,
    3297. 

  3297.                 range: range,
    3298. 

  3298.                 loc: loc
    3299. 

  3299.             });
    3300. 

  3300.         }
    3301. 

  3301. 

  3302.         return token;
    3303. 

  3303.     }
    3304. 

  3304. 

  3305.     function collectRegex() {
    3306. 

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

  3307. 

  3308.         skipComment();
    3309. 

  3309. 

  3310.         pos = index;
    3311. 

  3311.         loc = {
    3312. 

  3312.             start: {
    3313. 

  3313.                 line: lineNumber,
    3314. 

  3314.                 column: index - lineStart
    3315. 

  3315.             }
    3316. 

  3316.         };
    3317. 

  3317. 

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

  3319.         loc.end = {
    3320. 

  3320.             line: lineNumber,
    3321. 

  3321.             column: index - lineStart
    3322. 

  3322.         };
    3323. 

  3323. 

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

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

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

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

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

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

  3330.                 }
    3331. 

  3331.             }
    3332. 

  3332.         }
    3333. 

  3333. 

  3334.         extra.tokens.push({
    3335. 

  3335.             type: 'RegularExpression',
    3336. 

  3336.             value: regex.literal,
    3337. 

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

  3338.             loc: loc
    3339. 

  3339.         });
    3340. 

  3340. 

  3341.         return regex;
    3342. 

  3342.     }
    3343. 

  3343. 

  3344.     function filterTokenLocation() {
    3345. 

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

  3346. 

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

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

  3349.             token = {
    3350. 

  3350.                 type: entry.type,
    3351. 

  3351.                 value: entry.value
    3352. 

  3352.             };
    3353. 

  3353.             if (extra.range) {
    3354. 

  3354.                 token.range = entry.range;
    3355. 

  3355.             }
    3356. 

  3356.             if (extra.loc) {
    3357. 

  3357.                 token.loc = entry.loc;
    3358. 

  3358.             }
    3359. 

  3359.             tokens.push(token);
    3360. 

  3360.         }
    3361. 

  3361. 

  3362.         extra.tokens = tokens;
    3363. 

  3363.     }
    3364. 

  3364. 

  3365.     function createLiteral(token) {
    3366. 

  3366.         return {
    3367. 

  3367.             type: Syntax.Literal,
    3368. 

  3368.             value: token.value
    3369. 

  3369.         };
    3370. 

  3370.     }
    3371. 

  3371. 

  3372.     function createRawLiteral(token) {
    3373. 

  3373.         return {
    3374. 

  3374.             type: Syntax.Literal,
    3375. 

  3375.             value: token.value,
    3376. 

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

  3377.         };
    3378. 

  3378.     }
    3379. 

  3379. 

  3380.     function createLocationMarker() {
    3381. 

  3381.         var marker = {};
    3382. 

  3382. 

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

  3384.         marker.loc = {
    3385. 

  3385.             start: {
    3386. 

  3386.                 line: lineNumber,
    3387. 

  3387.                 column: index - lineStart
    3388. 

  3388.             },
    3389. 

  3389.             end: {
    3390. 

  3390.                 line: lineNumber,
    3391. 

  3391.                 column: index - lineStart
    3392. 

  3392.             }
    3393. 

  3393.         };
    3394. 

  3394. 

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

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

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

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

  3399.         };
    3400. 

  3400. 

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

  3402.             if (extra.range) {
    3403. 

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

  3404.             }
    3405. 

  3405.             if (extra.loc) {
    3406. 

  3406.                 node.groupLoc = {
    3407. 

  3407.                     start: {
    3408. 

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

  3409.                         column: this.loc.start.column
    3410. 

  3410.                     },
    3411. 

  3411.                     end: {
    3412. 

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

  3413.                         column: this.loc.end.column
    3414. 

  3414.                     }
    3415. 

  3415.                 };
    3416. 

  3416.             }
    3417. 

  3417.         };
    3418. 

  3418. 

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

  3420.             if (extra.range) {
    3421. 

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

  3422.             }
    3423. 

  3423.             if (extra.loc) {
    3424. 

  3424.                 node.loc = {
    3425. 

  3425.                     start: {
    3426. 

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

  3427.                         column: this.loc.start.column
    3428. 

  3428.                     },
    3429. 

  3429.                     end: {
    3430. 

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

  3431.                         column: this.loc.end.column
    3432. 

  3432.                     }
    3433. 

  3433.                 };
    3434. 

  3434.             }
    3435. 

  3435.         };
    3436. 

  3436. 

  3437.         return marker;
    3438. 

  3438.     }
    3439. 

  3439. 

  3440.     function trackGroupExpression() {
    3441. 

  3441.         var marker, expr;
    3442. 

  3442. 

  3443.         skipComment();
    3444. 

  3444.         marker = createLocationMarker();
    3445. 

  3445.         expect('(');
    3446. 

  3446. 

  3447.         expr = parseExpression();
    3448. 

  3448. 

  3449.         expect(')');
    3450. 

  3450. 

  3451.         marker.end();
    3452. 

  3452.         marker.applyGroup(expr);
    3453. 

  3453. 

  3454.         return expr;
    3455. 

  3455.     }
    3456. 

  3456. 

  3457.     function trackLeftHandSideExpression() {
    3458. 

  3458.         var marker, expr;
    3459. 

  3459. 

  3460.         skipComment();
    3461. 

  3461.         marker = createLocationMarker();
    3462. 

  3462. 

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

  3464. 

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

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

  3467.                 expr = {
    3468. 

  3468.                     type: Syntax.MemberExpression,
    3469. 

  3469.                     computed: true,
    3470. 

  3470.                     object: expr,
    3471. 

  3471.                     property: parseComputedMember()
    3472. 

  3472.                 };
    3473. 

  3473.                 marker.end();
    3474. 

  3474.                 marker.apply(expr);
    3475. 

  3475.             } else {
    3476. 

  3476.                 expr = {
    3477. 

  3477.                     type: Syntax.MemberExpression,
    3478. 

  3478.                     computed: false,
    3479. 

  3479.                     object: expr,
    3480. 

  3480.                     property: parseNonComputedMember()
    3481. 

  3481.                 };
    3482. 

  3482.                 marker.end();
    3483. 

  3483.                 marker.apply(expr);
    3484. 

  3484.             }
    3485. 

  3485.         }
    3486. 

  3486. 

  3487.         return expr;
    3488. 

  3488.     }
    3489. 

  3489. 

  3490.     function trackLeftHandSideExpressionAllowCall() {
    3491. 

  3491.         var marker, expr;
    3492. 

  3492. 

  3493.         skipComment();
    3494. 

  3494.         marker = createLocationMarker();
    3495. 

  3495. 

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

  3497. 

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

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

  3500.                 expr = {
    3501. 

  3501.                     type: Syntax.CallExpression,
    3502. 

  3502.                     callee: expr,
    3503. 

  3503.                     'arguments': parseArguments()
    3504. 

  3504.                 };
    3505. 

  3505.                 marker.end();
    3506. 

  3506.                 marker.apply(expr);
    3507. 

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

  3508.                 expr = {
    3509. 

  3509.                     type: Syntax.MemberExpression,
    3510. 

  3510.                     computed: true,
    3511. 

  3511.                     object: expr,
    3512. 

  3512.                     property: parseComputedMember()
    3513. 

  3513.                 };
    3514. 

  3514.                 marker.end();
    3515. 

  3515.                 marker.apply(expr);
    3516. 

  3516.             } else {
    3517. 

  3517.                 expr = {
    3518. 

  3518.                     type: Syntax.MemberExpression,
    3519. 

  3519.                     computed: false,
    3520. 

  3520.                     object: expr,
    3521. 

  3521.                     property: parseNonComputedMember()
    3522. 

  3522.                 };
    3523. 

  3523.                 marker.end();
    3524. 

  3524.                 marker.apply(expr);
    3525. 

  3525.             }
    3526. 

  3526.         }
    3527. 

  3527. 

  3528.         return expr;
    3529. 

  3529.     }
    3530. 

  3530. 

  3531.     function filterGroup(node) {
    3532. 

  3532.         var n, i, entry;
    3533. 

  3533. 

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

  3535.         for (i in node) {
    3536. 

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

  3537.                 entry = node[i];
    3538. 

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

  3539.                     n[i] = entry;
    3540. 

  3540.                 } else {
    3541. 

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

  3542.                 }
    3543. 

  3543.             }
    3544. 

  3544.         }
    3545. 

  3545.         return n;
    3546. 

  3546.     }
    3547. 

  3547. 

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

  3549. 

  3550.         return function (parseFunction) {
    3551. 

  3551. 

  3552.             function isBinary(node) {
    3553. 

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

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

  3555.             }
    3556. 

  3556. 

  3557.             function visit(node) {
    3558. 

  3558.                 var start, end;
    3559. 

  3559. 

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

  3561.                     visit(node.left);
    3562. 

  3562.                 }
    3563. 

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

  3564.                     visit(node.right);
    3565. 

  3565.                 }
    3566. 

  3566. 

  3567.                 if (range) {
    3568. 

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

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

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

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

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

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

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

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

  3576.                     }
    3577. 

  3577.                 }
    3578. 

  3578.                 if (loc) {
    3579. 

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

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

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

  3582.                         node.loc = {
    3583. 

  3583.                             start: start,
    3584. 

  3584.                             end: end
    3585. 

  3585.                         };
    3586. 

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

  3587.                         node.loc = {
    3588. 

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

  3589.                             end: node.right.loc.end
    3590. 

  3590.                         };
    3591. 

  3591.                     }
    3592. 

  3592.                 }
    3593. 

  3593.             }
    3594. 

  3594. 

  3595.             return function () {
    3596. 

  3596.                 var marker, node;
    3597. 

  3597. 

  3598.                 skipComment();
    3599. 

  3599. 

  3600.                 marker = createLocationMarker();
    3601. 

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

  3602.                 marker.end();
    3603. 

  3603. 

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

  3605.                     marker.apply(node);
    3606. 

  3606.                 }
    3607. 

  3607. 

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

  3609.                     marker.apply(node);
    3610. 

  3610.                 }
    3611. 

  3611. 

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

  3613.                     visit(node);
    3614. 

  3614.                 }
    3615. 

  3615. 

  3616.                 return node;
    3617. 

  3617.             };
    3618. 

  3618.         };
    3619. 

  3619.     }
    3620. 

  3620. 

  3621.     function patch() {
    3622. 

  3622. 

  3623.         var wrapTracking;
    3624. 

  3624. 

  3625.         if (extra.comments) {
    3626. 

  3626.             extra.skipComment = skipComment;
    3627. 

  3627.             skipComment = scanComment;
    3628. 

  3628.         }
    3629. 

  3629. 

  3630.         if (extra.raw) {
    3631. 

  3631.             extra.createLiteral = createLiteral;
    3632. 

  3632.             createLiteral = createRawLiteral;
    3633. 

  3633.         }
    3634. 

  3634. 

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

  3636. 

  3637.             extra.parseGroupExpression = parseGroupExpression;
    3638. 

  3638.             extra.parseLeftHandSideExpression = parseLeftHandSideExpression;
    3639. 

  3639.             extra.parseLeftHandSideExpressionAllowCall = parseLeftHandSideExpressionAllowCall;
    3640. 

  3640.             parseGroupExpression = trackGroupExpression;
    3641. 

  3641.             parseLeftHandSideExpression = trackLeftHandSideExpression;
    3642. 

  3642.             parseLeftHandSideExpressionAllowCall = trackLeftHandSideExpressionAllowCall;
    3643. 

  3643. 

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

  3645. 

  3646.             extra.parseAdditiveExpression = parseAdditiveExpression;
    3647. 

  3647.             extra.parseAssignmentExpression = parseAssignmentExpression;
    3648. 

  3648.             extra.parseBitwiseANDExpression = parseBitwiseANDExpression;
    3649. 

  3649.             extra.parseBitwiseORExpression = parseBitwiseORExpression;
    3650. 

  3650.             extra.parseBitwiseXORExpression = parseBitwiseXORExpression;
    3651. 

  3651.             extra.parseBlock = parseBlock;
    3652. 

  3652.             extra.parseFunctionSourceElements = parseFunctionSourceElements;
    3653. 

  3653.             extra.parseCatchClause = parseCatchClause;
    3654. 

  3654.             extra.parseComputedMember = parseComputedMember;
    3655. 

  3655.             extra.parseConditionalExpression = parseConditionalExpression;
    3656. 

  3656.             extra.parseConstLetDeclaration = parseConstLetDeclaration;
    3657. 

  3657.             extra.parseEqualityExpression = parseEqualityExpression;
    3658. 

  3658.             extra.parseExpression = parseExpression;
    3659. 

  3659.             extra.parseForVariableDeclaration = parseForVariableDeclaration;
    3660. 

  3660.             extra.parseFunctionDeclaration = parseFunctionDeclaration;
    3661. 

  3661.             extra.parseFunctionExpression = parseFunctionExpression;
    3662. 

  3662.             extra.parseLogicalANDExpression = parseLogicalANDExpression;
    3663. 

  3663.             extra.parseLogicalORExpression = parseLogicalORExpression;
    3664. 

  3664.             extra.parseMultiplicativeExpression = parseMultiplicativeExpression;
    3665. 

  3665.             extra.parseNewExpression = parseNewExpression;
    3666. 

  3666.             extra.parseNonComputedProperty = parseNonComputedProperty;
    3667. 

  3667.             extra.parseObjectProperty = parseObjectProperty;
    3668. 

  3668.             extra.parseObjectPropertyKey = parseObjectPropertyKey;
    3669. 

  3669.             extra.parsePostfixExpression = parsePostfixExpression;
    3670. 

  3670.             extra.parsePrimaryExpression = parsePrimaryExpression;
    3671. 

  3671.             extra.parseProgram = parseProgram;
    3672. 

  3672.             extra.parsePropertyFunction = parsePropertyFunction;
    3673. 

  3673.             extra.parseRelationalExpression = parseRelationalExpression;
    3674. 

  3674.             extra.parseStatement = parseStatement;
    3675. 

  3675.             extra.parseShiftExpression = parseShiftExpression;
    3676. 

  3676.             extra.parseSwitchCase = parseSwitchCase;
    3677. 

  3677.             extra.parseUnaryExpression = parseUnaryExpression;
    3678. 

  3678.             extra.parseVariableDeclaration = parseVariableDeclaration;
    3679. 

  3679.             extra.parseVariableIdentifier = parseVariableIdentifier;
    3680. 

  3680. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  3697.             parseLeftHandSideExpression = wrapTracking(parseLeftHandSideExpression);
    3698. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  3716.         }
    3717. 

  3717. 

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

  3719.             extra.advance = advance;
    3720. 

  3720.             extra.scanRegExp = scanRegExp;
    3721. 

  3721. 

  3722.             advance = collectToken;
    3723. 

  3723.             scanRegExp = collectRegex;
    3724. 

  3724.         }
    3725. 

  3725.     }
    3726. 

  3726. 

  3727.     function unpatch() {
    3728. 

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

  3729.             skipComment = extra.skipComment;
    3730. 

  3730.         }
    3731. 

  3731. 

  3732.         if (extra.raw) {
    3733. 

  3733.             createLiteral = extra.createLiteral;
    3734. 

  3734.         }
    3735. 

  3735. 

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

  3737.             parseAdditiveExpression = extra.parseAdditiveExpression;
    3738. 

  3738.             parseAssignmentExpression = extra.parseAssignmentExpression;
    3739. 

  3739.             parseBitwiseANDExpression = extra.parseBitwiseANDExpression;
    3740. 

  3740.             parseBitwiseORExpression = extra.parseBitwiseORExpression;
    3741. 

  3741.             parseBitwiseXORExpression = extra.parseBitwiseXORExpression;
    3742. 

  3742.             parseBlock = extra.parseBlock;
    3743. 

  3743.             parseFunctionSourceElements = extra.parseFunctionSourceElements;
    3744. 

  3744.             parseCatchClause = extra.parseCatchClause;
    3745. 

  3745.             parseComputedMember = extra.parseComputedMember;
    3746. 

  3746.             parseConditionalExpression = extra.parseConditionalExpression;
    3747. 

  3747.             parseConstLetDeclaration = extra.parseConstLetDeclaration;
    3748. 

  3748.             parseEqualityExpression = extra.parseEqualityExpression;
    3749. 

  3749.             parseExpression = extra.parseExpression;
    3750. 

  3750.             parseForVariableDeclaration = extra.parseForVariableDeclaration;
    3751. 

  3751.             parseFunctionDeclaration = extra.parseFunctionDeclaration;
    3752. 

  3752.             parseFunctionExpression = extra.parseFunctionExpression;
    3753. 

  3753.             parseGroupExpression = extra.parseGroupExpression;
    3754. 

  3754.             parseLeftHandSideExpression = extra.parseLeftHandSideExpression;
    3755. 

  3755.             parseLeftHandSideExpressionAllowCall = extra.parseLeftHandSideExpressionAllowCall;
    3756. 

  3756.             parseLogicalANDExpression = extra.parseLogicalANDExpression;
    3757. 

  3757.             parseLogicalORExpression = extra.parseLogicalORExpression;
    3758. 

  3758.             parseMultiplicativeExpression = extra.parseMultiplicativeExpression;
    3759. 

  3759.             parseNewExpression = extra.parseNewExpression;
    3760. 

  3760.             parseNonComputedProperty = extra.parseNonComputedProperty;
    3761. 

  3761.             parseObjectProperty = extra.parseObjectProperty;
    3762. 

  3762.             parseObjectPropertyKey = extra.parseObjectPropertyKey;
    3763. 

  3763.             parsePrimaryExpression = extra.parsePrimaryExpression;
    3764. 

  3764.             parsePostfixExpression = extra.parsePostfixExpression;
    3765. 

  3765.             parseProgram = extra.parseProgram;
    3766. 

  3766.             parsePropertyFunction = extra.parsePropertyFunction;
    3767. 

  3767.             parseRelationalExpression = extra.parseRelationalExpression;
    3768. 

  3768.             parseStatement = extra.parseStatement;
    3769. 

  3769.             parseShiftExpression = extra.parseShiftExpression;
    3770. 

  3770.             parseSwitchCase = extra.parseSwitchCase;
    3771. 

  3771.             parseUnaryExpression = extra.parseUnaryExpression;
    3772. 

  3772.             parseVariableDeclaration = extra.parseVariableDeclaration;
    3773. 

  3773.             parseVariableIdentifier = extra.parseVariableIdentifier;
    3774. 

  3774.         }
    3775. 

  3775. 

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

  3777.             advance = extra.advance;
    3778. 

  3778.             scanRegExp = extra.scanRegExp;
    3779. 

  3779.         }
    3780. 

  3780.     }
    3781. 

  3781. 

  3782.     function stringToArray(str) {
    3783. 

  3783.         var length = str.length,
    3784. 

  3784.             result = [],
    3785. 

  3785.             i;
    3786. 

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

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

  3788.         }
    3789. 

  3789.         return result;
    3790. 

  3790.     }
    3791. 

  3791. 

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

  3793.         var program, toString;
    3794. 

  3794. 

  3795.         toString = String;
    3796. 

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

  3797.             code = toString(code);
    3798. 

  3798.         }
    3799. 

  3799. 

  3800.         source = code;
    3801. 

  3801.         index = 0;
    3802. 

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

  3803.         lineStart = 0;
    3804. 

  3804.         length = source.length;
    3805. 

  3805.         buffer = null;
    3806. 

  3806.         state = {
    3807. 

  3807.             allowIn: true,
    3808. 

  3808.             labelSet: {},
    3809. 

  3809.             inFunctionBody: false,
    3810. 

  3810.             inIteration: false,
    3811. 

  3811.             inSwitch: false
    3812. 

  3812.         };
    3813. 

  3813. 

  3814.         extra = {};
    3815. 

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

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

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

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

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

  3820.                 extra.tokens = [];
    3821. 

  3821.             }
    3822. 

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

  3823.                 extra.comments = [];
    3824. 

  3824.             }
    3825. 

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

  3826.                 extra.errors = [];
    3827. 

  3827.             }
    3828. 

  3828.         }
    3829. 

  3829. 

  3830.         if (length > 0) {
    3831. 

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

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

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

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

  3835.                 if (code instanceof String) {
    3836. 

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

  3837.                 }
    3838. 

  3838. 

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

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

  3841.                     source = stringToArray(code);
    3842. 

  3842.                 }
    3843. 

  3843.             }
    3844. 

  3844.         }
    3845. 

  3845. 

  3846.         patch();
    3847. 

  3847.         try {
    3848. 

  3848.             program = parseProgram();
    3849. 

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

  3850.                 filterCommentLocation();
    3851. 

  3851.                 program.comments = extra.comments;
    3852. 

  3852.             }
    3853. 

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

  3854.                 filterTokenLocation();
    3855. 

  3855.                 program.tokens = extra.tokens;
    3856. 

  3856.             }
    3857. 

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

  3858.                 program.errors = extra.errors;
    3859. 

  3859.             }
    3860. 

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

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

  3862.             }
    3863. 

  3863.         } catch (e) {
    3864. 

  3864.             throw e;
    3865. 

  3865.         } finally {
    3866. 

  3866.             unpatch();
    3867. 

  3867.             extra = {};
    3868. 

  3868.         }
    3869. 

  3869. 

  3870.         return program;
    3871. 

  3871.     }
    3872. 

  3872. 

  3873.     // Sync with package.json.
    3874. 

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

  3875. 

  3876.     exports.parse = parse;
    3877. 

  3877. 

  3878.     // Deep copy.
    3879. 

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

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

  3881. 

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

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

  3884.         }
    3885. 

  3885. 

  3886.         for (name in Syntax) {
    3887. 

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

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

  3889.             }
    3890. 

  3890.         }
    3891. 

  3891. 

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

  3893.             Object.freeze(types);
    3894. 

  3894.         }
    3895. 

  3895. 

  3896.         return types;
    3897. 

  3897.     }());
    3898. 

  3898. 

  3899. }));
    3900. 

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

  3901. 

  3902. })(null);
    3903. 

  3903. 

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

  3905. 

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

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

  3908.     var keys = [];
    3909. 

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

  3910.     return keys;
    3911. 

  3911. };
    3912. 

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

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

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

  3915.         fn.call(xs, xs[i], i, xs);
    3916. 

  3916.     }
    3917. 

  3917. };
    3918. 

  3918. 

  3919. var isArray = Array.isArray || function (xs) {
    3920. 

  3920.     return Object.prototype.toString.call(xs) === '[object Array]';
    3921. 

  3921. };
    3922. 

  3922. 

  3923. module.exports = function (src, opts, fn) {
    3924. 

  3924.     if (typeof opts === 'function') {
    3925. 

  3925.         fn = opts;
    3926. 

  3926.         opts = {};
    3927. 

  3927.     }
    3928. 

  3928.     if (typeof src === 'object') {
    3929. 

  3929.         opts = src;
    3930. 

  3930.         src = opts.source;
    3931. 

  3931.         delete opts.source;
    3932. 

  3932.     }
    3933. 

  3933.     src = src === undefined ? opts.source : src;
    3934. 

  3934.     opts.range = true;
    3935. 

  3935.     if (typeof src !== 'string') src = String(src);
    3936. 

  3936.     
    3937. 

  3937.     var ast = parse(src, opts);
    3938. 

  3938.     
    3939. 

  3939.     var result = {
    3940. 

  3940.         chunks : src.split(''),
    3941. 

  3941.         toString : function () { return result.chunks.join('') },
    3942. 

  3942.         inspect : function () { return result.toString() }
    3943. 

  3943.     };
    3944. 

  3944.     var index = 0;
    3945. 

  3945.     
    3946. 

  3946.     (function walk (node, parent) {
    3947. 

  3947.         insertHelpers(node, parent, result.chunks);
    3948. 

  3948.         
    3949. 

  3949.         forEach(objectKeys(node), function (key) {
    3950. 

  3950.             if (key === 'parent') return;
    3951. 

  3951.             
    3952. 

  3952.             var child = node[key];
    3953. 

  3953.             if (isArray(child)) {
    3954. 

  3954.                 forEach(child, function (c) {
    3955. 

  3955.                     if (c && typeof c.type === 'string') {
    3956. 

  3956.                         walk(c, node);
    3957. 

  3957.                     }
    3958. 

  3958.                 });
    3959. 

  3959.             }
    3960. 

  3960.             else if (child && typeof child.type === 'string') {
    3961. 

  3961.                 insertHelpers(child, node, result.chunks);
    3962. 

  3962.                 walk(child, node);
    3963. 

  3963.             }
    3964. 

  3964.         });
    3965. 

  3965.         fn(node);
    3966. 

  3966.     })(ast, undefined);
    3967. 

  3967.     
    3968. 

  3968.     return result;
    3969. 

  3969. };
    3970. 

  3970.  
    3971. 

  3971. function insertHelpers (node, parent, chunks) {
    3972. 

  3972.     if (!node.range) return;
    3973. 

  3973.     
    3974. 

  3974.     node.parent = parent;
    3975. 

  3975.     
    3976. 

  3976.     node.source = function () {
    3977. 

  3977.         return chunks.slice(
    3978. 

  3978.             node.range[0], node.range[1]
    3979. 

  3979.         ).join('');
    3980. 

  3980.     };
    3981. 

  3981.     
    3982. 

  3982.     if (node.update && typeof node.update === 'object') {
    3983. 

  3983.         var prev = node.update;
    3984. 

  3984.         forEach(objectKeys(prev), function (key) {
    3985. 

  3985.             update[key] = prev[key];
    3986. 

  3986.         });
    3987. 

  3987.         node.update = update;
    3988. 

  3988.     }
    3989. 

  3989.     else {
    3990. 

  3990.         node.update = update;
    3991. 

  3991.     }
    3992. 

  3992.     
    3993. 

  3993.     function update (s) {
    3994. 

  3994.         chunks[node.range[0]] = s;
    3995. 

  3995.         for (var i = node.range[0] + 1; i < node.range[1]; i++) {
    3996. 

  3996.             chunks[i] = '';
    3997. 

  3997.         }
    3998. 

  3998.     };
    3999. 

  3999. }
    4000. 

  4000. 

  4001. window.falafel = module.exports;})(function(){return {parse: esprima.parse};},{exports: {}});
    4002. 

  4002. 

  4003. var inBrowser = typeof window !== 'undefined' && this === window;
    4004. 

  4004. var parseAndModify = (inBrowser ? window.falafel : require("falafel"));
    4005. 

  4005. 

  4006. (inBrowser ? window : exports).blanket = (function(){
    4007. 

  4007.     var linesToAddTracking = [
    4008. 

  4008.         "ExpressionStatement",
    4009. 

  4009.         "BreakStatement"   ,
    4010. 

  4010.         "ContinueStatement" ,
    4011. 

  4011.         "VariableDeclaration",
    4012. 

  4012.         "ReturnStatement"   ,
    4013. 

  4013.         "ThrowStatement"   ,
    4014. 

  4014.         "TryStatement"     ,
    4015. 

  4015.         "FunctionDeclaration"    ,
    4016. 

  4016.         "IfStatement"       ,
    4017. 

  4017.         "WhileStatement"    ,
    4018. 

  4018.         "DoWhileStatement"   ,
    4019. 

  4019.         "ForStatement"   ,
    4020. 

  4020.         "ForInStatement"  ,
    4021. 

  4021.         "SwitchStatement"  ,
    4022. 

  4022.         "WithStatement"
    4023. 

  4023.     ],
    4024. 

  4024.     linesToAddBrackets = [
    4025. 

  4025.         "IfStatement"       ,
    4026. 

  4026.         "WhileStatement"    ,
    4027. 

  4027.         "DoWhileStatement"     ,
    4028. 

  4028.         "ForStatement"   ,
    4029. 

  4029.         "ForInStatement"  ,
    4030. 

  4030.         "WithStatement"
    4031. 

  4031.     ],
    4032. 

  4032.     __blanket,
    4033. 

  4033.     copynumber = Math.floor(Math.random()*1000),
    4034. 

  4034.     coverageInfo = {},options = {
    4035. 

  4035.         reporter: null,
    4036. 

  4036.         adapter:null,
    4037. 

  4037.         filter: null,
    4038. 

  4038.         customVariable: null,
    4039. 

  4039.         orderedLoading: true,
    4040. 

  4040.         loader: null,
    4041. 

  4041.         ignoreScriptError: false,
    4042. 

  4042.         existingRequireJS:false,
    4043. 

  4043.         autoStart: false,
    4044. 

  4044.         timeout: 180,
    4045. 

  4045.         ignoreCors: false,
    4046. 

  4046.         branchTracking: false,
    4047. 

  4047.         sourceURL: false,
    4048. 

  4048.         debug:false,
    4049. 

  4049.         engineOnly:false,
    4050. 

  4050.         testReadyCallback:null,
    4051. 

  4051.         commonJS:false,
    4052. 

  4052.         instrumentCache:false
    4053. 

  4053.     };
    4054. 

  4054.     
    4055. 

  4055.     if (inBrowser && typeof window.blanket !== 'undefined'){
    4056. 

  4056.         __blanket = window.blanket.noConflict();
    4057. 

  4057.     }
    4058. 

  4058.     
    4059. 

  4059.     _blanket = {
    4060. 

  4060.         noConflict: function(){
    4061. 

  4061.             if (__blanket){
    4062. 

  4062.                 return __blanket;
    4063. 

  4063.             }
    4064. 

  4064.             return _blanket;
    4065. 

  4065.         },
    4066. 

  4066.         _getCopyNumber: function(){
    4067. 

  4067.             //internal method
    4068. 

  4068.             //for differentiating between instances
    4069. 

  4069.             return copynumber;
    4070. 

  4070.         },
    4071. 

  4071.         extend: function(obj) {
    4072. 

  4072.             //borrowed from underscore
    4073. 

  4073.             _blanket._extend(_blanket,obj);
    4074. 

  4074.         },
    4075. 

  4075.         _extend: function(dest,source){
    4076. 

  4076.           if (source) {
    4077. 

  4077.             for (var prop in source) {
    4078. 

  4078.               if ( dest[prop] instanceof Object && typeof dest[prop] !== "function"){
    4079. 

  4079.                 _blanket._extend(dest[prop],source[prop]);
    4080. 

  4080.               }else{
    4081. 

  4081.                   dest[prop] = source[prop];
    4082. 

  4082.               }
    4083. 

  4083.             }
    4084. 

  4084.           }
    4085. 

  4085.         },
    4086. 

  4086.         getCovVar: function(){
    4087. 

  4087.             var opt = _blanket.options("customVariable");
    4088. 

  4088.             if (opt){
    4089. 

  4089.                 if (_blanket.options("debug")) {console.log("BLANKET-Using custom tracking variable:",opt);}
    4090. 

  4090.                 return inBrowser ? "window."+opt : opt;
    4091. 

  4091.             }
    4092. 

  4092.             return inBrowser ?   "window._$blanket" : "_$jscoverage";
    4093. 

  4093.         },
    4094. 

  4094.         options: function(key,value){
    4095. 

  4095.             if (typeof key !== "string"){
    4096. 

  4096.                 _blanket._extend(options,key);
    4097. 

  4097.             }else if (typeof value === 'undefined'){
    4098. 

  4098.                 return options[key];
    4099. 

  4099.             }else{
    4100. 

  4100.                 options[key]=value;
    4101. 

  4101.             }
    4102. 

  4102.         },
    4103. 

  4103.         instrument: function(config, next){
    4104. 

  4104.             //check instrumented hash table,
    4105. 

  4105.             //return instrumented code if available.
    4106. 

  4106.             var inFile = config.inputFile,
    4107. 

  4107.                 inFileName = config.inputFileName;
    4108. 

  4108.             //check instrument cache
    4109. 

  4109.            if (_blanket.options("instrumentCache") && sessionStorage && sessionStorage.getItem("blanket_instrument_store-"+inFileName)){
    4110. 

  4110.                 if (_blanket.options("debug")) {console.log("BLANKET-Reading instrumentation from cache: ",inFileName);}
    4111. 

  4111.                 next(sessionStorage.getItem("blanket_instrument_store-"+inFileName));
    4112. 

  4112.             }else{
    4113. 

  4113.                 var sourceArray = _blanket._prepareSource(inFile);
    4114. 

  4114.                 _blanket._trackingArraySetup=[];
    4115. 

  4115.                 var instrumented =  parseAndModify(inFile,{loc:true,comment:true}, _blanket._addTracking(inFileName));
    4116. 

  4116.                 instrumented = _blanket._trackingSetup(inFileName,sourceArray)+instrumented;
    4117. 

  4117.                 if (_blanket.options("sourceURL")){
    4118. 

  4118.                     instrumented += "\n//@ sourceURL="+inFileName.replace("http://","");
    4119. 

  4119.                 }
    4120. 

  4120.                 if (_blanket.options("debug")) {console.log("BLANKET-Instrumented file: ",inFileName);}
    4121. 

  4121.                 if (_blanket.options("instrumentCache") && sessionStorage){
    4122. 

  4122.                     if (_blanket.options("debug")) {console.log("BLANKET-Saving instrumentation to cache: ",inFileName);}
    4123. 

  4123.                     sessionStorage.setItem("blanket_instrument_store-"+inFileName,instrumented);
    4124. 

  4124.                 }
    4125. 

  4125.                 next(instrumented);
    4126. 

  4126.             }
    4127. 

  4127.         },
    4128. 

  4128.         _trackingArraySetup: [],
    4129. 

  4129.         _branchingArraySetup: [],
    4130. 

  4130.         _prepareSource: function(source){
    4131. 

  4131.             return source.replace(/\\/g,"\\\\").replace(/'/g,"\\'").replace(/(\r\n|\n|\r)/gm,"\n").split('\n');
    4132. 

  4132.         },
    4133. 

  4133.         _trackingSetup: function(filename,sourceArray){
    4134. 

  4134.             var branches = _blanket.options("branchTracking");
    4135. 

  4135.             var sourceString = sourceArray.join("',\n'");
    4136. 

  4136.             var intro = "";
    4137. 

  4137.             var covVar = _blanket.getCovVar();
    4138. 

  4138. 

  4139.             intro += "if (typeof "+covVar+" === 'undefined') "+covVar+" = {};\n";
    4140. 

  4140.             if (branches){
    4141. 

  4141.                 intro += "var _$branchFcn=function(f,l,c,r){ ";
    4142. 

  4142.                 intro += "if (!!r) { ";
    4143. 

  4143.                 intro += covVar+"[f].branchData[l][c][0] = "+covVar+"[f].branchData[l][c][0] || [];";
    4144. 

  4144.                 intro += covVar+"[f].branchData[l][c][0].push(r); }";
    4145. 

  4145.                 intro += "else { ";
    4146. 

  4146.                 intro += covVar+"[f].branchData[l][c][1] = "+covVar+"[f].branchData[l][c][1] || [];";
    4147. 

  4147.                 intro += covVar+"[f].branchData[l][c][1].push(r); }";
    4148. 

  4148.                 intro += "return r;};\n";
    4149. 

  4149.             }
    4150. 

  4150.             intro += "if (typeof "+covVar+"['"+filename+"'] === 'undefined'){";
    4151. 

  4151. 

  4152.             intro += covVar+"['"+filename+"']=[];\n";
    4153. 

  4153.             if (branches){
    4154. 

  4154.                 intro += covVar+"['"+filename+"'].branchData=[];\n";
    4155. 

  4155.             }
    4156. 

  4156.             intro += covVar+"['"+filename+"'].source=['"+sourceString+"'];\n";
    4157. 

  4157.             //initialize array values
    4158. 

  4158.             _blanket._trackingArraySetup.sort(function(a,b){
    4159. 

  4159.                 return parseInt(a,10) > parseInt(b,10);
    4160. 

  4160.             }).forEach(function(item){
    4161. 

  4161.                 intro += covVar+"['"+filename+"']["+item+"]=0;\n";
    4162. 

  4162.             });
    4163. 

  4163.             if (branches){
    4164. 

  4164.                 _blanket._branchingArraySetup.sort(function(a,b){
    4165. 

  4165.                     return a.line > b.line;
    4166. 

  4166.                 }).sort(function(a,b){
    4167. 

  4167.                     return a.column > b.column;
    4168. 

  4168.                 }).forEach(function(item){
    4169. 

  4169.                     if (item.file === filename){
    4170. 

  4170.                         intro += "if (typeof "+ covVar+"['"+filename+"'].branchData["+item.line+"] === 'undefined'){\n";
    4171. 

  4171.                         intro += covVar+"['"+filename+"'].branchData["+item.line+"]=[];\n";
    4172. 

  4172.                         intro += "}";
    4173. 

  4173.                         intro += covVar+"['"+filename+"'].branchData["+item.line+"]["+item.column+"] = [];\n";
    4174. 

  4174.                         intro += covVar+"['"+filename+"'].branchData["+item.line+"]["+item.column+"].consequent = "+JSON.stringify(item.consequent)+";\n";
    4175. 

  4175.                         intro += covVar+"['"+filename+"'].branchData["+item.line+"]["+item.column+"].alternate = "+JSON.stringify(item.alternate)+";\n";
    4176. 

  4176.                     }
    4177. 

  4177.                 });
    4178. 

  4178.             }
    4179. 

  4179.             intro += "}";
    4180. 

  4180. 

  4181.             return intro;
    4182. 

  4182.         },
    4183. 

  4183.         _blockifyIf: function(node){
    4184. 

  4184.             if (linesToAddBrackets.indexOf(node.type) > -1){
    4185. 

  4185.                 var bracketsExistObject = node.consequent || node.body;
    4186. 

  4186.                 var bracketsExistAlt = node.alternate;
    4187. 

  4187.                 if( bracketsExistAlt && bracketsExistAlt.type !== "BlockStatement") {
    4188. 

  4188.                     bracketsExistAlt.update("{\n"+bracketsExistAlt.source()+"}\n");
    4189. 

  4189.                 }
    4190. 

  4190.                 if( bracketsExistObject && bracketsExistObject.type !== "BlockStatement") {
    4191. 

  4191.                     bracketsExistObject.update("{\n"+bracketsExistObject.source()+"}\n");
    4192. 

  4192.                 }
    4193. 

  4193.             }
    4194. 

  4194.         },
    4195. 

  4195.         _trackBranch: function(node,filename){
    4196. 

  4196.             //recursive on consequent and alternative
    4197. 

  4197.             var line = node.loc.start.line;
    4198. 

  4198.             var col = node.loc.start.column;
    4199. 

  4199. 

  4200.             _blanket._branchingArraySetup.push({
    4201. 

  4201.                 line: line,
    4202. 

  4202.                 column: col,
    4203. 

  4203.                 file:filename,
    4204. 

  4204.                 consequent: node.consequent.loc,
    4205. 

  4205.                 alternate: node.alternate.loc
    4206. 

  4206.             });
    4207. 

  4207. 

  4208.             var source = node.source();
    4209. 

  4209.             var updated = "_$branchFcn"+
    4210. 

  4210.                           "('"+filename+"',"+line+","+col+","+source.slice(0,source.indexOf("?"))+
    4211. 

  4211.                           ")"+source.slice(source.indexOf("?"));
    4212. 

  4212.             node.update(updated);
    4213. 

  4213.         },
    4214. 

  4214.         _addTracking: function (filename) {
    4215. 

  4215.             //falafel doesn't take a file name
    4216. 

  4216.             //so we include the filename in a closure
    4217. 

  4217.             //and return the function to falafel
    4218. 

  4218.             var covVar = _blanket.getCovVar();
    4219. 

  4219. 

  4220.             return function(node){
    4221. 

  4221.                 _blanket._blockifyIf(node);
    4222. 

  4222. 

  4223.                 if (linesToAddTracking.indexOf(node.type) > -1 && node.parent.type !== "LabeledStatement") {
    4224. 

  4224.                     _blanket._checkDefs(node,filename);
    4225. 

  4225.                     if (node.type === "VariableDeclaration" &&
    4226. 

  4226.                         (node.parent.type === "ForStatement" || node.parent.type === "ForInStatement")){
    4227. 

  4227.                         return;
    4228. 

  4228.                     }
    4229. 

  4229.                     if (node.loc && node.loc.start){
    4230. 

  4230.                         node.update(covVar+"['"+filename+"']["+node.loc.start.line+"]++;\n"+node.source());
    4231. 

  4231.                         _blanket._trackingArraySetup.push(node.loc.start.line);
    4232. 

  4232.                     }else{
    4233. 

  4233.                         //I don't think we can handle a node with no location
    4234. 

  4234.                         throw new Error("The instrumenter encountered a node with no location: "+Object.keys(node));
    4235. 

  4235.                     }
    4236. 

  4236.                 }else if (_blanket.options("branchTracking") && node.type === "ConditionalExpression"){
    4237. 

  4237.                     _blanket._trackBranch(node,filename);
    4238. 

  4238.                 }
    4239. 

  4239.             };
    4240. 

  4240.         },
    4241. 

  4241.         _checkDefs: function(node,filename){
    4242. 

  4242.             // Make sure developers don't redefine window. if they do, inform them it is wrong.
    4243. 

  4243.             if (inBrowser){
    4244. 

  4244.                 if (node.type === "VariableDeclaration" && node.declarations) {
    4245. 

  4245.                     node.declarations.forEach(function(declaration) {
    4246. 

  4246.                         if (declaration.id.name === "window") {
    4247. 

  4247.                             throw new Error("Instrumentation error, you cannot redefine the 'window' variable in  " + filename + ":" + node.loc.start.line);
    4248. 

  4248.                         }
    4249. 

  4249.                     });
    4250. 

  4250.                 }
    4251. 

  4251.                 if (node.type === "FunctionDeclaration" && node.params) {
    4252. 

  4252.                     node.params.forEach(function(param) {
    4253. 

  4253.                         if (param.name === "window") {
    4254. 

  4254.                             throw new Error("Instrumentation error, you cannot redefine the 'window' variable in  " + filename + ":" + node.loc.start.line);
    4255. 

  4255.                         }
    4256. 

  4256.                     });
    4257. 

  4257.                 }
    4258. 

  4258.                 //Make sure developers don't redefine the coverage variable
    4259. 

  4259.                 if (node.type === "ExpressionStatement" &&
    4260. 

  4260.                     node.expression && node.expression.left &&
    4261. 

  4261.                     node.expression.left.object && node.expression.left.property &&
    4262. 

  4262.                     node.expression.left.object.name +
    4263. 

  4263.                         "." + node.expression.left.property.name === _blanket.getCovVar()) {
    4264. 

  4264.                     throw new Error("Instrumentation error, you cannot redefine the coverage variable in  " + filename + ":" + node.loc.start.line);
    4265. 

  4265.                 }
    4266. 

  4266.             }else{
    4267. 

  4267.                 //Make sure developers don't redefine the coverage variable in node
    4268. 

  4268.                 if (node.type === "ExpressionStatement" &&
    4269. 

  4269.                     node.expression && node.expression.left &&
    4270. 

  4270.                     !node.expression.left.object && !node.expression.left.property &&
    4271. 

  4271.                     node.expression.left.name === _blanket.getCovVar()) {
    4272. 

  4272.                     throw new Error("Instrumentation error, you cannot redefine the coverage variable in  " + filename + ":" + node.loc.start.line);
    4273. 

  4273.                 }
    4274. 

  4274.             }
    4275. 

  4275.         },
    4276. 

  4276.         setupCoverage: function(){
    4277. 

  4277.             coverageInfo.instrumentation = "blanket";
    4278. 

  4278.             coverageInfo.stats = {
    4279. 

  4279.                 "suites": 0,
    4280. 

  4280.                 "tests": 0,
    4281. 

  4281.                 "passes": 0,
    4282. 

  4282.                 "pending": 0,
    4283. 

  4283.                 "failures": 0,
    4284. 

  4284.                 "start": new Date()
    4285. 

  4285.             };
    4286. 

  4286.         },
    4287. 

  4287.         _checkIfSetup: function(){
    4288. 

  4288.             if (!coverageInfo.stats){
    4289. 

  4289.                 throw new Error("You must call blanket.setupCoverage() first.");
    4290. 

  4290.             }
    4291. 

  4291.         },
    4292. 

  4292.         onTestStart: function(){
    4293. 

  4293.             if (_blanket.options("debug")) {console.log("BLANKET-Test event started");}
    4294. 

  4294.             this._checkIfSetup();
    4295. 

  4295.             coverageInfo.stats.tests++;
    4296. 

  4296.             coverageInfo.stats.pending++;
    4297. 

  4297.         },
    4298. 

  4298.         onTestDone: function(total,passed){
    4299. 

  4299.             this._checkIfSetup();
    4300. 

  4300.             if(passed === total){
    4301. 

  4301.                 coverageInfo.stats.passes++;
    4302. 

  4302.             }else{
    4303. 

  4303.                 coverageInfo.stats.failures++;
    4304. 

  4304.             }
    4305. 

  4305.             coverageInfo.stats.pending--;
    4306. 

  4306.         },
    4307. 

  4307.         onModuleStart: function(){
    4308. 

  4308.             this._checkIfSetup();
    4309. 

  4309.             coverageInfo.stats.suites++;
    4310. 

  4310.         },
    4311. 

  4311.         onTestsDone: function(){
    4312. 

  4312.             if (_blanket.options("debug")) {console.log("BLANKET-Test event done");}
    4313. 

  4313.             this._checkIfSetup();
    4314. 

  4314.             coverageInfo.stats.end = new Date();
    4315. 

  4315. 

  4316.             if (inBrowser){
    4317. 

  4317.                 this.report(coverageInfo);
    4318. 

  4318.             }else{
    4319. 

  4319.                 if (!_blanket.options("branchTracking")){
    4320. 

  4320.                     delete (inBrowser ? window : global)[_blanket.getCovVar()].branchFcn;
    4321. 

  4321.                 }
    4322. 

  4322.                 this.options("reporter").call(this,coverageInfo);
    4323. 

  4323.             }
    4324. 

  4324.         }
    4325. 

  4325.     };
    4326. 

  4326.     return _blanket;
    4327. 

  4327. })();
    4328. 

  4328. 

  4329. (function(_blanket){
    4330. 

  4330.     var oldOptions = _blanket.options;
    4331. 

  4331. _blanket.extend({
    4332. 

  4332.     outstandingRequireFiles:[],
    4333. 

  4333.     options: function(key,value){
    4334. 

  4334.         var newVal={};
    4335. 

  4335. 

  4336.         if (typeof key !== "string"){
    4337. 

  4337.             //key is key/value map
    4338. 

  4338.             oldOptions(key);
    4339. 

  4339.             newVal = key;
    4340. 

  4340.         }else if (typeof value === 'undefined'){
    4341. 

  4341.             //accessor
    4342. 

  4342.             return oldOptions(key);
    4343. 

  4343.         }else{
    4344. 

  4344.             //setter
    4345. 

  4345.             oldOptions(key,value);
    4346. 

  4346.             newVal[key] = value;
    4347. 

  4347.         }
    4348. 

  4348. 

  4349.         if (newVal.adapter){
    4350. 

  4350.             _blanket._loadFile(newVal.adapter);
    4351. 

  4351.         }
    4352. 

  4352.         if (newVal.loader){
    4353. 

  4353.             _blanket._loadFile(newVal.loader);
    4354. 

  4354.         }
    4355. 

  4355.     },
    4356. 

  4356.     requiringFile: function(filename,done){
    4357. 

  4357.         if (typeof filename === "undefined"){
    4358. 

  4358.             _blanket.outstandingRequireFiles=[];
    4359. 

  4359.         }else if (typeof done === "undefined"){
    4360. 

  4360.             _blanket.outstandingRequireFiles.push(filename);
    4361. 

  4361.         }else{
    4362. 

  4362.             _blanket.outstandingRequireFiles.splice(_blanket.outstandingRequireFiles.indexOf(filename),1);
    4363. 

  4363.         }
    4364. 

  4364.     },
    4365. 

  4365.     requireFilesLoaded: function(){
    4366. 

  4366.         return _blanket.outstandingRequireFiles.length === 0;
    4367. 

  4367.     },
    4368. 

  4368.     showManualLoader: function(){
    4369. 

  4369.         if (document.getElementById("blanketLoaderDialog")){
    4370. 

  4370.             return;
    4371. 

  4371.         }
    4372. 

  4372.         //copied from http://blog.avtex.com/2012/01/26/cross-browser-css-only-modal-box/
    4373. 

  4373.         var loader = "<div class='blanketDialogOverlay'>";
    4374. 

  4374.             loader += "&nbsp;</div>";
    4375. 

  4375.             loader += "<div class='blanketDialogVerticalOffset'>";
    4376. 

  4376.             loader += "<div class='blanketDialogBox'>";
    4377. 

  4377.             loader += "<b>Error:</b> Blanket.js encountered a cross origin request error while instrumenting the source files.  ";
    4378. 

  4378.             loader += "<br><br>This is likely caused by the source files being referenced locally (using the file:// protocol). ";
    4379. 

  4379.             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).";
    4380. 

  4380.             loader += "<br>";
    4381. 

  4381.             if (typeof FileReader !== "undefined"){
    4382. 

  4382.                 loader += "<br>Or, try the experimental loader.  When prompted, simply click on the directory containing all the source files you want covered.";
    4383. 

  4383.                 loader += "<a href='javascript:document.getElementById(\"fileInput\").click();'>Start Loader</a>";
    4384. 

  4384.                 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'/>";
    4385. 

  4385.             }
    4386. 

  4386.             loader += "<br><span style='float:right;cursor:pointer;'  onclick=document.getElementById('blanketLoaderDialog').style.display='none';>Close</span>";
    4387. 

  4387.             loader += "<div style='clear:both'></div>";
    4388. 

  4388.             loader += "</div></div>";
    4389. 

  4389. 

  4390.         var css = ".blanketDialogWrapper {";
    4391. 

  4391.             css += "display:block;";
    4392. 

  4392.             css += "position:fixed;";
    4393. 

  4393.             css += "z-index:40001; }";
    4394. 

  4394. 

  4395.             css += ".blanketDialogOverlay {";
    4396. 

  4396.             css += "position:fixed;";
    4397. 

  4397.             css += "width:100%;";
    4398. 

  4398.             css += "height:100%;";
    4399. 

  4399.             css += "background-color:black;";
    4400. 

  4400.             css += "opacity:.5; ";
    4401. 

  4401.             css += "-ms-filter:'progid:DXImageTransform.Microsoft.Alpha(Opacity=50)'; ";
    4402. 

  4402.             css += "filter:alpha(opacity=50); ";
    4403. 

  4403.             css += "z-index:40001; }";
    4404. 

  4404. 

  4405.             css += ".blanketDialogVerticalOffset { ";
    4406. 

  4406.             css += "position:fixed;";
    4407. 

  4407.             css += "top:30%;";
    4408. 

  4408.             css += "width:100%;";
    4409. 

  4409.             css += "z-index:40002; }";
    4410. 

  4410. 

  4411.             css += ".blanketDialogBox { ";
    4412. 

  4412.             css += "width:405px; ";
    4413. 

  4413.             css += "position:relative;";
    4414. 

  4414.             css += "margin:0 auto;";
    4415. 

  4415.             css += "background-color:white;";
    4416. 

  4416.             css += "padding:10px;";
    4417. 

  4417.             css += "border:1px solid black; }";
    4418. 

  4418. 

  4419.         var dom = document.createElement("style");
    4420. 

  4420.         dom.innerHTML = css;
    4421. 

  4421.         document.head.appendChild(dom);
    4422. 

  4422. 

  4423.         var div = document.createElement("div");
    4424. 

  4424.         div.id = "blanketLoaderDialog";
    4425. 

  4425.         div.className = "blanketDialogWrapper";
    4426. 

  4426.         div.innerHTML = loader;
    4427. 

  4427.         document.body.insertBefore(div,document.body.firstChild);
    4428. 

  4428. 

  4429.     },
    4430. 

  4430.     manualFileLoader: function(files){
    4431. 

  4431.         var toArray =Array.prototype.slice;
    4432. 

  4432.         files = toArray.call(files).filter(function(item){
    4433. 

  4433.             return item.type !== "";
    4434. 

  4434.         });
    4435. 

  4435.         var sessionLength = files.length-1;
    4436. 

  4436.         var sessionIndx=0;
    4437. 

  4437.         var sessionArray = {};
    4438. 

  4438.         if (sessionStorage["blanketSessionLoader"]){
    4439. 

  4439.             sessionArray = JSON.parse(sessionStorage["blanketSessionLoader"]);
    4440. 

  4440.         }
    4441. 

  4441. 

  4442. 

  4443.         var fileLoader = function(event){
    4444. 

  4444.             var fileContent = event.currentTarget.result;
    4445. 

  4445.             var file = files[sessionIndx];
    4446. 

  4446.             var filename = file.webkitRelativePath && file.webkitRelativePath !== '' ? file.webkitRelativePath : file.name;
    4447. 

  4447.             sessionArray[filename] = fileContent;
    4448. 

  4448.             sessionIndx++;
    4449. 

  4449.             if (sessionIndx === sessionLength){
    4450. 

  4450.                 sessionStorage.setItem("blanketSessionLoader", JSON.stringify(sessionArray));
    4451. 

  4451.                 document.location.reload();
    4452. 

  4452.             }else{
    4453. 

  4453.                 readFile(files[sessionIndx]);
    4454. 

  4454.             }
    4455. 

  4455.         };
    4456. 

  4456.         function readFile(file){
    4457. 

  4457.             var reader = new FileReader();
    4458. 

  4458.             reader.onload = fileLoader;
    4459. 

  4459.             reader.readAsText(file);
    4460. 

  4460.         }
    4461. 

  4461.         readFile(files[sessionIndx]);
    4462. 

  4462.     },
    4463. 

  4463.     _loadFile: function(path){
    4464. 

  4464.         if (typeof path !== "undefined"){
    4465. 

  4465.             var request = new XMLHttpRequest();
    4466. 

  4466.             request.open('GET', path, false);
    4467. 

  4467.             request.send();
    4468. 

  4468.             var script = document.createElement("script");
    4469. 

  4469.             script.type = "text/javascript";
    4470. 

  4470.             script.text = request.responseText;
    4471. 

  4471.             (document.body || document.getElementsByTagName('head')[0]).appendChild(script);
    4472. 

  4472.         }
    4473. 

  4473.     },
    4474. 

  4474.     hasAdapter: function(callback){
    4475. 

  4475.         return _blanket.options("adapter") !== null;
    4476. 

  4476.     },
    4477. 

  4477.     report: function(coverage_data){
    4478. 

  4478.         if (!document.getElementById("blanketLoaderDialog")){
    4479. 

  4479.             //all found, clear it
    4480. 

  4480.             _blanket.blanketSession = null;
    4481. 

  4481.         }
    4482. 

  4482.         coverage_data.files = window._$blanket;
    4483. 

  4483.         var require = blanket.options("commonJS") ? blanket._commonjs.require : window.require;
    4484. 

  4484. 

  4485.         // Check if we have any covered files that requires reporting
    4486. 

  4486.         // otherwise just exit gracefully.
    4487. 

  4487.         if (!coverage_data.files || !Object.keys(coverage_data.files).length) {
    4488. 

  4488.             if (_blanket.options("debug")) {console.log("BLANKET-Reporting No files were instrumented.");}
    4489. 

  4489.             return;
    4490. 

  4490.         }
    4491. 

  4491. 

  4492.         if (typeof coverage_data.files.branchFcn !== "undefined"){
    4493. 

  4493.             delete coverage_data.files.branchFcn;
    4494. 

  4494.         }
    4495. 

  4495.         if (typeof _blanket.options("reporter") === "string"){
    4496. 

  4496.             require([_blanket.options("reporter").replace(".js","")],function(r){
    4497. 

  4497.                 r(coverage_data,_blanket.options("reporter_options"));
    4498. 

  4498.             });
    4499. 

  4499.         }else if (typeof _blanket.options("reporter") === "function"){
    4500. 

  4500.             _blanket.options("reporter")(coverage_data);
    4501. 

  4501.         }else if (typeof _blanket.defaultReporter === 'function'){
    4502. 

  4502.             _blanket.defaultReporter(coverage_data);
    4503. 

  4503.         }else{
    4504. 

  4504.             throw new Error("no reporter defined.");
    4505. 

  4505.         }
    4506. 

  4506.     },
    4507. 

  4507.     _bindStartTestRunner: function(bindEvent,startEvent){
    4508. 

  4508.         if (bindEvent){
    4509. 

  4509.             bindEvent(startEvent);
    4510. 

  4510.         }else{
    4511. 

  4511.             window.addEventListener("load",startEvent,false);
    4512. 

  4512.         }
    4513. 

  4513.     },
    4514. 

  4514.     _loadSourceFiles: function(callback){
    4515. 

  4515.         console.log("ls1:"+new Date().getTime());
    4516. 

  4516.         var require = blanket.options("commonJS") ? blanket._commonjs.require : window.require;
    4517. 

  4517.         function copy(o){
    4518. 

  4518.           var _copy = Object.create( Object.getPrototypeOf(o) );
    4519. 

  4519.           var propNames = Object.getOwnPropertyNames(o);
    4520. 

  4520. 

  4521.           propNames.forEach(function(name){
    4522. 

  4522.             var desc = Object.getOwnPropertyDescriptor(o, name);
    4523. 

  4523.             Object.defineProperty(_copy, name, desc);
    4524. 

  4524.           });
    4525. 

  4525. 

  4526.           return _copy;
    4527. 

  4527.         }
    4528. 

  4528.         if (_blanket.options("debug")) {console.log("BLANKET-Collecting page scripts");}
    4529. 

  4529.         var scripts = _blanket.utils.collectPageScripts();
    4530. 

  4530.         //_blanket.options("filter",scripts);
    4531. 

  4531.         if (scripts.length === 0){
    4532. 

  4532.             callback();
    4533. 

  4533.         }else{
    4534. 

  4534. 

  4535.             //check session state
    4536. 

  4536.             if (sessionStorage["blanketSessionLoader"]){
    4537. 

  4537.                 _blanket.blanketSession = JSON.parse(sessionStorage["blanketSessionLoader"]);
    4538. 

  4538.             }
    4539. 

  4539. 

  4540.             var requireConfig = {
    4541. 

  4541.                 paths: {},
    4542. 

  4542.                 shim: {},
    4543. 

  4543.                 waitSeconds: _blanket.options("timeout")
    4544. 

  4544.             };
    4545. 

  4545.             var lastDep = {
    4546. 

  4546.                 deps: []
    4547. 

  4547.             };
    4548. 

  4548.             var isOrdered = _blanket.options("orderedLoading");
    4549. 

  4549.             var initialGet=[];
    4550. 

  4550.             scripts.forEach(function(file,indx){
    4551. 

  4551.                 //for whatever reason requirejs
    4552. 

  4552.                 //prefers when we don't use the full path
    4553. 

  4553.                 //so we just use a custom name
    4554. 

  4554.                 var requireKey = "blanket_"+indx;
    4555. 

  4555.                 initialGet.push(requireKey);
    4556. 

  4556.                 requireConfig.paths[requireKey] = file;
    4557. 

  4557.                 if (isOrdered){
    4558. 

  4558.                     if (indx > 0){
    4559. 

  4559.                        requireConfig.shim[requireKey] = copy(lastDep);
    4560. 

  4560.                     }
    4561. 

  4561.                     lastDep.deps = [requireKey];
    4562. 

  4562.                 }
    4563. 

  4563.             });
    4564. 

  4564.             require.config(requireConfig);
    4565. 

  4565.             var filt = initialGet;
    4566. 

  4566.             require(filt, function(){
    4567. 

  4567.                 callback();
    4568. 

  4568.             });
    4569. 

  4569.         }
    4570. 

  4570.         console.log("ls2:"+new Date().getTime());
    4571. 

  4571.     },
    4572. 

  4572.     beforeStartTestRunner: function(opts){
    4573. 

  4573.         opts = opts || {};
    4574. 

  4574.         opts.checkRequirejs = typeof opts.checkRequirejs === "undefined" ? true : opts.checkRequirejs;
    4575. 

  4575.         opts.callback = opts.callback || function() {  };
    4576. 

  4576.         opts.coverage = typeof opts.coverage === "undefined" ? true : opts.coverage;
    4577. 

  4577.         if (opts.coverage) {
    4578. 

  4578.             _blanket._bindStartTestRunner(opts.bindEvent,
    4579. 

  4579.             function(){
    4580. 

  4580.                 _blanket._loadSourceFiles(function() {
    4581. 

  4581. 

  4582.                     var allLoaded = function(){
    4583. 

  4583.                         return opts.condition ? opts.condition() : _blanket.requireFilesLoaded();
    4584. 

  4584.                     };
    4585. 

  4585.                     var check = function() {
    4586. 

  4586.                         if (allLoaded()) {
    4587. 

  4587.                             if (_blanket.options("debug")) {console.log("BLANKET-All files loaded, init start test runner callback.");}
    4588. 

  4588.                             var cb = _blanket.options("testReadyCallback");
    4589. 

  4589. 

  4590.                             if (cb){
    4591. 

  4591.                                 if (typeof cb === "function"){
    4592. 

  4592.                                     cb(opts.callback);
    4593. 

  4593.                                 }else if (typeof cb === "string"){
    4594. 

  4594.                                     eval(cb);
    4595. 

  4595.                                     opts.callback();
    4596. 

  4596.                                 }
    4597. 

  4597.                             }else{
    4598. 

  4598.                                 opts.callback();
    4599. 

  4599.                             }
    4600. 

  4600.                         } else {
    4601. 

  4601.                             setTimeout(check, 13);
    4602. 

  4602.                         }
    4603. 

  4603.                     };
    4604. 

  4604.                     check();
    4605. 

  4605.                 });
    4606. 

  4606.             });
    4607. 

  4607.         }else{
    4608. 

  4608.             opts.callback();
    4609. 

  4609.         }
    4610. 

  4610.     },
    4611. 

  4611.     utils: {
    4612. 

  4612.         qualifyURL: function (url) {
    4613. 

  4613.             //http://stackoverflow.com/questions/470832/getting-an-absolute-url-from-a-relative-one-ie6-issue
    4614. 

  4614.             var a = document.createElement('a');
    4615. 

  4615.             a.href = url;
    4616. 

  4616.             return a.href;
    4617. 

  4617.         }
    4618. 

  4618.     }
    4619. 

  4619. });
    4620. 

  4620. 

  4621. })(blanket);
    4622. 

  4622. 

  4623. blanket.setupRequireJS=function(context){
    4624. 

  4624. 

  4625. /** vim: et:ts=4:sw=4:sts=4
    4626. 

  4626.  * @license RequireJS 2.1.4 Copyright (c) 2010-2012, The Dojo Foundation All Rights Reserved.
    4627. 

  4627.  * Available via the MIT or new BSD license.
    4628. 

  4628.  * see: http://github.com/jrburke/requirejs for details
    4629. 

  4629.  */
    4630. 

  4630. //Not using strict: uneven strict support in browsers, #392, and causes
    4631. 

  4631. //problems with requirejs.exec()/transpiler plugins that may not be strict.
    4632. 

  4632. /*jslint regexp: true, nomen: true, sloppy: true */
    4633. 

  4633. /*global window, navigator, document, importScripts, setTimeout, opera */
    4634. 

  4634. 

  4635. var requirejs, require, define;
    4636. 

  4636. (function (global) {
    4637. 

  4637.     var req, s, head, baseElement, dataMain, src,
    4638. 

  4638.         interactiveScript, currentlyAddingScript, mainScript, subPath,
    4639. 

  4639.         version = '2.1.4',
    4640. 

  4640.         commentRegExp = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/mg,
    4641. 

  4641.         cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,
    4642. 

  4642.         jsSuffixRegExp = /\.js$/,
    4643. 

  4643.         currDirRegExp = /^\.\//,
    4644. 

  4644.         op = Object.prototype,
    4645. 

  4645.         ostring = op.toString,
    4646. 

  4646.         hasOwn = op.hasOwnProperty,
    4647. 

  4647.         ap = Array.prototype,
    4648. 

  4648.         apsp = ap.splice,
    4649. 

  4649.         isBrowser = !!(typeof window !== 'undefined' && navigator && document),
    4650. 

  4650.         isWebWorker = !isBrowser && typeof importScripts !== 'undefined',
    4651. 

  4651.         //PS3 indicates loaded and complete, but need to wait for complete
    4652. 

  4652.         //specifically. Sequence is 'loading', 'loaded', execution,
    4653. 

  4653.         // then 'complete'. The UA check is unfortunate, but not sure how
    4654. 

  4654.         //to feature test w/o causing perf issues.
    4655. 

  4655.         readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ?
    4656. 

  4656.                       /^complete$/ : /^(complete|loaded)$/,
    4657. 

  4657.         defContextName = '_',
    4658. 

  4658.         //Oh the tragedy, detecting opera. See the usage of isOpera for reason.
    4659. 

  4659.         isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]',
    4660. 

  4660.         contexts = {},
    4661. 

  4661.         cfg = {},
    4662. 

  4662.         globalDefQueue = [],
    4663. 

  4663.         useInteractive = false;
    4664. 

  4664. 

  4665.     function isFunction(it) {
    4666. 

  4666.         return ostring.call(it) === '[object Function]';
    4667. 

  4667.     }
    4668. 

  4668. 

  4669.     function isArray(it) {
    4670. 

  4670.         return ostring.call(it) === '[object Array]';
    4671. 

  4671.     }
    4672. 

  4672. 

  4673.     /**
    4674. 

  4674.      * Helper function for iterating over an array. If the func returns
    4675. 

  4675.      * a true value, it will break out of the loop.
    4676. 

  4676.      */
    4677. 

  4677.     function each(ary, func) {
    4678. 

  4678.         if (ary) {
    4679. 

  4679.             var i;
    4680. 

  4680.             for (i = 0; i < ary.length; i += 1) {
    4681. 

  4681.                 if (ary[i] && func(ary[i], i, ary)) {
    4682. 

  4682.                     break;
    4683. 

  4683.                 }
    4684. 

  4684.             }
    4685. 

  4685.         }
    4686. 

  4686.     }
    4687. 

  4687. 

  4688.     /**
    4689. 

  4689.      * Helper function for iterating over an array backwards. If the func
    4690. 

  4690.      * returns a true value, it will break out of the loop.
    4691. 

  4691.      */
    4692. 

  4692.     function eachReverse(ary, func) {
    4693. 

  4693.         if (ary) {
    4694. 

  4694.             var i;
    4695. 

  4695.             for (i = ary.length - 1; i > -1; i -= 1) {
    4696. 

  4696.                 if (ary[i] && func(ary[i], i, ary)) {
    4697. 

  4697.                     break;
    4698. 

  4698.                 }
    4699. 

  4699.             }
    4700. 

  4700.         }
    4701. 

  4701.     }
    4702. 

  4702. 

  4703.     function hasProp(obj, prop) {
    4704. 

  4704.         return hasOwn.call(obj, prop);
    4705. 

  4705.     }
    4706. 

  4706. 

  4707.     function getOwn(obj, prop) {
    4708. 

  4708.         return hasProp(obj, prop) && obj[prop];
    4709. 

  4709.     }
    4710. 

  4710. 

  4711.     /**
    4712. 

  4712.      * Cycles over properties in an object and calls a function for each
    4713. 

  4713.      * property value. If the function returns a truthy value, then the
    4714. 

  4714.      * iteration is stopped.
    4715. 

  4715.      */
    4716. 

  4716.     function eachProp(obj, func) {
    4717. 

  4717.         var prop;
    4718. 

  4718.         for (prop in obj) {
    4719. 

  4719.             if (hasProp(obj, prop)) {
    4720. 

  4720.                 if (func(obj[prop], prop)) {
    4721. 

  4721.                     break;
    4722. 

  4722.                 }
    4723. 

  4723.             }
    4724. 

  4724.         }
    4725. 

  4725.     }
    4726. 

  4726. 

  4727.     /**
    4728. 

  4728.      * Simple function to mix in properties from source into target,
    4729. 

  4729.      * but only if target does not already have a property of the same name.
    4730. 

  4730.      */
    4731. 

  4731.     function mixin(target, source, force, deepStringMixin) {
    4732. 

  4732.         if (source) {
    4733. 

  4733.             eachProp(source, function (value, prop) {
    4734. 

  4734.                 if (force || !hasProp(target, prop)) {
    4735. 

  4735.                     if (deepStringMixin && typeof value !== 'string') {
    4736. 

  4736.                         if (!target[prop]) {
    4737. 

  4737.                             target[prop] = {};
    4738. 

  4738.                         }
    4739. 

  4739.                         mixin(target[prop], value, force, deepStringMixin);
    4740. 

  4740.                     } else {
    4741. 

  4741.                         target[prop] = value;
    4742. 

  4742.                     }
    4743. 

  4743.                 }
    4744. 

  4744.             });
    4745. 

  4745.         }
    4746. 

  4746.         return target;
    4747. 

  4747.     }
    4748. 

  4748. 

  4749.     //Similar to Function.prototype.bind, but the 'this' object is specified
    4750. 

  4750.     //first, since it is easier to read/figure out what 'this' will be.
    4751. 

  4751.     function bind(obj, fn) {
    4752. 

  4752.         return function () {
    4753. 

  4753.             return fn.apply(obj, arguments);
    4754. 

  4754.         };
    4755. 

  4755.     }
    4756. 

  4756. 

  4757.     function scripts() {
    4758. 

  4758.         return document.getElementsByTagName('script');
    4759. 

  4759.     }
    4760. 

  4760. 

  4761.     //Allow getting a global that expressed in
    4762. 

  4762.     //dot notation, like 'a.b.c'.
    4763. 

  4763.     function getGlobal(value) {
    4764. 

  4764.         if (!value) {
    4765. 

  4765.             return value;
    4766. 

  4766.         }
    4767. 

  4767.         var g = global;
    4768. 

  4768.         each(value.split('.'), function (part) {
    4769. 

  4769.             g = g[part];
    4770. 

  4770.         });
    4771. 

  4771.         return g;
    4772. 

  4772.     }
    4773. 

  4773. 

  4774.     /**
    4775. 

  4775.      * Constructs an error with a pointer to an URL with more information.
    4776. 

  4776.      * @param {String} id the error ID that maps to an ID on a web page.
    4777. 

  4777.      * @param {String} message human readable error.
    4778. 

  4778.      * @param {Error} [err] the original error, if there is one.
    4779. 

  4779.      *
    4780. 

  4780.      * @returns {Error}
    4781. 

  4781.      */
    4782. 

  4782.     function makeError(id, msg, err, requireModules) {
    4783. 

  4783.         var e = new Error(msg + '\nhttp://requirejs.org/docs/errors.html#' + id);
    4784. 

  4784.         e.requireType = id;
    4785. 

  4785.         e.requireModules = requireModules;
    4786. 

  4786.         if (err) {
    4787. 

  4787.             e.originalError = err;
    4788. 

  4788.         }
    4789. 

  4789.         return e;
    4790. 

  4790.     }
    4791. 

  4791. 

  4792.     if (typeof define !== 'undefined') {
    4793. 

  4793.         //If a define is already in play via another AMD loader,
    4794. 

  4794.         //do not overwrite.
    4795. 

  4795.         return;
    4796. 

  4796.     }
    4797. 

  4797. 

  4798.     if (typeof requirejs !== 'undefined') {
    4799. 

  4799.         if (isFunction(requirejs)) {
    4800. 

  4800.             //Do not overwrite and existing requirejs instance.
    4801. 

  4801.             return;
    4802. 

  4802.         }
    4803. 

  4803.         cfg = requirejs;
    4804. 

  4804.         requirejs = undefined;
    4805. 

  4805.     }
    4806. 

  4806. 

  4807.     //Allow for a require config object
    4808. 

  4808.     if (typeof require !== 'undefined' && !isFunction(require)) {
    4809. 

  4809.         //assume it is a config object.
    4810. 

  4810.         cfg = require;
    4811. 

  4811.         require = undefined;
    4812. 

  4812.     }
    4813. 

  4813. 

  4814.     function newContext(contextName) {
    4815. 

  4815.         var inCheckLoaded, Module, context, handlers,
    4816. 

  4816.             checkLoadedTimeoutId,
    4817. 

  4817.             config = {
    4818. 

  4818.                 waitSeconds: 7,
    4819. 

  4819.                 baseUrl: './',
    4820. 

  4820.                 paths: {},
    4821. 

  4821.                 pkgs: {},
    4822. 

  4822.                 shim: {},
    4823. 

  4823.                 map: {},
    4824. 

  4824.                 config: {}
    4825. 

  4825.             },
    4826. 

  4826.             registry = {},
    4827. 

  4827.             undefEvents = {},
    4828. 

  4828.             defQueue = [],
    4829. 

  4829.             defined = {},
    4830. 

  4830.             urlFetched = {},
    4831. 

  4831.             requireCounter = 1,
    4832. 

  4832.             unnormalizedCounter = 1;
    4833. 

  4833. 

  4834.         /**
    4835. 

  4835.          * Trims the . and .. from an array of path segments.
    4836. 

  4836.          * It will keep a leading path segment if a .. will become
    4837. 

  4837.          * the first path segment, to help with module name lookups,
    4838. 

  4838.          * which act like paths, but can be remapped. But the end result,
    4839. 

  4839.          * all paths that use this function should look normalized.
    4840. 

  4840.          * NOTE: this method MODIFIES the input array.
    4841. 

  4841.          * @param {Array} ary the array of path segments.
    4842. 

  4842.          */
    4843. 

  4843.         function trimDots(ary) {
    4844. 

  4844.             var i, part;
    4845. 

  4845.             for (i = 0; ary[i]; i += 1) {
    4846. 

  4846.                 part = ary[i];
    4847. 

  4847.                 if (part === '.') {
    4848. 

  4848.                     ary.splice(i, 1);
    4849. 

  4849.                     i -= 1;
    4850. 

  4850.                 } else if (part === '..') {
    4851. 

  4851.                     if (i === 1 && (ary[2] === '..' || ary[0] === '..')) {
    4852. 

  4852.                         //End of the line. Keep at least one non-dot
    4853. 

  4853.                         //path segment at the front so it can be mapped
    4854. 

  4854.                         //correctly to disk. Otherwise, there is likely
    4855. 

  4855.                         //no path mapping for a path starting with '..'.
    4856. 

  4856.                         //This can still fail, but catches the most reasonable
    4857. 

  4857.                         //uses of ..
    4858. 

  4858.                         break;
    4859. 

  4859.                     } else if (i > 0) {
    4860. 

  4860.                         ary.splice(i - 1, 2);
    4861. 

  4861.                         i -= 2;
    4862. 

  4862.                     }
    4863. 

  4863.                 }
    4864. 

  4864.             }
    4865. 

  4865.         }
    4866. 

  4866. 

  4867.         /**
    4868. 

  4868.          * Given a relative module name, like ./something, normalize it to
    4869. 

  4869.          * a real name that can be mapped to a path.
    4870. 

  4870.          * @param {String} name the relative name
    4871. 

  4871.          * @param {String} baseName a real name that the name arg is relative
    4872. 

  4872.          * to.
    4873. 

  4873.          * @param {Boolean} applyMap apply the map config to the value. Should
    4874. 

  4874.          * only be done if this normalization is for a dependency ID.
    4875. 

  4875.          * @returns {String} normalized name
    4876. 

  4876.          */
    4877. 

  4877.         function normalize(name, baseName, applyMap) {
    4878. 

  4878.             var pkgName, pkgConfig, mapValue, nameParts, i, j, nameSegment,
    4879. 

  4879.                 foundMap, foundI, foundStarMap, starI,
    4880. 

  4880.                 baseParts = baseName && baseName.split('/'),
    4881. 

  4881.                 normalizedBaseParts = baseParts,
    4882. 

  4882.                 map = config.map,
    4883. 

  4883.                 starMap = map && map['*'];
    4884. 

  4884. 

  4885.             //Adjust any relative paths.
    4886. 

  4886.             if (name && name.charAt(0) === '.') {
    4887. 

  4887.                 //If have a base name, try to normalize against it,
    4888. 

  4888.                 //otherwise, assume it is a top-level require that will
    4889. 

  4889.                 //be relative to baseUrl in the end.
    4890. 

  4890.                 if (baseName) {
    4891. 

  4891.                     if (getOwn(config.pkgs, baseName)) {
    4892. 

  4892.                         //If the baseName is a package name, then just treat it as one
    4893. 

  4893.                         //name to concat the name with.
    4894. 

  4894.                         normalizedBaseParts = baseParts = [baseName];
    4895. 

  4895.                     } else {
    4896. 

  4896.                         //Convert baseName to array, and lop off the last part,
    4897. 

  4897.                         //so that . matches that 'directory' and not name of the baseName's
    4898. 

  4898.                         //module. For instance, baseName of 'one/two/three', maps to
    4899. 

  4899.                         //'one/two/three.js', but we want the directory, 'one/two' for
    4900. 

  4900.                         //this normalization.
    4901. 

  4901.                         normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
    4902. 

  4902.                     }
    4903. 

  4903. 

  4904.                     name = normalizedBaseParts.concat(name.split('/'));
    4905. 

  4905.                     trimDots(name);
    4906. 

  4906. 

  4907.                     //Some use of packages may use a . path to reference the
    4908. 

  4908.                     //'main' module name, so normalize for that.
    4909. 

  4909.                     pkgConfig = getOwn(config.pkgs, (pkgName = name[0]));
    4910. 

  4910.                     name = name.join('/');
    4911. 

  4911.                     if (pkgConfig && name === pkgName + '/' + pkgConfig.main) {
    4912. 

  4912.                         name = pkgName;
    4913. 

  4913.                     }
    4914. 

  4914.                 } else if (name.indexOf('./') === 0) {
    4915. 

  4915.                     // No baseName, so this is ID is resolved relative
    4916. 

  4916.                     // to baseUrl, pull off the leading dot.
    4917. 

  4917.                     name = name.substring(2);
    4918. 

  4918.                 }
    4919. 

  4919.             }
    4920. 

  4920. 

  4921.             //Apply map config if available.
    4922. 

  4922.             if (applyMap && (baseParts || starMap) && map) {
    4923. 

  4923.                 nameParts = name.split('/');
    4924. 

  4924. 

  4925.                 for (i = nameParts.length; i > 0; i -= 1) {
    4926. 

  4926.                     nameSegment = nameParts.slice(0, i).join('/');
    4927. 

  4927. 

  4928.                     if (baseParts) {
    4929. 

  4929.                         //Find the longest baseName segment match in the config.
    4930. 

  4930.                         //So, do joins on the biggest to smallest lengths of baseParts.
    4931. 

  4931.                         for (j = baseParts.length; j > 0; j -= 1) {
    4932. 

  4932.                             mapValue = getOwn(map, baseParts.slice(0, j).join('/'));
    4933. 

  4933. 

  4934.                             //baseName segment has config, find if it has one for
    4935. 

  4935.                             //this name.
    4936. 

  4936.                             if (mapValue) {
    4937. 

  4937.                                 mapValue = getOwn(mapValue, nameSegment);
    4938. 

  4938.                                 if (mapValue) {
    4939. 

  4939.                                     //Match, update name to the new value.
    4940. 

  4940.                                     foundMap = mapValue;
    4941. 

  4941.                                     foundI = i;
    4942. 

  4942.                                     break;
    4943. 

  4943.                                 }
    4944. 

  4944.                             }
    4945. 

  4945.                         }
    4946. 

  4946.                     }
    4947. 

  4947. 

  4948.                     if (foundMap) {
    4949. 

  4949.                         break;
    4950. 

  4950.                     }
    4951. 

  4951. 

  4952.                     //Check for a star map match, but just hold on to it,
    4953. 

  4953.                     //if there is a shorter segment match later in a matching
    4954. 

  4954.                     //config, then favor over this star map.
    4955. 

  4955.                     if (!foundStarMap && starMap && getOwn(starMap, nameSegment)) {
    4956. 

  4956.                         foundStarMap = getOwn(starMap, nameSegment);
    4957. 

  4957.                         starI = i;
    4958. 

  4958.                     }
    4959. 

  4959.                 }
    4960. 

  4960. 

  4961.                 if (!foundMap && foundStarMap) {
    4962. 

  4962.                     foundMap = foundStarMap;
    4963. 

  4963.                     foundI = starI;
    4964. 

  4964.                 }
    4965. 

  4965. 

  4966.                 if (foundMap) {
    4967. 

  4967.                     nameParts.splice(0, foundI, foundMap);
    4968. 

  4968.                     name = nameParts.join('/');
    4969. 

  4969.                 }
    4970. 

  4970.             }
    4971. 

  4971. 

  4972.             return name;
    4973. 

  4973.         }
    4974. 

  4974. 

  4975.         function removeScript(name) {
    4976. 

  4976.             if (isBrowser) {
    4977. 

  4977.                 each(scripts(), function (scriptNode) {
    4978. 

  4978.                     if (scriptNode.getAttribute('data-requiremodule') === name &&
    4979. 

  4979.                             scriptNode.getAttribute('data-requirecontext') === context.contextName) {
    4980. 

  4980.                         scriptNode.parentNode.removeChild(scriptNode);
    4981. 

  4981.                         return true;
    4982. 

  4982.                     }
    4983. 

  4983.                 });
    4984. 

  4984.             }
    4985. 

  4985.         }
    4986. 

  4986. 

  4987.         function hasPathFallback(id) {
    4988. 

  4988.             var pathConfig = getOwn(config.paths, id);
    4989. 

  4989.             if (pathConfig && isArray(pathConfig) && pathConfig.length > 1) {
    4990. 

  4990.                 removeScript(id);
    4991. 

  4991.                 //Pop off the first array value, since it failed, and
    4992. 

  4992.                 //retry
    4993. 

  4993.                 pathConfig.shift();
    4994. 

  4994.                 context.require.undef(id);
    4995. 

  4995.                 context.require([id]);
    4996. 

  4996.                 return true;
    4997. 

  4997.             }
    4998. 

  4998.         }
    4999. 

  4999. 

  5000.         //Turns a plugin!resource to [plugin, resource]
    5001. 

  5001.         //with the plugin being undefined if the name
    5002. 

  5002.         //did not have a plugin prefix.
    5003. 

  5003.         function splitPrefix(name) {
    5004. 

  5004.             var prefix,
    5005. 

  5005.                 index = name ? name.indexOf('!') : -1;
    5006. 

  5006.             if (index > -1) {
    5007. 

  5007.                 prefix = name.substring(0, index);
    5008. 

  5008.                 name = name.substring(index + 1, name.length);
    5009. 

  5009.             }
    5010. 

  5010.             return [prefix, name];
    5011. 

  5011.         }
    5012. 

  5012. 

  5013.         /**
    5014. 

  5014.          * Creates a module mapping that includes plugin prefix, module
    5015. 

  5015.          * name, and path. If parentModuleMap is provided it will
    5016. 

  5016.          * also normalize the name via require.normalize()
    5017. 

  5017.          *
    5018. 

  5018.          * @param {String} name the module name
    5019. 

  5019.          * @param {String} [parentModuleMap] parent module map
    5020. 

  5020.          * for the module name, used to resolve relative names.
    5021. 

  5021.          * @param {Boolean} isNormalized: is the ID already normalized.
    5022. 

  5022.          * This is true if this call is done for a define() module ID.
    5023. 

  5023.          * @param {Boolean} applyMap: apply the map config to the ID.
    5024. 

  5024.          * Should only be true if this map is for a dependency.
    5025. 

  5025.          *
    5026. 

  5026.          * @returns {Object}
    5027. 

  5027.          */
    5028. 

  5028.         function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {
    5029. 

  5029.             var url, pluginModule, suffix, nameParts,
    5030. 

  5030.                 prefix = null,
    5031. 

  5031.                 parentName = parentModuleMap ? parentModuleMap.name : null,
    5032. 

  5032.                 originalName = name,
    5033. 

  5033.                 isDefine = true,
    5034. 

  5034.                 normalizedName = '';
    5035. 

  5035. 

  5036.             //If no name, then it means it is a require call, generate an
    5037. 

  5037.             //internal name.
    5038. 

  5038.             if (!name) {
    5039. 

  5039.                 isDefine = false;
    5040. 

  5040.                 name = '_@r' + (requireCounter += 1);
    5041. 

  5041.             }
    5042. 

  5042. 

  5043.             nameParts = splitPrefix(name);
    5044. 

  5044.             prefix = nameParts[0];
    5045. 

  5045.             name = nameParts[1];
    5046. 

  5046. 

  5047.             if (prefix) {
    5048. 

  5048.                 prefix = normalize(prefix, parentName, applyMap);
    5049. 

  5049.                 pluginModule = getOwn(defined, prefix);
    5050. 

  5050.             }
    5051. 

  5051. 

  5052.             //Account for relative paths if there is a base name.
    5053. 

  5053.             if (name) {
    5054. 

  5054.                 if (prefix) {
    5055. 

  5055.                     if (pluginModule && pluginModule.normalize) {
    5056. 

  5056.                         //Plugin is loaded, use its normalize method.
    5057. 

  5057.                         normalizedName = pluginModule.normalize(name, function (name) {
    5058. 

  5058.                             return normalize(name, parentName, applyMap);
    5059. 

  5059.                         });
    5060. 

  5060.                     } else {
    5061. 

  5061.                         normalizedName = normalize(name, parentName, applyMap);
    5062. 

  5062.                     }
    5063. 

  5063.                 } else {
    5064. 

  5064.                     //A regular module.
    5065. 

  5065.                     normalizedName = normalize(name, parentName, applyMap);
    5066. 

  5066. 

  5067.                     //Normalized name may be a plugin ID due to map config
    5068. 

  5068.                     //application in normalize. The map config values must
    5069. 

  5069.                     //already be normalized, so do not need to redo that part.
    5070. 

  5070.                     nameParts = splitPrefix(normalizedName);
    5071. 

  5071.                     prefix = nameParts[0];
    5072. 

  5072.                     normalizedName = nameParts[1];
    5073. 

  5073.                     isNormalized = true;
    5074. 

  5074. 

  5075.                     url = context.nameToUrl(normalizedName);
    5076. 

  5076.                 }
    5077. 

  5077.             }
    5078. 

  5078. 

  5079.             //If the id is a plugin id that cannot be determined if it needs
    5080. 

  5080.             //normalization, stamp it with a unique ID so two matching relative
    5081. 

  5081.             //ids that may conflict can be separate.
    5082. 

  5082.             suffix = prefix && !pluginModule && !isNormalized ?
    5083. 

  5083.                      '_unnormalized' + (unnormalizedCounter += 1) :
    5084. 

  5084.                      '';
    5085. 

  5085. 

  5086.             return {
    5087. 

  5087.                 prefix: prefix,
    5088. 

  5088.                 name: normalizedName,
    5089. 

  5089.                 parentMap: parentModuleMap,
    5090. 

  5090.                 unnormalized: !!suffix,
    5091. 

  5091.                 url: url,
    5092. 

  5092.                 originalName: originalName,
    5093. 

  5093.                 isDefine: isDefine,
    5094. 

  5094.                 id: (prefix ?
    5095. 

  5095.                         prefix + '!' + normalizedName :
    5096. 

  5096.                         normalizedName) + suffix
    5097. 

  5097.             };
    5098. 

  5098.         }
    5099. 

  5099. 

  5100.         function getModule(depMap) {
    5101. 

  5101.             var id = depMap.id,
    5102. 

  5102.                 mod = getOwn(registry, id);
    5103. 

  5103. 

  5104.             if (!mod) {
    5105. 

  5105.                 mod = registry[id] = new context.Module(depMap);
    5106. 

  5106.             }
    5107. 

  5107. 

  5108.             return mod;
    5109. 

  5109.         }
    5110. 

  5110. 

  5111.         function on(depMap, name, fn) {
    5112. 

  5112.             var id = depMap.id,
    5113. 

  5113.                 mod = getOwn(registry, id);
    5114. 

  5114. 

  5115.             if (hasProp(defined, id) &&
    5116. 

  5116.                     (!mod || mod.defineEmitComplete)) {
    5117. 

  5117.                 if (name === 'defined') {
    5118. 

  5118.                     fn(defined[id]);
    5119. 

  5119.                 }
    5120. 

  5120.             } else {
    5121. 

  5121.                 getModule(depMap).on(name, fn);
    5122. 

  5122.             }
    5123. 

  5123.         }
    5124. 

  5124. 

  5125.         function onError(err, errback) {
    5126. 

  5126.             var ids = err.requireModules,
    5127. 

  5127.                 notified = false;
    5128. 

  5128. 

  5129.             if (errback) {
    5130. 

  5130.                 errback(err);
    5131. 

  5131.             } else {
    5132. 

  5132.                 each(ids, function (id) {
    5133. 

  5133.                     var mod = getOwn(registry, id);
    5134. 

  5134.                     if (mod) {
    5135. 

  5135.                         //Set error on module, so it skips timeout checks.
    5136. 

  5136.                         mod.error = err;
    5137. 

  5137.                         if (mod.events.error) {
    5138. 

  5138.                             notified = true;
    5139. 

  5139.                             mod.emit('error', err);
    5140. 

  5140.                         }
    5141. 

  5141.                     }
    5142. 

  5142.                 });
    5143. 

  5143. 

  5144.                 if (!notified) {
    5145. 

  5145.                     req.onError(err);
    5146. 

  5146.                 }
    5147. 

  5147.             }
    5148. 

  5148.         }
    5149. 

  5149. 

  5150.         /**
    5151. 

  5151.          * Internal method to transfer globalQueue items to this context's
    5152. 

  5152.          * defQueue.
    5153. 

  5153.          */
    5154. 

  5154.         function takeGlobalQueue() {
    5155. 

  5155.             //Push all the globalDefQueue items into the context's defQueue
    5156. 

  5156.             if (globalDefQueue.length) {
    5157. 

  5157.                 //Array splice in the values since the context code has a
    5158. 

  5158.                 //local var ref to defQueue, so cannot just reassign the one
    5159. 

  5159.                 //on context.
    5160. 

  5160.                 apsp.apply(defQueue,
    5161. 

  5161.                            [defQueue.length - 1, 0].concat(globalDefQueue));
    5162. 

  5162.                 globalDefQueue = [];
    5163. 

  5163.             }
    5164. 

  5164.         }
    5165. 

  5165. 

  5166.         handlers = {
    5167. 

  5167.             'require': function (mod) {
    5168. 

  5168.                 if (mod.require) {
    5169. 

  5169.                     return mod.require;
    5170. 

  5170.                 } else {
    5171. 

  5171.                     return (mod.require = context.makeRequire(mod.map));
    5172. 

  5172.                 }
    5173. 

  5173.             },
    5174. 

  5174.             'exports': function (mod) {
    5175. 

  5175.                 mod.usingExports = true;
    5176. 

  5176.                 if (mod.map.isDefine) {
    5177. 

  5177.                     if (mod.exports) {
    5178. 

  5178.                         return mod.exports;
    5179. 

  5179.                     } else {
    5180. 

  5180.                         return (mod.exports = defined[mod.map.id] = {});
    5181. 

  5181.                     }
    5182. 

  5182.                 }
    5183. 

  5183.             },
    5184. 

  5184.             'module': function (mod) {
    5185. 

  5185.                 if (mod.module) {
    5186. 

  5186.                     return mod.module;
    5187. 

  5187.                 } else {
    5188. 

  5188.                     return (mod.module = {
    5189. 

  5189.                         id: mod.map.id,
    5190. 

  5190.                         uri: mod.map.url,
    5191. 

  5191.                         config: function () {
    5192. 

  5192.                             return (config.config && getOwn(config.config, mod.map.id)) || {};
    5193. 

  5193.                         },
    5194. 

  5194.                         exports: defined[mod.map.id]
    5195. 

  5195.                     });
    5196. 

  5196.                 }
    5197. 

  5197.             }
    5198. 

  5198.         };
    5199. 

  5199. 

  5200.         function cleanRegistry(id) {
    5201. 

  5201.             //Clean up machinery used for waiting modules.
    5202. 

  5202.             delete registry[id];
    5203. 

  5203.         }
    5204. 

  5204. 

  5205.         function breakCycle(mod, traced, processed) {
    5206. 

  5206.             var id = mod.map.id;
    5207. 

  5207. 

  5208.             if (mod.error) {
    5209. 

  5209.                 mod.emit('error', mod.error);
    5210. 

  5210.             } else {
    5211. 

  5211.                 traced[id] = true;
    5212. 

  5212.                 each(mod.depMaps, function (depMap, i) {
    5213. 

  5213.                     var depId = depMap.id,
    5214. 

  5214.                         dep = getOwn(registry, depId);
    5215. 

  5215. 

  5216.                     //Only force things that have not completed
    5217. 

  5217.                     //being defined, so still in the registry,
    5218. 

  5218.                     //and only if it has not been matched up
    5219. 

  5219.                     //in the module already.
    5220. 

  5220.                     if (dep && !mod.depMatched[i] && !processed[depId]) {
    5221. 

  5221.                         if (getOwn(traced, depId)) {
    5222. 

  5222.                             mod.defineDep(i, defined[depId]);
    5223. 

  5223.                             mod.check(); //pass false?
    5224. 

  5224.                         } else {
    5225. 

  5225.                             breakCycle(dep, traced, processed);
    5226. 

  5226.                         }
    5227. 

  5227.                     }
    5228. 

  5228.                 });
    5229. 

  5229.                 processed[id] = true;
    5230. 

  5230.             }
    5231. 

  5231.         }
    5232. 

  5232. 

  5233.         function checkLoaded() {
    5234. 

  5234.             var map, modId, err, usingPathFallback,
    5235. 

  5235.                 waitInterval = config.waitSeconds * 1000,
    5236. 

  5236.                 //It is possible to disable the wait interval by using waitSeconds of 0.
    5237. 

  5237.                 expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
    5238. 

  5238.                 noLoads = [],
    5239. 

  5239.                 reqCalls = [],
    5240. 

  5240.                 stillLoading = false,
    5241. 

  5241.                 needCycleCheck = true;
    5242. 

  5242. 

  5243.             //Do not bother if this call was a result of a cycle break.
    5244. 

  5244.             if (inCheckLoaded) {
    5245. 

  5245.                 return;
    5246. 

  5246.             }
    5247. 

  5247. 

  5248.             inCheckLoaded = true;
    5249. 

  5249. 

  5250.             //Figure out the state of all the modules.
    5251. 

  5251.             eachProp(registry, function (mod) {
    5252. 

  5252.                 map = mod.map;
    5253. 

  5253.                 modId = map.id;
    5254. 

  5254. 

  5255.                 //Skip things that are not enabled or in error state.
    5256. 

  5256.                 if (!mod.enabled) {
    5257. 

  5257.                     return;
    5258. 

  5258.                 }
    5259. 

  5259. 

  5260.                 if (!map.isDefine) {
    5261. 

  5261.                     reqCalls.push(mod);
    5262. 

  5262.                 }
    5263. 

  5263. 

  5264.                 if (!mod.error) {
    5265. 

  5265.                     //If the module should be executed, and it has not
    5266. 

  5266.                     //been inited and time is up, remember it.
    5267. 

  5267.                     if (!mod.inited && expired) {
    5268. 

  5268.                         if (hasPathFallback(modId)) {
    5269. 

  5269.                             usingPathFallback = true;
    5270. 

  5270.                             stillLoading = true;
    5271. 

  5271.                         } else {
    5272. 

  5272.                             noLoads.push(modId);
    5273. 

  5273.                             removeScript(modId);
    5274. 

  5274.                         }
    5275. 

  5275.                     } else if (!mod.inited && mod.fetched && map.isDefine) {
    5276. 

  5276.                         stillLoading = true;
    5277. 

  5277.                         if (!map.prefix) {
    5278. 

  5278.                             //No reason to keep looking for unfinished
    5279. 

  5279.                             //loading. If the only stillLoading is a
    5280. 

  5280.                             //plugin resource though, keep going,
    5281. 

  5281.                             //because it may be that a plugin resource
    5282. 

  5282.                             //is waiting on a non-plugin cycle.
    5283. 

  5283.                             return (needCycleCheck = false);
    5284. 

  5284.                         }
    5285. 

  5285.                     }
    5286. 

  5286.                 }
    5287. 

  5287.             });
    5288. 

  5288. 

  5289.             if (expired && noLoads.length) {
    5290. 

  5290.                 //If wait time expired, throw error of unloaded modules.
    5291. 

  5291.                 err = makeError('timeout', 'Load timeout for modules: ' + noLoads, null, noLoads);
    5292. 

  5292.                 err.contextName = context.contextName;
    5293. 

  5293.                 return onError(err);
    5294. 

  5294.             }
    5295. 

  5295. 

  5296.             //Not expired, check for a cycle.
    5297. 

  5297.             if (needCycleCheck) {
    5298. 

  5298.                 each(reqCalls, function (mod) {
    5299. 

  5299.                     breakCycle(mod, {}, {});
    5300. 

  5300.                 });
    5301. 

  5301.             }
    5302. 

  5302. 

  5303.             //If still waiting on loads, and the waiting load is something
    5304. 

  5304.             //other than a plugin resource, or there are still outstanding
    5305. 

  5305.             //scripts, then just try back later.
    5306. 

  5306.             if ((!expired || usingPathFallback) && stillLoading) {
    5307. 

  5307.                 //Something is still waiting to load. Wait for it, but only
    5308. 

  5308.                 //if a timeout is not already in effect.
    5309. 

  5309.                 if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {
    5310. 

  5310.                     checkLoadedTimeoutId = setTimeout(function () {
    5311. 

  5311.                         checkLoadedTimeoutId = 0;
    5312. 

  5312.                         checkLoaded();
    5313. 

  5313.                     }, 50);
    5314. 

  5314.                 }
    5315. 

  5315.             }
    5316. 

  5316. 

  5317.             inCheckLoaded = false;
    5318. 

  5318.         }
    5319. 

  5319. 

  5320.         Module = function (map) {
    5321. 

  5321.             this.events = getOwn(undefEvents, map.id) || {};
    5322. 

  5322.             this.map = map;
    5323. 

  5323.             this.shim = getOwn(config.shim, map.id);
    5324. 

  5324.             this.depExports = [];
    5325. 

  5325.             this.depMaps = [];
    5326. 

  5326.             this.depMatched = [];
    5327. 

  5327.             this.pluginMaps = {};
    5328. 

  5328.             this.depCount = 0;
    5329. 

  5329. 

  5330.             /* this.exports this.factory
    5331. 

  5331.                this.depMaps = [],
    5332. 

  5332.                this.enabled, this.fetched
    5333. 

  5333.             */
    5334. 

  5334.         };
    5335. 

  5335. 

  5336.         Module.prototype = {
    5337. 

  5337.             init: function (depMaps, factory, errback, options) {
    5338. 

  5338.                 options = options || {};
    5339. 

  5339. 

  5340.                 //Do not do more inits if already done. Can happen if there
    5341. 

  5341.                 //are multiple define calls for the same module. That is not
    5342. 

  5342.                 //a normal, common case, but it is also not unexpected.
    5343. 

  5343.                 if (this.inited) {
    5344. 

  5344.                     return;
    5345. 

  5345.                 }
    5346. 

  5346. 

  5347.                 this.factory = factory;
    5348. 

  5348. 

  5349.                 if (errback) {
    5350. 

  5350.                     //Register for errors on this module.
    5351. 

  5351.                     this.on('error', errback);
    5352. 

  5352.                 } else if (this.events.error) {
    5353. 

  5353.                     //If no errback already, but there are error listeners
    5354. 

  5354.                     //on this module, set up an errback to pass to the deps.
    5355. 

  5355.                     errback = bind(this, function (err) {
    5356. 

  5356.                         this.emit('error', err);
    5357. 

  5357.                     });
    5358. 

  5358.                 }
    5359. 

  5359. 

  5360.                 //Do a copy of the dependency array, so that
    5361. 

  5361.                 //source inputs are not modified. For example
    5362. 

  5362.                 //"shim" deps are passed in here directly, and
    5363. 

  5363.                 //doing a direct modification of the depMaps array
    5364. 

  5364.                 //would affect that config.
    5365. 

  5365.                 this.depMaps = depMaps && depMaps.slice(0);
    5366. 

  5366. 

  5367.                 this.errback = errback;
    5368. 

  5368. 

  5369.                 //Indicate this module has be initialized
    5370. 

  5370.                 this.inited = true;
    5371. 

  5371. 

  5372.                 this.ignore = options.ignore;
    5373. 

  5373. 

  5374.                 //Could have option to init this module in enabled mode,
    5375. 

  5375.                 //or could have been previously marked as enabled. However,
    5376. 

  5376.                 //the dependencies are not known until init is called. So
    5377. 

  5377.                 //if enabled previously, now trigger dependencies as enabled.
    5378. 

  5378.                 if (options.enabled || this.enabled) {
    5379. 

  5379.                     //Enable this module and dependencies.
    5380. 

  5380.                     //Will call this.check()
    5381. 

  5381.                     this.enable();
    5382. 

  5382.                 } else {
    5383. 

  5383.                     this.check();
    5384. 

  5384.                 }
    5385. 

  5385.             },
    5386. 

  5386. 

  5387.             defineDep: function (i, depExports) {
    5388. 

  5388.                 //Because of cycles, defined callback for a given
    5389. 

  5389.                 //export can be called more than once.
    5390. 

  5390.                 if (!this.depMatched[i]) {
    5391. 

  5391.                     this.depMatched[i] = true;
    5392. 

  5392.                     this.depCount -= 1;
    5393. 

  5393.                     this.depExports[i] = depExports;
    5394. 

  5394.                 }
    5395. 

  5395.             },
    5396. 

  5396. 

  5397.             fetch: function () {
    5398. 

  5398.                 if (this.fetched) {
    5399. 

  5399.                     return;
    5400. 

  5400.                 }
    5401. 

  5401.                 this.fetched = true;
    5402. 

  5402. 

  5403.                 context.startTime = (new Date()).getTime();
    5404. 

  5404. 

  5405.                 var map = this.map;
    5406. 

  5406. 

  5407.                 //If the manager is for a plugin managed resource,
    5408. 

  5408.                 //ask the plugin to load it now.
    5409. 

  5409.                 if (this.shim) {
    5410. 

  5410.                     context.makeRequire(this.map, {
    5411. 

  5411.                         enableBuildCallback: true
    5412. 

  5412.                     })(this.shim.deps || [], bind(this, function () {
    5413. 

  5413.                         return map.prefix ? this.callPlugin() : this.load();
    5414. 

  5414.                     }));
    5415. 

  5415.                 } else {
    5416. 

  5416.                     //Regular dependency.
    5417. 

  5417.                     return map.prefix ? this.callPlugin() : this.load();
    5418. 

  5418.                 }
    5419. 

  5419.             },
    5420. 

  5420. 

  5421.             load: function () {
    5422. 

  5422.                 var url = this.map.url;
    5423. 

  5423. 

  5424.                 //Regular dependency.
    5425. 

  5425.                 if (!urlFetched[url]) {
    5426. 

  5426.                     urlFetched[url] = true;
    5427. 

  5427.                     context.load(this.map.id, url);
    5428. 

  5428.                 }
    5429. 

  5429.             },
    5430. 

  5430. 

  5431.             /**
    5432. 

  5432.              * Checks is the module is ready to define itself, and if so,
    5433. 

  5433.              * define it.
    5434. 

  5434.              */
    5435. 

  5435.             check: function () {
    5436. 

  5436.                 if (!this.enabled || this.enabling) {
    5437. 

  5437.                     return;
    5438. 

  5438.                 }
    5439. 

  5439. 

  5440.                 var err, cjsModule,
    5441. 

  5441.                     id = this.map.id,
    5442. 

  5442.                     depExports = this.depExports,
    5443. 

  5443.                     exports = this.exports,
    5444. 

  5444.                     factory = this.factory;
    5445. 

  5445. 

  5446.                 if (!this.inited) {
    5447. 

  5447.                     this.fetch();
    5448. 

  5448.                 } else if (this.error) {
    5449. 

  5449.                     this.emit('error', this.error);
    5450. 

  5450.                 } else if (!this.defining) {
    5451. 

  5451.                     //The factory could trigger another require call
    5452. 

  5452.                     //that would result in checking this module to
    5453. 

  5453.                     //define itself again. If already in the process
    5454. 

  5454.                     //of doing that, skip this work.
    5455. 

  5455.                     this.defining = true;
    5456. 

  5456. 

  5457.                     if (this.depCount < 1 && !this.defined) {
    5458. 

  5458.                         if (isFunction(factory)) {
    5459. 

  5459.                             //If there is an error listener, favor passing
    5460. 

  5460.                             //to that instead of throwing an error.
    5461. 

  5461.                             if (this.events.error) {
    5462. 

  5462.                                 try {
    5463. 

  5463.                                     exports = context.execCb(id, factory, depExports, exports);
    5464. 

  5464.                                 } catch (e) {
    5465. 

  5465.                                     err = e;
    5466. 

  5466.                                 }
    5467. 

  5467.                             } else {
    5468. 

  5468.                                 exports = context.execCb(id, factory, depExports, exports);
    5469. 

  5469.                             }
    5470. 

  5470. 

  5471.                             if (this.map.isDefine) {
    5472. 

  5472.                                 //If setting exports via 'module' is in play,
    5473. 

  5473.                                 //favor that over return value and exports. After that,
    5474. 

  5474.                                 //favor a non-undefined return value over exports use.
    5475. 

  5475.                                 cjsModule = this.module;
    5476. 

  5476.                                 if (cjsModule &&
    5477. 

  5477.                                         cjsModule.exports !== undefined &&
    5478. 

  5478.                                         //Make sure it is not already the exports value
    5479. 

  5479.                                         cjsModule.exports !== this.exports) {
    5480. 

  5480.                                     exports = cjsModule.exports;
    5481. 

  5481.                                 } else if (exports === undefined && this.usingExports) {
    5482. 

  5482.                                     //exports already set the defined value.
    5483. 

  5483.                                     exports = this.exports;
    5484. 

  5484.                                 }
    5485. 

  5485.                             }
    5486. 

  5486. 

  5487.                             if (err) {
    5488. 

  5488.                                 err.requireMap = this.map;
    5489. 

  5489.                                 err.requireModules = [this.map.id];
    5490. 

  5490.                                 err.requireType = 'define';
    5491. 

  5491.                                 return onError((this.error = err));
    5492. 

  5492.                             }
    5493. 

  5493. 

  5494.                         } else {
    5495. 

  5495.                             //Just a literal value
    5496. 

  5496.                             exports = factory;
    5497. 

  5497.                         }
    5498. 

  5498. 

  5499.                         this.exports = exports;
    5500. 

  5500. 

  5501.                         if (this.map.isDefine && !this.ignore) {
    5502. 

  5502.                             defined[id] = exports;
    5503. 

  5503. 

  5504.                             if (req.onResourceLoad) {
    5505. 

  5505.                                 req.onResourceLoad(context, this.map, this.depMaps);
    5506. 

  5506.                             }
    5507. 

  5507.                         }
    5508. 

  5508. 

  5509.                         //Clean up
    5510. 

  5510.                         delete registry[id];
    5511. 

  5511. 

  5512.                         this.defined = true;
    5513. 

  5513.                     }
    5514. 

  5514. 

  5515.                     //Finished the define stage. Allow calling check again
    5516. 

  5516.                     //to allow define notifications below in the case of a
    5517. 

  5517.                     //cycle.
    5518. 

  5518.                     this.defining = false;
    5519. 

  5519. 

  5520.                     if (this.defined && !this.defineEmitted) {
    5521. 

  5521.                         this.defineEmitted = true;
    5522. 

  5522.                         this.emit('defined', this.exports);
    5523. 

  5523.                         this.defineEmitComplete = true;
    5524. 

  5524.                     }
    5525. 

  5525. 

  5526.                 }
    5527. 

  5527.             },
    5528. 

  5528. 

  5529.             callPlugin: function () {
    5530. 

  5530.                 var map = this.map,
    5531. 

  5531.                     id = map.id,
    5532. 

  5532.                     //Map already normalized the prefix.
    5533. 

  5533.                     pluginMap = makeModuleMap(map.prefix);
    5534. 

  5534. 

  5535.                 //Mark this as a dependency for this plugin, so it
    5536. 

  5536.                 //can be traced for cycles.
    5537. 

  5537.                 this.depMaps.push(pluginMap);
    5538. 

  5538. 

  5539.                 on(pluginMap, 'defined', bind(this, function (plugin) {
    5540. 

  5540.                     var load, normalizedMap, normalizedMod,
    5541. 

  5541.                         name = this.map.name,
    5542. 

  5542.                         parentName = this.map.parentMap ? this.map.parentMap.name : null,
    5543. 

  5543.                         localRequire = context.makeRequire(map.parentMap, {
    5544. 

  5544.                             enableBuildCallback: true
    5545. 

  5545.                         });
    5546. 

  5546. 

  5547.                     //If current map is not normalized, wait for that
    5548. 

  5548.                     //normalized name to load instead of continuing.
    5549. 

  5549.                     if (this.map.unnormalized) {
    5550. 

  5550.                         //Normalize the ID if the plugin allows it.
    5551. 

  5551.                         if (plugin.normalize) {
    5552. 

  5552.                             name = plugin.normalize(name, function (name) {
    5553. 

  5553.                                 return normalize(name, parentName, true);
    5554. 

  5554.                             }) || '';
    5555. 

  5555.                         }
    5556. 

  5556. 

  5557.                         //prefix and name should already be normalized, no need
    5558. 

  5558.                         //for applying map config again either.
    5559. 

  5559.                         normalizedMap = makeModuleMap(map.prefix + '!' + name,
    5560. 

  5560.                                                       this.map.parentMap);
    5561. 

  5561.                         on(normalizedMap,
    5562. 

  5562.                             'defined', bind(this, function (value) {
    5563. 

  5563.                                 this.init([], function () { return value; }, null, {
    5564. 

  5564.                                     enabled: true,
    5565. 

  5565.                                     ignore: true
    5566. 

  5566.                                 });
    5567. 

  5567.                             }));
    5568. 

  5568. 

  5569.                         normalizedMod = getOwn(registry, normalizedMap.id);
    5570. 

  5570.                         if (normalizedMod) {
    5571. 

  5571.                             //Mark this as a dependency for this plugin, so it
    5572. 

  5572.                             //can be traced for cycles.
    5573. 

  5573.                             this.depMaps.push(normalizedMap);
    5574. 

  5574. 

  5575.                             if (this.events.error) {
    5576. 

  5576.                                 normalizedMod.on('error', bind(this, function (err) {
    5577. 

  5577.                                     this.emit('error', err);
    5578. 

  5578.                                 }));
    5579. 

  5579.                             }
    5580. 

  5580.                             normalizedMod.enable();
    5581. 

  5581.                         }
    5582. 

  5582. 

  5583.                         return;
    5584. 

  5584.                     }
    5585. 

  5585. 

  5586.                     load = bind(this, function (value) {
    5587. 

  5587.                         this.init([], function () { return value; }, null, {
    5588. 

  5588.                             enabled: true
    5589. 

  5589.                         });
    5590. 

  5590.                     });
    5591. 

  5591. 

  5592.                     load.error = bind(this, function (err) {
    5593. 

  5593.                         this.inited = true;
    5594. 

  5594.                         this.error = err;
    5595. 

  5595.                         err.requireModules = [id];
    5596. 

  5596. 

  5597.                         //Remove temp unnormalized modules for this module,
    5598. 

  5598.                         //since they will never be resolved otherwise now.
    5599. 

  5599.                         eachProp(registry, function (mod) {
    5600. 

  5600.                             if (mod.map.id.indexOf(id + '_unnormalized') === 0) {
    5601. 

  5601.                                 cleanRegistry(mod.map.id);
    5602. 

  5602.                             }
    5603. 

  5603.                         });
    5604. 

  5604. 

  5605.                         onError(err);
    5606. 

  5606.                     });
    5607. 

  5607. 

  5608.                     //Allow plugins to load other code without having to know the
    5609. 

  5609.                     //context or how to 'complete' the load.
    5610. 

  5610.                     load.fromText = bind(this, function (text, textAlt) {
    5611. 

  5611.                         /*jslint evil: true */
    5612. 

  5612.                         var moduleName = map.name,
    5613. 

  5613.                             moduleMap = makeModuleMap(moduleName),
    5614. 

  5614.                             hasInteractive = useInteractive;
    5615. 

  5615. 

  5616.                         //As of 2.1.0, support just passing the text, to reinforce
    5617. 

  5617.                         //fromText only being called once per resource. Still
    5618. 

  5618.                         //support old style of passing moduleName but discard
    5619. 

  5619.                         //that moduleName in favor of the internal ref.
    5620. 

  5620.                         if (textAlt) {
    5621. 

  5621.                             text = textAlt;
    5622. 

  5622.                         }
    5623. 

  5623. 

  5624.                         //Turn off interactive script matching for IE for any define
    5625. 

  5625.                         //calls in the text, then turn it back on at the end.
    5626. 

  5626.                         if (hasInteractive) {
    5627. 

  5627.                             useInteractive = false;
    5628. 

  5628.                         }
    5629. 

  5629. 

  5630.                         //Prime the system by creating a module instance for
    5631. 

  5631.                         //it.
    5632. 

  5632.                         getModule(moduleMap);
    5633. 

  5633. 

  5634.                         //Transfer any config to this other module.
    5635. 

  5635.                         if (hasProp(config.config, id)) {
    5636. 

  5636.                             config.config[moduleName] = config.config[id];
    5637. 

  5637.                         }
    5638. 

  5638. 

  5639.                         try {
    5640. 

  5640.                             req.exec(text);
    5641. 

  5641.                         } catch (e) {
    5642. 

  5642.                             return onError(makeError('fromtexteval',
    5643. 

  5643.                                              'fromText eval for ' + id +
    5644. 

  5644.                                             ' failed: ' + e,
    5645. 

  5645.                                              e,
    5646. 

  5646.                                              [id]));
    5647. 

  5647.                         }
    5648. 

  5648. 

  5649.                         if (hasInteractive) {
    5650. 

  5650.                             useInteractive = true;
    5651. 

  5651.                         }
    5652. 

  5652. 

  5653.                         //Mark this as a dependency for the plugin
    5654. 

  5654.                         //resource
    5655. 

  5655.                         this.depMaps.push(moduleMap);
    5656. 

  5656. 

  5657.                         //Support anonymous modules.
    5658. 

  5658.                         context.completeLoad(moduleName);
    5659. 

  5659. 

  5660.                         //Bind the value of that module to the value for this
    5661. 

  5661.                         //resource ID.
    5662. 

  5662.                         localRequire([moduleName], load);
    5663. 

  5663.                     });
    5664. 

  5664. 

  5665.                     //Use parentName here since the plugin's name is not reliable,
    5666. 

  5666.                     //could be some weird string with no path that actually wants to
    5667. 

  5667.                     //reference the parentName's path.
    5668. 

  5668.                     plugin.load(map.name, localRequire, load, config);
    5669. 

  5669.                 }));
    5670. 

  5670. 

  5671.                 context.enable(pluginMap, this);
    5672. 

  5672.                 this.pluginMaps[pluginMap.id] = pluginMap;
    5673. 

  5673.             },
    5674. 

  5674. 

  5675.             enable: function () {
    5676. 

  5676.                 this.enabled = true;
    5677. 

  5677. 

  5678.                 //Set flag mentioning that the module is enabling,
    5679. 

  5679.                 //so that immediate calls to the defined callbacks
    5680. 

  5680.                 //for dependencies do not trigger inadvertent load
    5681. 

  5681.                 //with the depCount still being zero.
    5682. 

  5682.                 this.enabling = true;
    5683. 

  5683. 

  5684.                 //Enable each dependency
    5685. 

  5685.                 each(this.depMaps, bind(this, function (depMap, i) {
    5686. 

  5686.                     var id, mod, handler;
    5687. 

  5687. 

  5688.                     if (typeof depMap === 'string') {
    5689. 

  5689.                         //Dependency needs to be converted to a depMap
    5690. 

  5690.                         //and wired up to this module.
    5691. 

  5691.                         depMap = makeModuleMap(depMap,
    5692. 

  5692.                                                (this.map.isDefine ? this.map : this.map.parentMap),
    5693. 

  5693.                                                false,
    5694. 

  5694.                                                !this.skipMap);
    5695. 

  5695.                         this.depMaps[i] = depMap;
    5696. 

  5696. 

  5697.                         handler = getOwn(handlers, depMap.id);
    5698. 

  5698. 

  5699.                         if (handler) {
    5700. 

  5700.                             this.depExports[i] = handler(this);
    5701. 

  5701.                             return;
    5702. 

  5702.                         }
    5703. 

  5703. 

  5704.                         this.depCount += 1;
    5705. 

  5705. 

  5706.                         on(depMap, 'defined', bind(this, function (depExports) {
    5707. 

  5707.                             this.defineDep(i, depExports);
    5708. 

  5708.                             this.check();
    5709. 

  5709.                         }));
    5710. 

  5710. 

  5711.                         if (this.errback) {
    5712. 

  5712.                             on(depMap, 'error', this.errback);
    5713. 

  5713.                         }
    5714. 

  5714.                     }
    5715. 

  5715. 

  5716.                     id = depMap.id;
    5717. 

  5717.                     mod = registry[id];
    5718. 

  5718. 

  5719.                     //Skip special modules like 'require', 'exports', 'module'
    5720. 

  5720.                     //Also, don't call enable if it is already enabled,
    5721. 

  5721.                     //important in circular dependency cases.
    5722. 

  5722.                     if (!hasProp(handlers, id) && mod && !mod.enabled) {
    5723. 

  5723.                         context.enable(depMap, this);
    5724. 

  5724.                     }
    5725. 

  5725.                 }));
    5726. 

  5726. 

  5727.                 //Enable each plugin that is used in
    5728. 

  5728.                 //a dependency
    5729. 

  5729.                 eachProp(this.pluginMaps, bind(this, function (pluginMap) {
    5730. 

  5730.                     var mod = getOwn(registry, pluginMap.id);
    5731. 

  5731.                     if (mod && !mod.enabled) {
    5732. 

  5732.                         context.enable(pluginMap, this);
    5733. 

  5733.                     }
    5734. 

  5734.                 }));
    5735. 

  5735. 

  5736.                 this.enabling = false;
    5737. 

  5737. 

  5738.                 this.check();
    5739. 

  5739.             },
    5740. 

  5740. 

  5741.             on: function (name, cb) {
    5742. 

  5742.                 var cbs = this.events[name];
    5743. 

  5743.                 if (!cbs) {
    5744. 

  5744.                     cbs = this.events[name] = [];
    5745. 

  5745.                 }
    5746. 

  5746.                 cbs.push(cb);
    5747. 

  5747.             },
    5748. 

  5748. 

  5749.             emit: function (name, evt) {
    5750. 

  5750.                 each(this.events[name], function (cb) {
    5751. 

  5751.                     cb(evt);
    5752. 

  5752.                 });
    5753. 

  5753.                 if (name === 'error') {
    5754. 

  5754.                     //Now that the error handler was triggered, remove
    5755. 

  5755.                     //the listeners, since this broken Module instance
    5756. 

  5756.                     //can stay around for a while in the registry.
    5757. 

  5757.                     delete this.events[name];
    5758. 

  5758.                 }
    5759. 

  5759.             }
    5760. 

  5760.         };
    5761. 

  5761. 

  5762.         function callGetModule(args) {
    5763. 

  5763.             //Skip modules already defined.
    5764. 

  5764.             if (!hasProp(defined, args[0])) {
    5765. 

  5765.                 getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2]);
    5766. 

  5766.             }
    5767. 

  5767.         }
    5768. 

  5768. 

  5769.         function removeListener(node, func, name, ieName) {
    5770. 

  5770.             //Favor detachEvent because of IE9
    5771. 

  5771.             //issue, see attachEvent/addEventListener comment elsewhere
    5772. 

  5772.             //in this file.
    5773. 

  5773.             if (node.detachEvent && !isOpera) {
    5774. 

  5774.                 //Probably IE. If not it will throw an error, which will be
    5775. 

  5775.                 //useful to know.
    5776. 

  5776.                 if (ieName) {
    5777. 

  5777.                     node.detachEvent(ieName, func);
    5778. 

  5778.                 }
    5779. 

  5779.             } else {
    5780. 

  5780.                 node.removeEventListener(name, func, false);
    5781. 

  5781.             }
    5782. 

  5782.         }
    5783. 

  5783. 

  5784.         /**
    5785. 

  5785.          * Given an event from a script node, get the requirejs info from it,
    5786. 

  5786.          * and then removes the event listeners on the node.
    5787. 

  5787.          * @param {Event} evt
    5788. 

  5788.          * @returns {Object}
    5789. 

  5789.          */
    5790. 

  5790.         function getScriptData(evt) {
    5791. 

  5791.             //Using currentTarget instead of target for Firefox 2.0's sake. Not
    5792. 

  5792.             //all old browsers will be supported, but this one was easy enough
    5793. 

  5793.             //to support and still makes sense.
    5794. 

  5794.             var node = evt.currentTarget || evt.srcElement;
    5795. 

  5795. 

  5796.             //Remove the listeners once here.
    5797. 

  5797.             removeListener(node, context.onScriptLoad, 'load', 'onreadystatechange');
    5798. 

  5798.             removeListener(node, context.onScriptError, 'error');
    5799. 

  5799. 

  5800.             return {
    5801. 

  5801.                 node: node,
    5802. 

  5802.                 id: node && node.getAttribute('data-requiremodule')
    5803. 

  5803.             };
    5804. 

  5804.         }
    5805. 

  5805. 

  5806.         function intakeDefines() {
    5807. 

  5807.             var args;
    5808. 

  5808. 

  5809.             //Any defined modules in the global queue, intake them now.
    5810. 

  5810.             takeGlobalQueue();
    5811. 

  5811. 

  5812.             //Make sure any remaining defQueue items get properly processed.
    5813. 

  5813.             while (defQueue.length) {
    5814. 

  5814.                 args = defQueue.shift();
    5815. 

  5815.                 if (args[0] === null) {
    5816. 

  5816.                     return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' + args[args.length - 1]));
    5817. 

  5817.                 } else {
    5818. 

  5818.                     //args are id, deps, factory. Should be normalized by the
    5819. 

  5819.                     //define() function.
    5820. 

  5820.                     callGetModule(args);
    5821. 

  5821.                 }
    5822. 

  5822.             }
    5823. 

  5823.         }
    5824. 

  5824. 

  5825.         context = {
    5826. 

  5826.             config: config,
    5827. 

  5827.             contextName: contextName,
    5828. 

  5828.             registry: registry,
    5829. 

  5829.             defined: defined,
    5830. 

  5830.             urlFetched: urlFetched,
    5831. 

  5831.             defQueue: defQueue,
    5832. 

  5832.             Module: Module,
    5833. 

  5833.             makeModuleMap: makeModuleMap,
    5834. 

  5834.             nextTick: req.nextTick,
    5835. 

  5835. 

  5836.             /**
    5837. 

  5837.              * Set a configuration for the context.
    5838. 

  5838.              * @param {Object} cfg config object to integrate.
    5839. 

  5839.              */
    5840. 

  5840.             configure: function (cfg) {
    5841. 

  5841.                 //Make sure the baseUrl ends in a slash.
    5842. 

  5842.                 if (cfg.baseUrl) {
    5843. 

  5843.                     if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {
    5844. 

  5844.                         cfg.baseUrl += '/';
    5845. 

  5845.                     }
    5846. 

  5846.                 }
    5847. 

  5847. 

  5848.                 //Save off the paths and packages since they require special processing,
    5849. 

  5849.                 //they are additive.
    5850. 

  5850.                 var pkgs = config.pkgs,
    5851. 

  5851.                     shim = config.shim,
    5852. 

  5852.                     objs = {
    5853. 

  5853.                         paths: true,
    5854. 

  5854.                         config: true,
    5855. 

  5855.                         map: true
    5856. 

  5856.                     };
    5857. 

  5857. 

  5858.                 eachProp(cfg, function (value, prop) {
    5859. 

  5859.                     if (objs[prop]) {
    5860. 

  5860.                         if (prop === 'map') {
    5861. 

  5861.                             mixin(config[prop], value, true, true);
    5862. 

  5862.                         } else {
    5863. 

  5863.                             mixin(config[prop], value, true);
    5864. 

  5864.                         }
    5865. 

  5865.                     } else {
    5866. 

  5866.                         config[prop] = value;
    5867. 

  5867.                     }
    5868. 

  5868.                 });
    5869. 

  5869. 

  5870.                 //Merge shim
    5871. 

  5871.                 if (cfg.shim) {
    5872. 

  5872.                     eachProp(cfg.shim, function (value, id) {
    5873. 

  5873.                         //Normalize the structure
    5874. 

  5874.                         if (isArray(value)) {
    5875. 

  5875.                             value = {
    5876. 

  5876.                                 deps: value
    5877. 

  5877.                             };
    5878. 

  5878.                         }
    5879. 

  5879.                         if ((value.exports || value.init) && !value.exportsFn) {
    5880. 

  5880.                             value.exportsFn = context.makeShimExports(value);
    5881. 

  5881.                         }
    5882. 

  5882.                         shim[id] = value;
    5883. 

  5883.                     });
    5884. 

  5884.                     config.shim = shim;
    5885. 

  5885.                 }
    5886. 

  5886. 

  5887.                 //Adjust packages if necessary.
    5888. 

  5888.                 if (cfg.packages) {
    5889. 

  5889.                     each(cfg.packages, function (pkgObj) {
    5890. 

  5890.                         var location;
    5891. 

  5891. 

  5892.                         pkgObj = typeof pkgObj === 'string' ? { name: pkgObj } : pkgObj;
    5893. 

  5893.                         location = pkgObj.location;
    5894. 

  5894. 

  5895.                         //Create a brand new object on pkgs, since currentPackages can
    5896. 

  5896.                         //be passed in again, and config.pkgs is the internal transformed
    5897. 

  5897.                         //state for all package configs.
    5898. 

  5898.                         pkgs[pkgObj.name] = {
    5899. 

  5899.                             name: pkgObj.name,
    5900. 

  5900.                             location: location || pkgObj.name,
    5901. 

  5901.                             //Remove leading dot in main, so main paths are normalized,
    5902. 

  5902.                             //and remove any trailing .js, since different package
    5903. 

  5903.                             //envs have different conventions: some use a module name,
    5904. 

  5904.                             //some use a file name.
    5905. 

  5905.                             main: (pkgObj.main || 'main')
    5906. 

  5906.                                   .replace(currDirRegExp, '')
    5907. 

  5907.                                   .replace(jsSuffixRegExp, '')
    5908. 

  5908.                         };
    5909. 

  5909.                     });
    5910. 

  5910. 

  5911.                     //Done with modifications, assing packages back to context config
    5912. 

  5912.                     config.pkgs = pkgs;
    5913. 

  5913.                 }
    5914. 

  5914. 

  5915.                 //If there are any "waiting to execute" modules in the registry,
    5916. 

  5916.                 //update the maps for them, since their info, like URLs to load,
    5917. 

  5917.                 //may have changed.
    5918. 

  5918.                 eachProp(registry, function (mod, id) {
    5919. 

  5919.                     //If module already has init called, since it is too
    5920. 

  5920.                     //late to modify them, and ignore unnormalized ones
    5921. 

  5921.                     //since they are transient.
    5922. 

  5922.                     if (!mod.inited && !mod.map.unnormalized) {
    5923. 

  5923.                         mod.map = makeModuleMap(id);
    5924. 

  5924.                     }
    5925. 

  5925.                 });
    5926. 

  5926. 

  5927.                 //If a deps array or a config callback is specified, then call
    5928. 

  5928.                 //require with those args. This is useful when require is defined as a
    5929. 

  5929.                 //config object before require.js is loaded.
    5930. 

  5930.                 if (cfg.deps || cfg.callback) {
    5931. 

  5931.                     context.require(cfg.deps || [], cfg.callback);
    5932. 

  5932.                 }
    5933. 

  5933.             },
    5934. 

  5934. 

  5935.             makeShimExports: function (value) {
    5936. 

  5936.                 function fn() {
    5937. 

  5937.                     var ret;
    5938. 

  5938.                     if (value.init) {
    5939. 

  5939.                         ret = value.init.apply(global, arguments);
    5940. 

  5940.                     }
    5941. 

  5941.                     return ret || (value.exports && getGlobal(value.exports));
    5942. 

  5942.                 }
    5943. 

  5943.                 return fn;
    5944. 

  5944.             },
    5945. 

  5945. 

  5946.             makeRequire: function (relMap, options) {
    5947. 

  5947.                 options = options || {};
    5948. 

  5948. 

  5949.                 function localRequire(deps, callback, errback) {
    5950. 

  5950.                     var id, map, requireMod;
    5951. 

  5951. 

  5952.                     if (options.enableBuildCallback && callback && isFunction(callback)) {
    5953. 

  5953.                         callback.__requireJsBuild = true;
    5954. 

  5954.                     }
    5955. 

  5955. 

  5956.                     if (typeof deps === 'string') {
    5957. 

  5957.                         if (isFunction(callback)) {
    5958. 

  5958.                             //Invalid call
    5959. 

  5959.                             return onError(makeError('requireargs', 'Invalid require call'), errback);
    5960. 

  5960.                         }
    5961. 

  5961. 

  5962.                         //If require|exports|module are requested, get the
    5963. 

  5963.                         //value for them from the special handlers. Caveat:
    5964. 

  5964.                         //this only works while module is being defined.
    5965. 

  5965.                         if (relMap && hasProp(handlers, deps)) {
    5966. 

  5966.                             return handlers[deps](registry[relMap.id]);
    5967. 

  5967.                         }
    5968. 

  5968. 

  5969.                         //Synchronous access to one module. If require.get is
    5970. 

  5970.                         //available (as in the Node adapter), prefer that.
    5971. 

  5971.                         if (req.get) {
    5972. 

  5972.                             return req.get(context, deps, relMap);
    5973. 

  5973.                         }
    5974. 

  5974. 

  5975.                         //Normalize module name, if it contains . or ..
    5976. 

  5976.                         map = makeModuleMap(deps, relMap, false, true);
    5977. 

  5977.                         id = map.id;
    5978. 

  5978. 

  5979.                         if (!hasProp(defined, id)) {
    5980. 

  5980.                             return onError(makeError('notloaded', 'Module name "' +
    5981. 

  5981.                                         id +
    5982. 

  5982.                                         '" has not been loaded yet for context: ' +
    5983. 

  5983.                                         contextName +
    5984. 

  5984.                                         (relMap ? '' : '. Use require([])')));
    5985. 

  5985.                         }
    5986. 

  5986.                         return defined[id];
    5987. 

  5987.                     }
    5988. 

  5988. 

  5989.                     //Grab defines waiting in the global queue.
    5990. 

  5990.                     intakeDefines();
    5991. 

  5991. 

  5992.                     //Mark all the dependencies as needing to be loaded.
    5993. 

  5993.                     context.nextTick(function () {
    5994. 

  5994.                         //Some defines could have been added since the
    5995. 

  5995.                         //require call, collect them.
    5996. 

  5996.                         intakeDefines();
    5997. 

  5997. 

  5998.                         requireMod = getModule(makeModuleMap(null, relMap));
    5999. 

  5999. 

  6000.                         //Store if map config should be applied to this require
    6001. 

  6001.                         //call for dependencies.
    6002. 

  6002.                         requireMod.skipMap = options.skipMap;
    6003. 

  6003. 

  6004.                         requireMod.init(deps, callback, errback, {
    6005. 

  6005.                             enabled: true
    6006. 

  6006.                         });
    6007. 

  6007. 

  6008.                         checkLoaded();
    6009. 

  6009.                     });
    6010. 

  6010. 

  6011.                     return localRequire;
    6012. 

  6012.                 }
    6013. 

  6013. 

  6014.                 mixin(localRequire, {
    6015. 

  6015.                     isBrowser: isBrowser,
    6016. 

  6016. 

  6017.                     /**
    6018. 

  6018.                      * Converts a module name + .extension into an URL path.
    6019. 

  6019.                      * *Requires* the use of a module name. It does not support using
    6020. 

  6020.                      * plain URLs like nameToUrl.
    6021. 

  6021.                      */
    6022. 

  6022.                     toUrl: function (moduleNamePlusExt) {
    6023. 

  6023.                         var ext, url,
    6024. 

  6024.                             index = moduleNamePlusExt.lastIndexOf('.'),
    6025. 

  6025.                             segment = moduleNamePlusExt.split('/')[0],
    6026. 

  6026.                             isRelative = segment === '.' || segment === '..';
    6027. 

  6027. 

  6028.                         //Have a file extension alias, and it is not the
    6029. 

  6029.                         //dots from a relative path.
    6030. 

  6030.                         if (index !== -1 && (!isRelative || index > 1)) {
    6031. 

  6031.                             ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
    6032. 

  6032.                             moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
    6033. 

  6033.                         }
    6034. 

  6034. 

  6035.                         url = context.nameToUrl(normalize(moduleNamePlusExt,
    6036. 

  6036.                                                 relMap && relMap.id, true), ext || '.fake');
    6037. 

  6037.                         return ext ? url : url.substring(0, url.length - 5);
    6038. 

  6038.                     },
    6039. 

  6039. 

  6040.                     defined: function (id) {
    6041. 

  6041.                         return hasProp(defined, makeModuleMap(id, relMap, false, true).id);
    6042. 

  6042.                     },
    6043. 

  6043. 

  6044.                     specified: function (id) {
    6045. 

  6045.                         id = makeModuleMap(id, relMap, false, true).id;
    6046. 

  6046.                         return hasProp(defined, id) || hasProp(registry, id);
    6047. 

  6047.                     }
    6048. 

  6048.                 });
    6049. 

  6049. 

  6050.                 //Only allow undef on top level require calls
    6051. 

  6051.                 if (!relMap) {
    6052. 

  6052.                     localRequire.undef = function (id) {
    6053. 

  6053.                         //Bind any waiting define() calls to this context,
    6054. 

  6054.                         //fix for #408
    6055. 

  6055.                         takeGlobalQueue();
    6056. 

  6056. 

  6057.                         var map = makeModuleMap(id, relMap, true),
    6058. 

  6058.                             mod = getOwn(registry, id);
    6059. 

  6059. 

  6060.                         delete defined[id];
    6061. 

  6061.                         delete urlFetched[map.url];
    6062. 

  6062.                         delete undefEvents[id];
    6063. 

  6063. 

  6064.                         if (mod) {
    6065. 

  6065.                             //Hold on to listeners in case the
    6066. 

  6066.                             //module will be attempted to be reloaded
    6067. 

  6067.                             //using a different config.
    6068. 

  6068.                             if (mod.events.defined) {
    6069. 

  6069.                                 undefEvents[id] = mod.events;
    6070. 

  6070.                             }
    6071. 

  6071. 

  6072.                             cleanRegistry(id);
    6073. 

  6073.                         }
    6074. 

  6074.                     };
    6075. 

  6075.                 }
    6076. 

  6076. 

  6077.                 return localRequire;
    6078. 

  6078.             },
    6079. 

  6079. 

  6080.             /**
    6081. 

  6081.              * Called to enable a module if it is still in the registry
    6082. 

  6082.              * awaiting enablement. A second arg, parent, the parent module,
    6083. 

  6083.              * is passed in for context, when this method is overriden by
    6084. 

  6084.              * the optimizer. Not shown here to keep code compact.
    6085. 

  6085.              */
    6086. 

  6086.             enable: function (depMap) {
    6087. 

  6087.                 var mod = getOwn(registry, depMap.id);
    6088. 

  6088.                 if (mod) {
    6089. 

  6089.                     getModule(depMap).enable();
    6090. 

  6090.                 }
    6091. 

  6091.             },
    6092. 

  6092. 

  6093.             /**
    6094. 

  6094.              * Internal method used by environment adapters to complete a load event.
    6095. 

  6095.              * A load event could be a script load or just a load pass from a synchronous
    6096. 

  6096.              * load call.
    6097. 

  6097.              * @param {String} moduleName the name of the module to potentially complete.
    6098. 

  6098.              */
    6099. 

  6099.             completeLoad: function (moduleName) {
    6100. 

  6100.                 var found, args, mod,
    6101. 

  6101.                     shim = getOwn(config.shim, moduleName) || {},
    6102. 

  6102.                     shExports = shim.exports;
    6103. 

  6103. 

  6104.                 takeGlobalQueue();
    6105. 

  6105. 

  6106.                 while (defQueue.length) {
    6107. 

  6107.                     args = defQueue.shift();
    6108. 

  6108.                     if (args[0] === null) {
    6109. 

  6109.                         args[0] = moduleName;
    6110. 

  6110.                         //If already found an anonymous module and bound it
    6111. 

  6111.                         //to this name, then this is some other anon module
    6112. 

  6112.                         //waiting for its completeLoad to fire.
    6113. 

  6113.                         if (found) {
    6114. 

  6114.                             break;
    6115. 

  6115.                         }
    6116. 

  6116.                         found = true;
    6117. 

  6117.                     } else if (args[0] === moduleName) {
    6118. 

  6118.                         //Found matching define call for this script!
    6119. 

  6119.                         found = true;
    6120. 

  6120.                     }
    6121. 

  6121. 

  6122.                     callGetModule(args);
    6123. 

  6123.                 }
    6124. 

  6124. 

  6125.                 //Do this after the cycle of callGetModule in case the result
    6126. 

  6126.                 //of those calls/init calls changes the registry.
    6127. 

  6127.                 mod = getOwn(registry, moduleName);
    6128. 

  6128. 

  6129.                 if (!found && !hasProp(defined, moduleName) && mod && !mod.inited) {
    6130. 

  6130.                     if (config.enforceDefine && (!shExports || !getGlobal(shExports))) {
    6131. 

  6131.                         if (hasPathFallback(moduleName)) {
    6132. 

  6132.                             return;
    6133. 

  6133.                         } else {
    6134. 

  6134.                             return onError(makeError('nodefine',
    6135. 

  6135.                                              'No define call for ' + moduleName,
    6136. 

  6136.                                              null,
    6137. 

  6137.                                              [moduleName]));
    6138. 

  6138.                         }
    6139. 

  6139.                     } else {
    6140. 

  6140.                         //A script that does not call define(), so just simulate
    6141. 

  6141.                         //the call for it.
    6142. 

  6142.                         callGetModule([moduleName, (shim.deps || []), shim.exportsFn]);
    6143. 

  6143.                     }
    6144. 

  6144.                 }
    6145. 

  6145. 

  6146.                 checkLoaded();
    6147. 

  6147.             },
    6148. 

  6148. 

  6149.             /**
    6150. 

  6150.              * Converts a module name to a file path. Supports cases where
    6151. 

  6151.              * moduleName may actually be just an URL.
    6152. 

  6152.              * Note that it **does not** call normalize on the moduleName,
    6153. 

  6153.              * it is assumed to have already been normalized. This is an
    6154. 

  6154.              * internal API, not a public one. Use toUrl for the public API.
    6155. 

  6155.              */
    6156. 

  6156.             nameToUrl: function (moduleName, ext) {
    6157. 

  6157.                 var paths, pkgs, pkg, pkgPath, syms, i, parentModule, url,
    6158. 

  6158.                     parentPath;
    6159. 

  6159. 

  6160.                 //If a colon is in the URL, it indicates a protocol is used and it is just
    6161. 

  6161.                 //an URL to a file, or if it starts with a slash, contains a query arg (i.e. ?)
    6162. 

  6162.                 //or ends with .js, then assume the user meant to use an url and not a module id.
    6163. 

  6163.                 //The slash is important for protocol-less URLs as well as full paths.
    6164. 

  6164.                 if (req.jsExtRegExp.test(moduleName)) {
    6165. 

  6165.                     //Just a plain path, not module name lookup, so just return it.
    6166. 

  6166.                     //Add extension if it is included. This is a bit wonky, only non-.js things pass
    6167. 

  6167.                     //an extension, this method probably needs to be reworked.
    6168. 

  6168.                     url = moduleName + (ext || '');
    6169. 

  6169.                 } else {
    6170. 

  6170.                     //A module that needs to be converted to a path.
    6171. 

  6171.                     paths = config.paths;
    6172. 

  6172.                     pkgs = config.pkgs;
    6173. 

  6173. 

  6174.                     syms = moduleName.split('/');
    6175. 

  6175.                     //For each module name segment, see if there is a path
    6176. 

  6176.                     //registered for it. Start with most specific name
    6177. 

  6177.                     //and work up from it.
    6178. 

  6178.                     for (i = syms.length; i > 0; i -= 1) {
    6179. 

  6179.                         parentModule = syms.slice(0, i).join('/');
    6180. 

  6180.                         pkg = getOwn(pkgs, parentModule);
    6181. 

  6181.                         parentPath = getOwn(paths, parentModule);
    6182. 

  6182.                         if (parentPath) {
    6183. 

  6183.                             //If an array, it means there are a few choices,
    6184. 

  6184.                             //Choose the one that is desired
    6185. 

  6185.                             if (isArray(parentPath)) {
    6186. 

  6186.                                 parentPath = parentPath[0];
    6187. 

  6187.                             }
    6188. 

  6188.                             syms.splice(0, i, parentPath);
    6189. 

  6189.                             break;
    6190. 

  6190.                         } else if (pkg) {
    6191. 

  6191.                             //If module name is just the package name, then looking
    6192. 

  6192.                             //for the main module.
    6193. 

  6193.                             if (moduleName === pkg.name) {
    6194. 

  6194.                                 pkgPath = pkg.location + '/' + pkg.main;
    6195. 

  6195.                             } else {
    6196. 

  6196.                                 pkgPath = pkg.location;
    6197. 

  6197.                             }
    6198. 

  6198.                             syms.splice(0, i, pkgPath);
    6199. 

  6199.                             break;
    6200. 

  6200.                         }
    6201. 

  6201.                     }
    6202. 

  6202. 

  6203.                     //Join the path parts together, then figure out if baseUrl is needed.
    6204. 

  6204.                     url = syms.join('/');
    6205. 

  6205.                     url += (ext || (/\?/.test(url) ? '' : '.js'));
    6206. 

  6206.                     url = (url.charAt(0) === '/' || url.match(/^[\w\+\.\-]+:/) ? '' : config.baseUrl) + url;
    6207. 

  6207.                 }
    6208. 

  6208. 

  6209.                 return config.urlArgs ? url +
    6210. 

  6210.                                         ((url.indexOf('?') === -1 ? '?' : '&') +
    6211. 

  6211.                                          config.urlArgs) : url;
    6212. 

  6212.             },
    6213. 

  6213. 

  6214.             //Delegates to req.load. Broken out as a separate function to
    6215. 

  6215.             //allow overriding in the optimizer.
    6216. 

  6216.             load: function (id, url) {
    6217. 

  6217.                 req.load(context, id, url);
    6218. 

  6218.             },
    6219. 

  6219. 

  6220.             /**
    6221. 

  6221.              * Executes a module callack function. Broken out as a separate function
    6222. 

  6222.              * solely to allow the build system to sequence the files in the built
    6223. 

  6223.              * layer in the right sequence.
    6224. 

  6224.              *
    6225. 

  6225.              * @private
    6226. 

  6226.              */
    6227. 

  6227.             execCb: function (name, callback, args, exports) {
    6228. 

  6228.                 return callback.apply(exports, args);
    6229. 

  6229.             },
    6230. 

  6230. 

  6231.             /**
    6232. 

  6232.              * callback for script loads, used to check status of loading.
    6233. 

  6233.              *
    6234. 

  6234.              * @param {Event} evt the event from the browser for the script
    6235. 

  6235.              * that was loaded.
    6236. 

  6236.              */
    6237. 

  6237.             onScriptLoad: function (evt) {
    6238. 

  6238.                 //Using currentTarget instead of target for Firefox 2.0's sake. Not
    6239. 

  6239.                 //all old browsers will be supported, but this one was easy enough
    6240. 

  6240.                 //to support and still makes sense.
    6241. 

  6241.                 if (evt.type === 'load' ||
    6242. 

  6242.                         (readyRegExp.test((evt.currentTarget || evt.srcElement).readyState))) {
    6243. 

  6243.                     //Reset interactive script so a script node is not held onto for
    6244. 

  6244.                     //to long.
    6245. 

  6245.                     interactiveScript = null;
    6246. 

  6246. 

  6247.                     //Pull out the name of the module and the context.
    6248. 

  6248.                     var data = getScriptData(evt);
    6249. 

  6249.                     context.completeLoad(data.id);
    6250. 

  6250.                 }
    6251. 

  6251.             },
    6252. 

  6252. 

  6253.             /**
    6254. 

  6254.              * Callback for script errors.
    6255. 

  6255.              */
    6256. 

  6256.             onScriptError: function (evt) {
    6257. 

  6257.                 var data = getScriptData(evt);
    6258. 

  6258.                 if (!hasPathFallback(data.id)) {
    6259. 

  6259.                     return onError(makeError('scripterror', 'Script error', evt, [data.id]));
    6260. 

  6260.                 }
    6261. 

  6261.             }
    6262. 

  6262.         };
    6263. 

  6263. 

  6264.         context.require = context.makeRequire();
    6265. 

  6265.         return context;
    6266. 

  6266.     }
    6267. 

  6267. 

  6268.     /**
    6269. 

  6269.      * Main entry point.
    6270. 

  6270.      *
    6271. 

  6271.      * If the only argument to require is a string, then the module that
    6272. 

  6272.      * is represented by that string is fetched for the appropriate context.
    6273. 

  6273.      *
    6274. 

  6274.      * If the first argument is an array, then it will be treated as an array
    6275. 

  6275.      * of dependency string names to fetch. An optional function callback can
    6276. 

  6276.      * be specified to execute when all of those dependencies are available.
    6277. 

  6277.      *
    6278. 

  6278.      * Make a local req variable to help Caja compliance (it assumes things
    6279. 

  6279.      * on a require that are not standardized), and to give a short
    6280. 

  6280.      * name for minification/local scope use.
    6281. 

  6281.      */
    6282. 

  6282.     req = requirejs = function (deps, callback, errback, optional) {
    6283. 

  6283. 

  6284.         //Find the right context, use default
    6285. 

  6285.         var context, config,
    6286. 

  6286.             contextName = defContextName;
    6287. 

  6287. 

  6288.         // Determine if have config object in the call.
    6289. 

  6289.         if (!isArray(deps) && typeof deps !== 'string') {
    6290. 

  6290.             // deps is a config object
    6291. 

  6291.             config = deps;
    6292. 

  6292.             if (isArray(callback)) {
    6293. 

  6293.                 // Adjust args if there are dependencies
    6294. 

  6294.                 deps = callback;
    6295. 

  6295.                 callback = errback;
    6296. 

  6296.                 errback = optional;
    6297. 

  6297.             } else {
    6298. 

  6298.                 deps = [];
    6299. 

  6299.             }
    6300. 

  6300.         }
    6301. 

  6301. 

  6302.         if (config && config.context) {
    6303. 

  6303.             contextName = config.context;
    6304. 

  6304.         }
    6305. 

  6305. 

  6306.         context = getOwn(contexts, contextName);
    6307. 

  6307.         if (!context) {
    6308. 

  6308.             context = contexts[contextName] = req.s.newContext(contextName);
    6309. 

  6309.         }
    6310. 

  6310. 

  6311.         if (config) {
    6312. 

  6312.             context.configure(config);
    6313. 

  6313.         }
    6314. 

  6314. 

  6315.         return context.require(deps, callback, errback);
    6316. 

  6316.     };
    6317. 

  6317. 

  6318.     /**
    6319. 

  6319.      * Support require.config() to make it easier to cooperate with other
    6320. 

  6320.      * AMD loaders on globally agreed names.
    6321. 

  6321.      */
    6322. 

  6322.     req.config = function (config) {
    6323. 

  6323.         return req(config);
    6324. 

  6324.     };
    6325. 

  6325. 

  6326.     /**
    6327. 

  6327.      * Execute something after the current tick
    6328. 

  6328.      * of the event loop. Override for other envs
    6329. 

  6329.      * that have a better solution than setTimeout.
    6330. 

  6330.      * @param  {Function} fn function to execute later.
    6331. 

  6331.      */
    6332. 

  6332.     req.nextTick = typeof setTimeout !== 'undefined' ? function (fn) {
    6333. 

  6333.         setTimeout(fn, 4);
    6334. 

  6334.     } : function (fn) { fn(); };
    6335. 

  6335. 

  6336.     /**
    6337. 

  6337.      * Export require as a global, but only if it does not already exist.
    6338. 

  6338.      */
    6339. 

  6339.     if (!require) {
    6340. 

  6340.         require = req;
    6341. 

  6341.     }
    6342. 

  6342. 

  6343.     req.version = version;
    6344. 

  6344. 

  6345.     //Used to filter out dependencies that are already paths.
    6346. 

  6346.     req.jsExtRegExp = /^\/|:|\?|\.js$/;
    6347. 

  6347.     req.isBrowser = isBrowser;
    6348. 

  6348.     s = req.s = {
    6349. 

  6349.         contexts: contexts,
    6350. 

  6350.         newContext: newContext
    6351. 

  6351.     };
    6352. 

  6352. 

  6353.     //Create default context.
    6354. 

  6354.     req({});
    6355. 

  6355. 

  6356.     //Exports some context-sensitive methods on global require.
    6357. 

  6357.     each([
    6358. 

  6358.         'toUrl',
    6359. 

  6359.         'undef',
    6360. 

  6360.         'defined',
    6361. 

  6361.         'specified'
    6362. 

  6362.     ], function (prop) {
    6363. 

  6363.         //Reference from contexts instead of early binding to default context,
    6364. 

  6364.         //so that during builds, the latest instance of the default context
    6365. 

  6365.         //with its config gets used.
    6366. 

  6366.         req[prop] = function () {
    6367. 

  6367.             var ctx = contexts[defContextName];
    6368. 

  6368.             return ctx.require[prop].apply(ctx, arguments);
    6369. 

  6369.         };
    6370. 

  6370.     });
    6371. 

  6371. 

  6372.     if (isBrowser) {
    6373. 

  6373.         head = s.head = document.getElementsByTagName('head')[0];
    6374. 

  6374.         //If BASE tag is in play, using appendChild is a problem for IE6.
    6375. 

  6375.         //When that browser dies, this can be removed. Details in this jQuery bug:
    6376. 

  6376.         //http://dev.jquery.com/ticket/2709
    6377. 

  6377.         baseElement = document.getElementsByTagName('base')[0];
    6378. 

  6378.         if (baseElement) {
    6379. 

  6379.             head = s.head = baseElement.parentNode;
    6380. 

  6380.         }
    6381. 

  6381.     }
    6382. 

  6382. 

  6383.     /**
    6384. 

  6384.      * Any errors that require explicitly generates will be passed to this
    6385. 

  6385.      * function. Intercept/override it if you want custom error handling.
    6386. 

  6386.      * @param {Error} err the error object.
    6387. 

  6387.      */
    6388. 

  6388.     req.onError = function (err) {
    6389. 

  6389.         throw err;
    6390. 

  6390.     };
    6391. 

  6391. 

  6392.     /**
    6393. 

  6393.      * Does the request to load a module for the browser case.
    6394. 

  6394.      * Make this a separate function to allow other environments
    6395. 

  6395.      * to override it.
    6396. 

  6396.      *
    6397. 

  6397.      * @param {Object} context the require context to find state.
    6398. 

  6398.      * @param {String} moduleName the name of the module.
    6399. 

  6399.      * @param {Object} url the URL to the module.
    6400. 

  6400.      */
    6401. 

  6401.     req.load = function (context, moduleName, url) {
    6402. 

  6402.         var config = (context && context.config) || {},
    6403. 

  6403.             node;
    6404. 

  6404.         if (isBrowser) {
    6405. 

  6405.             //In the browser so use a script tag
    6406. 

  6406.             node = config.xhtml ?
    6407. 

  6407.                     document.createElementNS('http://www.w3.org/1999/xhtml', 'html:script') :
    6408. 

  6408.                     document.createElement('script');
    6409. 

  6409.             node.type = config.scriptType || 'text/javascript';
    6410. 

  6410.             node.charset = 'utf-8';
    6411. 

  6411.             node.async = true;
    6412. 

  6412. 

  6413.             node.setAttribute('data-requirecontext', context.contextName);
    6414. 

  6414.             node.setAttribute('data-requiremodule', moduleName);
    6415. 

  6415. 

  6416.             //Set up load listener. Test attachEvent first because IE9 has
    6417. 

  6417.             //a subtle issue in its addEventListener and script onload firings
    6418. 

  6418.             //that do not match the behavior of all other browsers with
    6419. 

  6419.             //addEventListener support, which fire the onload event for a
    6420. 

  6420.             //script right after the script execution. See:
    6421. 

  6421.             //https://connect.microsoft.com/IE/feedback/details/648057/script-onload-event-is-not-fired-immediately-after-script-execution
    6422. 

  6422.             //UNFORTUNATELY Opera implements attachEvent but does not follow the script
    6423. 

  6423.             //script execution mode.
    6424. 

  6424.             if (node.attachEvent &&
    6425. 

  6425.                     //Check if node.attachEvent is artificially added by custom script or
    6426. 

  6426.                     //natively supported by browser
    6427. 

  6427.                     //read https://github.com/jrburke/requirejs/issues/187
    6428. 

  6428.                     //if we can NOT find [native code] then it must NOT natively supported.
    6429. 

  6429.                     //in IE8, node.attachEvent does not have toString()
    6430. 

  6430.                     //Note the test for "[native code" with no closing brace, see:
    6431. 

  6431.                     //https://github.com/jrburke/requirejs/issues/273
    6432. 

  6432.                     !(node.attachEvent.toString && node.attachEvent.toString().indexOf('[native code') < 0) &&
    6433. 

  6433.                     !isOpera) {
    6434. 

  6434.                 //Probably IE. IE (at least 6-8) do not fire
    6435. 

  6435.                 //script onload right after executing the script, so
    6436. 

  6436.                 //we cannot tie the anonymous define call to a name.
    6437. 

  6437.                 //However, IE reports the script as being in 'interactive'
    6438. 

  6438.                 //readyState at the time of the define call.
    6439. 

  6439.                 useInteractive = true;
    6440. 

  6440. 

  6441.                 node.attachEvent('onreadystatechange', context.onScriptLoad);
    6442. 

  6442.                 //It would be great to add an error handler here to catch
    6443. 

  6443.                 //404s in IE9+. However, onreadystatechange will fire before
    6444. 

  6444.                 //the error handler, so that does not help. If addEvenListener
    6445. 

  6445.                 //is used, then IE will fire error before load, but we cannot
    6446. 

  6446.                 //use that pathway given the connect.microsoft.com issue
    6447. 

  6447.                 //mentioned above about not doing the 'script execute,
    6448. 

  6448.                 //then fire the script load event listener before execute
    6449. 

  6449.                 //next script' that other browsers do.
    6450. 

  6450.                 //Best hope: IE10 fixes the issues,
    6451. 

  6451.                 //and then destroys all installs of IE 6-9.
    6452. 

  6452.                 //node.attachEvent('onerror', context.onScriptError);
    6453. 

  6453.             } else {
    6454. 

  6454.                 node.addEventListener('load', context.onScriptLoad, false);
    6455. 

  6455.                 node.addEventListener('error', context.onScriptError, false);
    6456. 

  6456.             }
    6457. 

  6457.             node.src = url;
    6458. 

  6458. 

  6459.             //For some cache cases in IE 6-8, the script executes before the end
    6460. 

  6460.             //of the appendChild execution, so to tie an anonymous define
    6461. 

  6461.             //call to the module name (which is stored on the node), hold on
    6462. 

  6462.             //to a reference to this node, but clear after the DOM insertion.
    6463. 

  6463.             currentlyAddingScript = node;
    6464. 

  6464.             if (baseElement) {
    6465. 

  6465.                 head.insertBefore(node, baseElement);
    6466. 

  6466.             } else {
    6467. 

  6467.                 head.appendChild(node);
    6468. 

  6468.             }
    6469. 

  6469.             currentlyAddingScript = null;
    6470. 

  6470. 

  6471.             return node;
    6472. 

  6472.         } else if (isWebWorker) {
    6473. 

  6473.             //In a web worker, use importScripts. This is not a very
    6474. 

  6474.             //efficient use of importScripts, importScripts will block until
    6475. 

  6475.             //its script is downloaded and evaluated. However, if web workers
    6476. 

  6476.             //are in play, the expectation that a build has been done so that
    6477. 

  6477.             //only one script needs to be loaded anyway. This may need to be
    6478. 

  6478.             //reevaluated if other use cases become common.
    6479. 

  6479.             importScripts(url);
    6480. 

  6480. 

  6481.             //Account for anonymous modules
    6482. 

  6482.             context.completeLoad(moduleName);
    6483. 

  6483.         }
    6484. 

  6484.     };
    6485. 

  6485. 

  6486.     function getInteractiveScript() {
    6487. 

  6487.         if (interactiveScript && interactiveScript.readyState === 'interactive') {
    6488. 

  6488.             return interactiveScript;
    6489. 

  6489.         }
    6490. 

  6490. 

  6491.         eachReverse(scripts(), function (script) {
    6492. 

  6492.             if (script.readyState === 'interactive') {
    6493. 

  6493.                 return (interactiveScript = script);
    6494. 

  6494.             }
    6495. 

  6495.         });
    6496. 

  6496.         return interactiveScript;
    6497. 

  6497.     }
    6498. 

  6498. 

  6499.     //Look for a data-main script attribute, which could also adjust the baseUrl.
    6500. 

  6500.     if (isBrowser) {
    6501. 

  6501.         //Figure out baseUrl. Get it from the script tag with require.js in it.
    6502. 

  6502.         eachReverse(scripts(), function (script) {
    6503. 

  6503.             //Set the 'head' where we can append children by
    6504. 

  6504.             //using the script's parent.
    6505. 

  6505.             if (!head) {
    6506. 

  6506.                 head = script.parentNode;
    6507. 

  6507.             }
    6508. 

  6508. 

  6509.             //Look for a data-main attribute to set main script for the page
    6510. 

  6510.             //to load. If it is there, the path to data main becomes the
    6511. 

  6511.             //baseUrl, if it is not already set.
    6512. 

  6512.             dataMain = script.getAttribute('data-main');
    6513. 

  6513.             if (dataMain) {
    6514. 

  6514.                 //Set final baseUrl if there is not already an explicit one.
    6515. 

  6515.                 if (!cfg.baseUrl) {
    6516. 

  6516.                     //Pull off the directory of data-main for use as the
    6517. 

  6517.                     //baseUrl.
    6518. 

  6518.                     src = dataMain.split('/');
    6519. 

  6519.                     mainScript = src.pop();
    6520. 

  6520.                     subPath = src.length ? src.join('/')  + '/' : './';
    6521. 

  6521. 

  6522.                     cfg.baseUrl = subPath;
    6523. 

  6523.                     dataMain = mainScript;
    6524. 

  6524.                 }
    6525. 

  6525. 

  6526.                 //Strip off any trailing .js since dataMain is now
    6527. 

  6527.                 //like a module name.
    6528. 

  6528.                 dataMain = dataMain.replace(jsSuffixRegExp, '');
    6529. 

  6529. 

  6530.                 //Put the data-main script in the files to load.
    6531. 

  6531.                 cfg.deps = cfg.deps ? cfg.deps.concat(dataMain) : [dataMain];
    6532. 

  6532. 

  6533.                 return true;
    6534. 

  6534.             }
    6535. 

  6535.         });
    6536. 

  6536.     }
    6537. 

  6537. 

  6538.     /**
    6539. 

  6539.      * The function that handles definitions of modules. Differs from
    6540. 

  6540.      * require() in that a string for the module should be the first argument,
    6541. 

  6541.      * and the function to execute after dependencies are loaded should
    6542. 

  6542.      * return a value to define the module corresponding to the first argument's
    6543. 

  6543.      * name.
    6544. 

  6544.      */
    6545. 

  6545.     define = function (name, deps, callback) {
    6546. 

  6546.         var node, context;
    6547. 

  6547. 

  6548.         //Allow for anonymous modules
    6549. 

  6549.         if (typeof name !== 'string') {
    6550. 

  6550.             //Adjust args appropriately
    6551. 

  6551.             callback = deps;
    6552. 

  6552.             deps = name;
    6553. 

  6553.             name = null;
    6554. 

  6554.         }
    6555. 

  6555. 

  6556.         //This module may not have dependencies
    6557. 

  6557.         if (!isArray(deps)) {
    6558. 

  6558.             callback = deps;
    6559. 

  6559.             deps = [];
    6560. 

  6560.         }
    6561. 

  6561. 

  6562.         //If no name, and callback is a function, then figure out if it a
    6563. 

  6563.         //CommonJS thing with dependencies.
    6564. 

  6564.         if (!deps.length && isFunction(callback)) {
    6565. 

  6565.             //Remove comments from the callback string,
    6566. 

  6566.             //look for require calls, and pull them into the dependencies,
    6567. 

  6567.             //but only if there are function args.
    6568. 

  6568.             if (callback.length) {
    6569. 

  6569.                 callback
    6570. 

  6570.                     .toString()
    6571. 

  6571.                     .replace(commentRegExp, '')
    6572. 

  6572.                     .replace(cjsRequireRegExp, function (match, dep) {
    6573. 

  6573.                         deps.push(dep);
    6574. 

  6574.                     });
    6575. 

  6575. 

  6576.                 //May be a CommonJS thing even without require calls, but still
    6577. 

  6577.                 //could use exports, and module. Avoid doing exports and module
    6578. 

  6578.                 //work though if it just needs require.
    6579. 

  6579.                 //REQUIRES the function to expect the CommonJS variables in the
    6580. 

  6580.                 //order listed below.
    6581. 

  6581.                 deps = (callback.length === 1 ? ['require'] : ['require', 'exports', 'module']).concat(deps);
    6582. 

  6582.             }
    6583. 

  6583.         }
    6584. 

  6584. 

  6585.         //If in IE 6-8 and hit an anonymous define() call, do the interactive
    6586. 

  6586.         //work.
    6587. 

  6587.         if (useInteractive) {
    6588. 

  6588.             node = currentlyAddingScript || getInteractiveScript();
    6589. 

  6589.             if (node) {
    6590. 

  6590.                 if (!name) {
    6591. 

  6591.                     name = node.getAttribute('data-requiremodule');
    6592. 

  6592.                 }
    6593. 

  6593.                 context = contexts[node.getAttribute('data-requirecontext')];
    6594. 

  6594.             }
    6595. 

  6595.         }
    6596. 

  6596. 

  6597.         //Always save off evaluating the def call until the script onload handler.
    6598. 

  6598.         //This allows multiple modules to be in a file without prematurely
    6599. 

  6599.         //tracing dependencies, and allows for anonymous module support,
    6600. 

  6600.         //where the module name is not known until the script onload event
    6601. 

  6601.         //occurs. If no context, use the global queue, and get it processed
    6602. 

  6602.         //in the onscript load callback.
    6603. 

  6603.         (context ? context.defQueue : globalDefQueue).push([name, deps, callback]);
    6604. 

  6604.     };
    6605. 

  6605. 

  6606.     define.amd = {
    6607. 

  6607.         jQuery: true
    6608. 

  6608.     };
    6609. 

  6609. 

  6610. 

  6611.     /**
    6612. 

  6612.      * Executes the text. Normally just uses eval, but can be modified
    6613. 

  6613.      * to use a better, environment-specific call. Only used for transpiling
    6614. 

  6614.      * loader plugins, not for plain JS modules.
    6615. 

  6615.      * @param {String} text the text to execute/evaluate.
    6616. 

  6616.      */
    6617. 

  6617.     req.exec = function (text) {
    6618. 

  6618.         /*jslint evil: true */
    6619. 

  6619.         return eval(text);
    6620. 

  6620.     };
    6621. 

  6621. 

  6622.     //Set up with config info.
    6623. 

  6623.     req(cfg);
    6624. 

  6624. }(this));
    6625. 

  6625. 

  6626. context.require=require; context.define=define; context.requirejs=requirejs; };
    6627. 

  6627. 

  6628. blanket.defaultReporter = function(coverage){
    6629. 

  6629.     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;}",
    6630. 

  6630.         successRate = 60,
    6631. 

  6631.         head = document.head,
    6632. 

  6632.         fileNumber = 0,
    6633. 

  6633.         body = document.body,
    6634. 

  6634.         headerContent,
    6635. 

  6635.         hasBranchTracking = Object.keys(coverage.files).some(function(elem){
    6636. 

  6636.           return typeof coverage.files[elem].branchData !== 'undefined';
    6637. 

  6637.         }),
    6638. 

  6638.         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>",
    6639. 

  6639.         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>";
    6640. 

  6640.         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>";
    6641. 

  6641. 

  6642.     function blanket_toggleSource(id) {
    6643. 

  6643.         var element = document.getElementById(id);
    6644. 

  6644.         if(element.style.display === 'block') {
    6645. 

  6645.             element.style.display = 'none';
    6646. 

  6646.         } else {
    6647. 

  6647.             element.style.display = 'block';
    6648. 

  6648.         }
    6649. 

  6649.     }
    6650. 

  6650. 

  6651. 

  6652.     var script = document.createElement("script");
    6653. 

  6653.     script.type = "text/javascript";
    6654. 

  6654.     script.text = blanket_toggleSource.toString().replace('function ' + blanket_toggleSource.name, 'function blanket_toggleSource');
    6655. 

  6655.     body.appendChild(script);
    6656. 

  6656. 

  6657.     var percentage = function(number, total) {
    6658. 

  6658.         return (Math.round(((number/total) * 100)*100)/100);
    6659. 

  6659.     };
    6660. 

  6660. 

  6661.     var appendTag = function (type, el, str) {
    6662. 

  6662.         var dom = document.createElement(type);
    6663. 

  6663.         dom.innerHTML = str;
    6664. 

  6664.         el.appendChild(dom);
    6665. 

  6665.     };
    6666. 

  6666. 

  6667.     function escapeInvalidXmlChars(str) {
    6668. 

  6668.         return str.replace(/\&/g, "&amp;")
    6669. 

  6669.             .replace(/</g, "&lt;")
    6670. 

  6670.             .replace(/\>/g, "&gt;")
    6671. 

  6671.             .replace(/\"/g, "&quot;")
    6672. 

  6672.             .replace(/\'/g, "&apos;");
    6673. 

  6673.     }
    6674. 

  6674. 

  6675.     function isBranchFollowed(data,bool){
    6676. 

  6676.         var mode = bool ? 0 : 1;
    6677. 

  6677.         if (typeof data === 'undefined' ||
    6678. 

  6678.             typeof data === null ||
    6679. 

  6679.             typeof data[mode] === 'undefined'){
    6680. 

  6680.             return false;
    6681. 

  6681.         }
    6682. 

  6682.         return data[mode].length > 0;
    6683. 

  6683.     }
    6684. 

  6684. 

  6685.     var branchStack = [];
    6686. 

  6686. 

  6687.     function branchReport(colsIndex,src,cols,offset,lineNum){
    6688. 

  6688.       var newsrc="";
    6689. 

  6689.        var postfix="";
    6690. 

  6690.       if (branchStack.length > 0){
    6691. 

  6691.         newsrc += "<span class='" + (isBranchFollowed(branchStack[0][1],branchStack[0][1].consequent === branchStack[0][0]) ? 'branchOkay' : 'branchWarning') + "'>";
    6692. 

  6692.         if (branchStack[0][0].end.line === lineNum){
    6693. 

  6693.           newsrc += escapeInvalidXmlChars(src.slice(0,branchStack[0][0].end.column)) + "</span>";
    6694. 

  6694.           src = src.slice(branchStack[0][0].end.column);
    6695. 

  6695.           branchStack.shift();
    6696. 

  6696.           if (branchStack.length > 0){
    6697. 

  6697.             newsrc += "<span class='" + (isBranchFollowed(branchStack[0][1],false) ? 'branchOkay' : 'branchWarning') + "'>";
    6698. 

  6698.             if (branchStack[0][0].end.line === lineNum){
    6699. 

  6699.               newsrc += escapeInvalidXmlChars(src.slice(0,branchStack[0][0].end.column)) + "</span>";
    6700. 

  6700.               src = src.slice(branchStack[0][0].end.column);
    6701. 

  6701.               branchStack.shift();
    6702. 

  6702.               if (!cols){
    6703. 

  6703.                 return {src: newsrc + escapeInvalidXmlChars(src) ,cols:cols};
    6704. 

  6704.               }
    6705. 

  6705.             }
    6706. 

  6706.             else if (!cols){
    6707. 

  6707.               return {src: newsrc + escapeInvalidXmlChars(src) + "</span>",cols:cols};
    6708. 

  6708.             }
    6709. 

  6709.             else{
    6710. 

  6710.               postfix = "</span>";
    6711. 

  6711.             }
    6712. 

  6712.           }else if (!cols){
    6713. 

  6713.             return {src: newsrc + escapeInvalidXmlChars(src) ,cols:cols};
    6714. 

  6714.           }
    6715. 

  6715.         }else if(!cols){
    6716. 

  6716.           return {src: newsrc + escapeInvalidXmlChars(src) + "</span>",cols:cols};
    6717. 

  6717.         }else{
    6718. 

  6718.           postfix = "</span>";
    6719. 

  6719.         }
    6720. 

  6720.       }
    6721. 

  6721.       var thisline = cols[colsIndex];
    6722. 

  6722.       //consequent
    6723. 

  6723.       
    6724. 

  6724.       var cons = thisline.consequent;
    6725. 

  6725.       if (cons.start.line > lineNum){
    6726. 

  6726.         branchStack.unshift([thisline.alternate,thisline]);
    6727. 

  6727.         branchStack.unshift([cons,thisline]);
    6728. 

  6728.         src = escapeInvalidXmlChars(src);
    6729. 

  6729.       }else{
    6730. 

  6730.         var style = "<span class='" + (isBranchFollowed(thisline,true) ? 'branchOkay' : 'branchWarning') + "'>";
    6731. 

  6731.         newsrc += escapeInvalidXmlChars(src.slice(0,cons.start.column-offset)) + style;
    6732. 

  6732.         
    6733. 

  6733.         if (cols.length > colsIndex+1 &&
    6734. 

  6734.           cols[colsIndex+1].consequent.start.line === lineNum &&
    6735. 

  6735.           cols[colsIndex+1].consequent.start.column-offset < cols[colsIndex].consequent.end.column-offset)
    6736. 

  6736.         {
    6737. 

  6737.           var res = branchReport(colsIndex+1,src.slice(cons.start.column-offset,cons.end.column-offset),cols,cons.start.column-offset,lineNum);
    6738. 

  6738.           newsrc += res.src;
    6739. 

  6739.           cols = res.cols;
    6740. 

  6740.           cols[colsIndex+1] = cols[colsIndex+2];
    6741. 

  6741.           cols.length--;
    6742. 

  6742.         }else{
    6743. 

  6743.           newsrc += escapeInvalidXmlChars(src.slice(cons.start.column-offset,cons.end.column-offset));
    6744. 

  6744.         }
    6745. 

  6745.         newsrc += "</span>";
    6746. 

  6746. 

  6747.         var alt = thisline.alternate;
    6748. 

  6748.         if (alt.start.line > lineNum){
    6749. 

  6749.           newsrc += escapeInvalidXmlChars(src.slice(cons.end.column-offset));
    6750. 

  6750.           branchStack.unshift([alt,thisline]);
    6751. 

  6751.         }else{
    6752. 

  6752.           newsrc += escapeInvalidXmlChars(src.slice(cons.end.column-offset,alt.start.column-offset));
    6753. 

  6753.           style = "<span class='" + (isBranchFollowed(thisline,false) ? 'branchOkay' : 'branchWarning') + "'>";
    6754. 

  6754.           newsrc +=  style;
    6755. 

  6755.           if (cols.length > colsIndex+1 &&
    6756. 

  6756.             cols[colsIndex+1].consequent.start.line === lineNum &&
    6757. 

  6757.             cols[colsIndex+1].consequent.start.column-offset < cols[colsIndex].alternate.end.column-offset)
    6758. 

  6758.           {
    6759. 

  6759.             var res2 = branchReport(colsIndex+1,src.slice(alt.start.column-offset,alt.end.column-offset),cols,alt.start.column-offset,lineNum);
    6760. 

  6760.             newsrc += res2.src;
    6761. 

  6761.             cols = res2.cols;
    6762. 

  6762.             cols[colsIndex+1] = cols[colsIndex+2];
    6763. 

  6763.             cols.length--;
    6764. 

  6764.           }else{
    6765. 

  6765.             newsrc += escapeInvalidXmlChars(src.slice(alt.start.column-offset,alt.end.column-offset));
    6766. 

  6766.           }
    6767. 

  6767.           newsrc += "</span>";
    6768. 

  6768.           newsrc += escapeInvalidXmlChars(src.slice(alt.end.column-offset));
    6769. 

  6769.           src = newsrc;
    6770. 

  6770.         }
    6771. 

  6771.       }
    6772. 

  6772.       return {src:src+postfix, cols:cols};
    6773. 

  6773.     }
    6774. 

  6774. 

  6775.     var isUndefined =  function(item){
    6776. 

  6776.             return typeof item !== 'undefined';
    6777. 

  6777.       };
    6778. 

  6778. 

  6779.     var files = coverage.files;
    6780. 

  6780.     var totals = {
    6781. 

  6781.       totalSmts: 0,
    6782. 

  6782.       numberOfFilesCovered: 0
    6783. 

  6783.     };
    6784. 

  6784.     for(var file in files)
    6785. 

  6785.     {
    6786. 

  6786.         fileNumber++;
    6787. 

  6787. 

  6788.         var statsForFile = files[file],
    6789. 

  6789.             totalSmts = 0,
    6790. 

  6790.             numberOfFilesCovered = 0,
    6791. 

  6791.             code = [],
    6792. 

  6792.             i;
    6793. 

  6793.         
    6794. 

  6794. 

  6795.         var end = [];
    6796. 

  6796.         for(i = 0; i < statsForFile.source.length; i +=1){
    6797. 

  6797.             var src = statsForFile.source[i];
    6798. 

  6798.             
    6799. 

  6799.             if (branchStack.length > 0 ||
    6800. 

  6800.                 typeof statsForFile.branchData !== 'undefined')
    6801. 

  6801.             {
    6802. 

  6802.                 if (typeof statsForFile.branchData[i+1] !== 'undefined')
    6803. 

  6803.                 {
    6804. 

  6804.                   var cols = statsForFile.branchData[i+1].filter(isUndefined);
    6805. 

  6805.                   var colsIndex=0;
    6806. 

  6806.                   
    6807. 

  6807.                     
    6808. 

  6808.                   src = branchReport(colsIndex,src,cols,0,i+1).src;
    6809. 

  6809.                   
    6810. 

  6810.                 }else if (branchStack.length){
    6811. 

  6811.                   src = branchReport(0,src,null,0,i+1).src;
    6812. 

  6812.                 }else{
    6813. 

  6813.                   src = escapeInvalidXmlChars(src);
    6814. 

  6814.                 }
    6815. 

  6815.               }else{
    6816. 

  6816.                 src = escapeInvalidXmlChars(src);
    6817. 

  6817.               }
    6818. 

  6818.               var lineClass="";
    6819. 

  6819.               if(statsForFile[i+1]) {
    6820. 

  6820.                 numberOfFilesCovered += 1;
    6821. 

  6821.                 totalSmts += 1;
    6822. 

  6822.                 lineClass = 'hit';
    6823. 

  6823.               }else{
    6824. 

  6824.                 if(statsForFile[i+1] === 0){
    6825. 

  6825.                     totalSmts++;
    6826. 

  6826.                     lineClass = 'miss';
    6827. 

  6827.                 }
    6828. 

  6828.               }
    6829. 

  6829.               code[i + 1] = "<div class='"+lineClass+"'><span class=''>"+(i + 1)+"</span>"+src+"</div>";
    6830. 

  6830.               totals.totalSmts += totalSmts;
    6831. 

  6831.               totals.numberOfFilesCovered += numberOfFilesCovered;
    6832. 

  6832.         }
    6833. 

  6833.         var totalBranches=0;
    6834. 

  6834.         var passedBranches=0;
    6835. 

  6835.         if (typeof statsForFile.branchData !== 'undefined'){
    6836. 

  6836.           for(var j=0;j<statsForFile.branchData.length;j++){
    6837. 

  6837.             if (typeof statsForFile.branchData[j] !== 'undefined'){
    6838. 

  6838.               for(var k=0;k<statsForFile.branchData[j].length;k++){
    6839. 

  6839.                 if (typeof statsForFile.branchData[j][k] !== 'undefined'){
    6840. 

  6840.                   totalBranches++;
    6841. 

  6841.                   if (typeof statsForFile.branchData[j][k][0] !== 'undefined' &&
    6842. 

  6842.                     statsForFile.branchData[j][k][0].length > 0 &&
    6843. 

  6843.                     typeof statsForFile.branchData[j][k][1] !== 'undefined' &&
    6844. 

  6844.                     statsForFile.branchData[j][k][1].length > 0){
    6845. 

  6845.                     passedBranches++;
    6846. 

  6846.                   }
    6847. 

  6847.                 }
    6848. 

  6848.               }
    6849. 

  6849.             }
    6850. 

  6850.           }
    6851. 

  6851.         }
    6852. 

  6852.         var result = percentage(numberOfFilesCovered, totalSmts);
    6853. 

  6853. 

  6854.         var output = fileTemplate.replace("{{file}}", file)
    6855. 

  6855.                                  .replace("{{percentage}}",result)
    6856. 

  6856.                                  .replace("{{numberCovered}}", numberOfFilesCovered)
    6857. 

  6857.                                  .replace(/\{\{fileNumber\}\}/g, fileNumber)
    6858. 

  6858.                                  .replace("{{totalSmts}}", totalSmts)
    6859. 

  6859.                                  .replace("{{totalBranches}}", totalBranches)
    6860. 

  6860.                                  .replace("{{passedBranches}}", passedBranches)
    6861. 

  6861.                                  .replace("{{source}}", code.join(" "));
    6862. 

  6862.         if(result < successRate)
    6863. 

  6863.         {
    6864. 

  6864.             output = output.replace("{{statusclass}}", "bl-error");
    6865. 

  6865.         } else {
    6866. 

  6866.             output = output.replace("{{statusclass}}", "bl-success");
    6867. 

  6867.         }
    6868. 

  6868.         bodyContent += output;
    6869. 

  6869.     }
    6870. 

  6870. 

  6871.     var totalPercent = percentage(totals.numberOfFilesCovered, totals.totalSmts);
    6872. 

  6872.     var statusClass = totalPercent < successRate ? "bl-error" : "bl-success";
    6873. 

  6873.     var totalsOutput = grandTotalTemplate.replace("{{percentage}}", totalPercent)
    6874. 

  6874.                                .replace("{{numberCovered}}", totals.numberOfFilesCovered)
    6875. 

  6875.                                .replace("{{totalSmts}}", totals.totalSmts)
    6876. 

  6876.                                .replace("{{statusclass}}", statusClass);
    6877. 

  6877. 

  6878.     bodyContent += totalsOutput;
    6879. 

  6879.     bodyContent += "</div>"; //closing main
    6880. 

  6880. 

  6881. 

  6882.     appendTag('style', head, cssSytle);
    6883. 

  6883.     //appendStyle(body, headerContent);
    6884. 

  6884.     if (document.getElementById("blanket-main")){
    6885. 

  6885.         document.getElementById("blanket-main").innerHTML=
    6886. 

  6886.             bodyContent.slice(23,-6);
    6887. 

  6887.     }else{
    6888. 

  6888.         appendTag('div', body, bodyContent);
    6889. 

  6889.     }
    6890. 

  6890.     //appendHtml(body, '</div>');
    6891. 

  6891. };
    6892. 

  6892. 

  6893. (function(){
    6894. 

  6894.     var newOptions={};
    6895. 

  6895.     //http://stackoverflow.com/a/2954896
    6896. 

  6896.     var toArray =Array.prototype.slice;
    6897. 

  6897.     var scripts = toArray.call(document.scripts);
    6898. 

  6898.     toArray.call(scripts[scripts.length - 1].attributes)
    6899. 

  6899.                     .forEach(function(es){
    6900. 

  6900.                         if(es.nodeName === "data-cover-only"){
    6901. 

  6901.                             newOptions.filter = es.nodeValue;
    6902. 

  6902.                         }
    6903. 

  6903.                         if(es.nodeName === "data-cover-never"){
    6904. 

  6904.                             newOptions.antifilter = es.nodeValue;
    6905. 

  6905.                         }
    6906. 

  6906.                         if(es.nodeName === "data-cover-reporter"){
    6907. 

  6907.                             newOptions.reporter = es.nodeValue;
    6908. 

  6908.                         }
    6909. 

  6909.                         if (es.nodeName === "data-cover-adapter"){
    6910. 

  6910.                             newOptions.adapter = es.nodeValue;
    6911. 

  6911.                         }
    6912. 

  6912.                         if (es.nodeName === "data-cover-loader"){
    6913. 

  6913.                             newOptions.loader = es.nodeValue;
    6914. 

  6914.                         }
    6915. 

  6915.                         if (es.nodeName === "data-cover-timeout"){
    6916. 

  6916.                             newOptions.timeout = es.nodeValue;
    6917. 

  6917.                         }
    6918. 

  6918.                         if (es.nodeName === "data-cover-reporter-options"){
    6919. 

  6919.                             try{
    6920. 

  6920.                                 newOptions.reporter_options = JSON.parse(es.nodeValue);
    6921. 

  6921.                             }catch(e){
    6922. 

  6922.                                 if (blanket.options("debug")){
    6923. 

  6923.                                     throw new Error("Invalid reporter options.  Must be a valid stringified JSON object.");
    6924. 

  6924.                                 }
    6925. 

  6925.                             }
    6926. 

  6926.                         }
    6927. 

  6927.                         if (es.nodeName === "data-cover-testReadyCallback"){
    6928. 

  6928.                             newOptions.testReadyCallback = es.nodeValue;
    6929. 

  6929.                         }
    6930. 

  6930.                         if (es.nodeName === "data-cover-customVariable"){
    6931. 

  6931.                             newOptions.customVariable = es.nodeValue;
    6932. 

  6932.                         }
    6933. 

  6933.                         if (es.nodeName === "data-cover-flags"){
    6934. 

  6934.                             var flags = " "+es.nodeValue+" ";
    6935. 

  6935.                             if (flags.indexOf(" unordered ") > -1){
    6936. 

  6936.                                 newOptions.order = false;
    6937. 

  6937.                             }
    6938. 

  6938.                             if (flags.indexOf(" ignoreError ") > -1){
    6939. 

  6939.                                 newOptions.ignoreScriptError = true;
    6940. 

  6940.                             }
    6941. 

  6941.                             if (flags.indexOf(" autoStart ") > -1){
    6942. 

  6942.                                 newOptions.autoStart = true;
    6943. 

  6943.                             }
    6944. 

  6944.                             if (flags.indexOf(" ignoreCors ") > -1){
    6945. 

  6945.                                 newOptions.ignoreCors = true;
    6946. 

  6946.                             }
    6947. 

  6947.                             if (flags.indexOf(" branchTracking ") > -1){
    6948. 

  6948.                                 newOptions.branchTracking = true;
    6949. 

  6949.                             }
    6950. 

  6950.                             if (flags.indexOf(" sourceURL ") > -1){
    6951. 

  6951.                                 newOptions.sourceURL = true;
    6952. 

  6952.                             }
    6953. 

  6953.                             if (flags.indexOf(" debug ") > -1){
    6954. 

  6954.                                 newOptions.debug = true;
    6955. 

  6955.                             }
    6956. 

  6956.                             if (flags.indexOf(" engineOnly ") > -1){
    6957. 

  6957.                                 newOptions.engineOnly = true;
    6958. 

  6958.                             }
    6959. 

  6959.                             if (flags.indexOf(" commonJS ") > -1){
    6960. 

  6960.                                 newOptions.commonJS = true;
    6961. 

  6961.                             }
    6962. 

  6962.                              if (flags.indexOf(" instrumentCache ") > -1){
    6963. 

  6963.                                 newOptions.instrumentCache = true;
    6964. 

  6964.                             }
    6965. 

  6965.                         }
    6966. 

  6966.                     });
    6967. 

  6967.     blanket.options(newOptions);
    6968. 

  6968. 

  6969.     if (typeof requirejs !== 'undefined'){
    6970. 

  6970.         blanket.options("existingRequireJS",true);
    6971. 

  6971.     }
    6972. 

  6972.     /* setup requirejs loader, if needed */
    6973. 

  6973.     if (!blanket.options("existingRequireJS") ){
    6974. 

  6974.         if (typeof window["define"] !== "undefined"){
    6975. 

  6975.             window["__blanket_old_define"]=window["define"];
    6976. 

  6976.             window["define"]=void 0;
    6977. 

  6977.         }
    6978. 

  6978.         if (blanket.options("commonJS")){
    6979. 

  6979.             blanket._commonjs = {};
    6980. 

  6980.             blanket.setupRequireJS(blanket._commonjs);
    6981. 

  6981.         }else{
    6982. 

  6982.             blanket.setupRequireJS(window);
    6983. 

  6983.         }
    6984. 

  6984.         if (typeof window["__blanket_old_define"] !== "undefined"){
    6985. 

  6985.             window["define"] = window["__blanket_old_define"];
    6986. 

  6986.         }
    6987. 

  6987.     }
    6988. 

  6988. })();
    6989. 

  6989. (function(_blanket){
    6990. 

  6990. _blanket.extend({
    6991. 

  6991.     utils: {
    6992. 

  6992.     normalizeBackslashes: function(str) {
    6993. 

  6993.         return str.replace(/\\/g, '/');
    6994. 

  6994.     },
    6995. 

  6995.     matchPatternAttribute: function(filename,pattern){
    6996. 

  6996.         if (typeof pattern === 'string'){
    6997. 

  6997.             if (pattern.indexOf("[") === 0){
    6998. 

  6998.                 //treat as array
    6999. 

  6999.                 var pattenArr = pattern.slice(1,pattern.length-1).split(",");
    7000. 

  7000.                 return pattenArr.some(function(elem){
    7001. 

  7001.                     return _blanket.utils.matchPatternAttribute(filename,_blanket.utils.normalizeBackslashes(elem.slice(1,-1)));
    7002. 

  7002.                     //return filename.indexOf(_blanket.utils.normalizeBackslashes(elem.slice(1,-1))) > -1;
    7003. 

  7003.                 });
    7004. 

  7004.             }else if ( pattern.indexOf("//") === 0){
    7005. 

  7005.                 var ex = pattern.slice(2,pattern.lastIndexOf('/'));
    7006. 

  7006.                 var mods = pattern.slice(pattern.lastIndexOf('/')+1);
    7007. 

  7007.                 var regex = new RegExp(ex,mods);
    7008. 

  7008.                 return regex.test(filename);
    7009. 

  7009.             }else if (pattern.indexOf("#") === 0){
    7010. 

  7010.                 return window[pattern.slice(1)].call(window,filename);
    7011. 

  7011.             }else{
    7012. 

  7012.                 return filename.indexOf(_blanket.utils.normalizeBackslashes(pattern)) > -1;
    7013. 

  7013.             }
    7014. 

  7014.         }else if ( pattern instanceof Array ){
    7015. 

  7015.             return pattern.some(function(elem){
    7016. 

  7016.                 return _blanket.utils.matchPatternAttribute(filename,elem);
    7017. 

  7017.             });
    7018. 

  7018.         }else if (pattern instanceof RegExp){
    7019. 

  7019.             return pattern.test(filename);
    7020. 

  7020.         }else if (typeof pattern === "function"){
    7021. 

  7021.             return pattern.call(window,filename);
    7022. 

  7022.         }
    7023. 

  7023.     },
    7024. 

  7024.     blanketEval: function(data){
    7025. 

  7025.         return ( window.execScript || function( data ) {
    7026. 

  7026.             //borrowed from jquery
    7027. 

  7027.             window[ "eval" ].call( window, data );
    7028. 

  7028.         } )( data );
    7029. 

  7029.     },
    7030. 

  7030.     collectPageScripts: function(){
    7031. 

  7031.         console.log("cps1:"+new Date().getTime());
    7032. 

  7032.         var toArray = Array.prototype.slice;
    7033. 

  7033.         var scripts = toArray.call(document.scripts);
    7034. 

  7034.         var selectedScripts=[],scriptNames=[];
    7035. 

  7035.         var filter = _blanket.options("filter");
    7036. 

  7036.         if(filter != null){
    7037. 

  7037.             //global filter in place, data-cover-only
    7038. 

  7038.             var antimatch = _blanket.options("antifilter");
    7039. 

  7039.             selectedScripts = toArray.call(document.scripts)
    7040. 

  7040.                             .filter(function(s){
    7041. 

  7041.                                 return toArray.call(s.attributes).filter(function(sn){
    7042. 

  7042.                                     return sn.nodeName === "src" && _blanket.utils.matchPatternAttribute(sn.nodeValue,filter) &&
    7043. 

  7043.                                         (typeof antimatch === "undefined" || !_blanket.utils.matchPatternAttribute(sn.nodeValue,antimatch));
    7044. 

  7044.                                 }).length === 1;
    7045. 

  7045.                             });
    7046. 

  7046.         }else{
    7047. 

  7047.             selectedScripts = toArray.call(document.querySelectorAll("script[data-cover]"));
    7048. 

  7048.         }
    7049. 

  7049.         scriptNames = selectedScripts.map(function(s){
    7050. 

  7050.                                 return _blanket.utils.qualifyURL(
    7051. 

  7051.                                     toArray.call(s.attributes).filter(
    7052. 

  7052.                                         function(sn){
    7053. 

  7053.                                             return sn.nodeName === "src";
    7054. 

  7054.                                         })[0].nodeValue).replace(".js","");
    7055. 

  7055.                                 });
    7056. 

  7056.         if (!filter){
    7057. 

  7057.             _blanket.options("filter","['"+scriptNames.join("','")+"']");
    7058. 

  7058.         }
    7059. 

  7059.         return scriptNames;
    7060. 

  7060.     }
    7061. 

  7061. }
    7062. 

  7062. });
    7063. 

  7063. (function(){
    7064. 

  7064.     var require = blanket.options("commonJS") ? blanket._commonjs.require : window.require;
    7065. 

  7065.     var requirejs = blanket.options("commonJS") ? blanket._commonjs.requirejs : window.requirejs;
    7066. 

  7066.     if (!_blanket.options("engineOnly")){
    7067. 

  7067. 

  7068.         _blanket.utils.oldloader = requirejs.load;
    7069. 

  7069.         console.log("cps2:"+new Date().getTime());
    7070. 

  7070. 

  7071.         requirejs.load = function (context, moduleName, url) {
    7072. 

  7072.             _blanket.requiringFile(url);
    7073. 

  7073.             requirejs.cget(url, function (content) {
    7074. 

  7074. 

  7075.                 var match = _blanket.options("filter");
    7076. 

  7076.                 //we check the never matches first
    7077. 

  7077.                 var antimatch = _blanket.options("antifilter");
    7078. 

  7078.                 if (typeof antimatch !== "undefined" &&
    7079. 

  7079.                         _blanket.utils.matchPatternAttribute(url.replace(".js",""),antimatch)
    7080. 

  7080.                     ){
    7081. 

  7081.                     _blanket.utils.oldloader(context, moduleName, url);
    7082. 

  7082.                     if (_blanket.options("debug")) {console.log("BLANKET-File will never be instrumented:"+url);}
    7083. 

  7083.                     _blanket.requiringFile(url,true);
    7084. 

  7084.                 }else if (_blanket.utils.matchPatternAttribute(url.replace(".js",""),match)){
    7085. 

  7085.                     if (_blanket.options("debug")) {console.log("BLANKET-Attempting instrument of:"+url);}
    7086. 

  7086.                     _blanket.instrument({
    7087. 

  7087.                         inputFile: content,
    7088. 

  7088.                         inputFileName: url
    7089. 

  7089.                     },function(instrumented){
    7090. 

  7090.                         try{
    7091. 

  7091.                             _blanket.utils.blanketEval(instrumented);
    7092. 

  7092.                             context.completeLoad(moduleName);
    7093. 

  7093.                             _blanket.requiringFile(url,true);
    7094. 

  7094.                         }
    7095. 

  7095.                         catch(err){
    7096. 

  7096.                             if (_blanket.options("ignoreScriptError")){
    7097. 

  7097.                                 //we can continue like normal if
    7098. 

  7098.                                 //we're ignoring script errors,
    7099. 

  7099.                                 //but otherwise we don't want
    7100. 

  7100.                                 //to completeLoad or the error might be
    7101. 

  7101.                                 //missed.
    7102. 

  7102.                                 if (_blanket.options("debug")) { console.log("BLANKET-There was an error loading the file:"+url); }
    7103. 

  7103.                                 context.completeLoad(moduleName);
    7104. 

  7104.                                 _blanket.requiringFile(url,true);
    7105. 

  7105.                             }else{
    7106. 

  7106.                                 throw new Error("Error parsing instrumented code: "+err);
    7107. 

  7107.                             }
    7108. 

  7108.                         }
    7109. 

  7109.                     });
    7110. 

  7110.                 }else{
    7111. 

  7111.                     if (_blanket.options("debug")) { console.log("BLANKET-Loading (without instrumenting) the file:"+url);}
    7112. 

  7112.                     _blanket.utils.oldloader(context, moduleName, url);
    7113. 

  7113.                     _blanket.requiringFile(url,true);
    7114. 

  7114.                 }
    7115. 

  7115. 

  7116.             }, function (err) {
    7117. 

  7117.                 _blanket.requiringFile();
    7118. 

  7118.                 throw err;
    7119. 

  7119.             });
    7120. 

  7120.         };
    7121. 

  7121. 

  7122. 

  7123.         requirejs.createXhr = function () {
    7124. 

  7124.             //Would love to dump the ActiveX crap in here. Need IE 6 to die first.
    7125. 

  7125.             var xhr, i, progId;
    7126. 

  7126.             if (typeof XMLHttpRequest !== "undefined") {
    7127. 

  7127.                 return new XMLHttpRequest();
    7128. 

  7128.             } else if (typeof ActiveXObject !== "undefined") {
    7129. 

  7129.                 for (i = 0; i < 3; i += 1) {
    7130. 

  7130.                     progId = progIds[i];
    7131. 

  7131.                     try {
    7132. 

  7132.                         xhr = new ActiveXObject(progId);
    7133. 

  7133.                     } catch (e) {}
    7134. 

  7134. 

  7135.                     if (xhr) {
    7136. 

  7136.                         progIds = [progId];  // so faster next time
    7137. 

  7137.                         break;
    7138. 

  7138.                     }
    7139. 

  7139.                 }
    7140. 

  7140.             }
    7141. 

  7141. 

  7142.             return xhr;
    7143. 

  7143.         };
    7144. 

  7144. 

  7145. 

  7146.         requirejs.cget = function (url, callback, errback, onXhr) {
    7147. 

  7147.             var foundInSession = false;
    7148. 

  7148.             if (_blanket.blanketSession){
    7149. 

  7149.                 var files = Object.keys(_blanket.blanketSession);
    7150. 

  7150.                 for (var i=0; i<files.length;i++ ){
    7151. 

  7151.                     var key = files[i];
    7152. 

  7152.                     if (url.indexOf(key) > -1){
    7153. 

  7153.                         callback(_blanket.blanketSession[key]);
    7154. 

  7154.                         foundInSession=true;
    7155. 

  7155.                         return;
    7156. 

  7156.                     }
    7157. 

  7157.                 }
    7158. 

  7158.             }
    7159. 

  7159.             if (!foundInSession){
    7160. 

  7160.                 var xhr = requirejs.createXhr();
    7161. 

  7161.                 xhr.open('GET', url, true);
    7162. 

  7162. 

  7163.                 //Allow overrides specified in config
    7164. 

  7164.                 if (onXhr) {
    7165. 

  7165.                     onXhr(xhr, url);
    7166. 

  7166.                 }
    7167. 

  7167. 

  7168.                 xhr.onreadystatechange = function (evt) {
    7169. 

  7169.                     var status, err;
    7170. 

  7170.                     
    7171. 

  7171.                     //Do not explicitly handle errors, those should be
    7172. 

  7172.                     //visible via console output in the browser.
    7173. 

  7173.                     if (xhr.readyState === 4) {
    7174. 

  7174.                         status = xhr.status;
    7175. 

  7175.                         if ((status > 399 && status < 600) /*||
    7176. 

  7176.                             (status === 0 &&
    7177. 

  7177.                                 navigator.userAgent.toLowerCase().indexOf('firefox') > -1)
    7178. 

  7178.                            */ ) {
    7179. 

  7179.                             //An http 4xx or 5xx error. Signal an error.
    7180. 

  7180.                             err = new Error(url + ' HTTP status: ' + status);
    7181. 

  7181.                             err.xhr = xhr;
    7182. 

  7182.                             errback(err);
    7183. 

  7183.                         } else {
    7184. 

  7184.                             callback(xhr.responseText);
    7185. 

  7185.                         }
    7186. 

  7186.                     }
    7187. 

  7187.                 };
    7188. 

  7188.                 try{
    7189. 

  7189.                     xhr.send(null);
    7190. 

  7190.                 }catch(e){
    7191. 

  7191.                     if (e.code && (e.code === 101 || e.code === 1012) && _blanket.options("ignoreCors") === false){
    7192. 

  7192.                         //running locally and getting error from browser
    7193. 

  7193.                         _blanket.showManualLoader();
    7194. 

  7194.                     } else {
    7195. 

  7195.                         throw e;
    7196. 

  7196.                     }
    7197. 

  7197.                 }
    7198. 

  7198.             }
    7199. 

  7199.         };
    7200. 

  7200.     }
    7201. 

  7201. })();
    7202. 

  7202. })(blanket);
    7203. 

  7203. 

  7204. (function(){
    7205. 

  7205. if (typeof QUnit !== 'undefined'){
    7206. 

  7206.     //check to make sure requirejs is completed before we start the test runner
    7207. 

  7207.     var allLoaded = function() {
    7208. 

  7208.         return window.QUnit.config.queue.length > 0 && blanket.noConflict().requireFilesLoaded();
    7209. 

  7209.     };
    7210. 

  7210. 

  7211.     if (!QUnit.config.urlConfig[0].tooltip){
    7212. 

  7212.         //older versions we run coverage automatically
    7213. 

  7213.         //and we change how events are binded
    7214. 

  7214.         QUnit.begin=function(){
    7215. 

  7215.             blanket.noConflict().setupCoverage();
    7216. 

  7216.         };
    7217. 

  7217.         
    7218. 

  7218.         QUnit.done=function(failures, total) {
    7219. 

  7219.             blanket.noConflict().onTestsDone();
    7220. 

  7220.         };
    7221. 

  7221.         QUnit.moduleStart=function( details ) {
    7222. 

  7222.             blanket.noConflict().onModuleStart();
    7223. 

  7223.         };
    7224. 

  7224.         QUnit.testStart=function( details ) {
    7225. 

  7225.             blanket.noConflict().onTestStart();
    7226. 

  7226.         };
    7227. 

  7227.         QUnit.testDone=function( details ) {
    7228. 

  7228.             blanket.noConflict().onTestDone(details.total,details.passed);
    7229. 

  7229.         };
    7230. 

  7230.         blanket.beforeStartTestRunner({
    7231. 

  7231.             condition: allLoaded,
    7232. 

  7232.             callback: QUnit.start
    7233. 

  7233.         });
    7234. 

  7234.     }else{
    7235. 

  7235.         QUnit.config.urlConfig.push({
    7236. 

  7236.             id: "coverage",
    7237. 

  7237.             label: "Enable coverage",
    7238. 

  7238.             tooltip: "Enable code coverage."
    7239. 

  7239.         });
    7240. 

  7240.     
    7241. 

  7241.         if ( QUnit.urlParams.coverage || blanket.options("autoStart") ) {
    7242. 

  7242.             QUnit.begin(function(){
    7243. 

  7243.                 blanket.noConflict().setupCoverage();
    7244. 

  7244.             });
    7245. 

  7245.             
    7246. 

  7246.             QUnit.done(function(failures, total) {
    7247. 

  7247.                 blanket.noConflict().onTestsDone();
    7248. 

  7248.             });
    7249. 

  7249.             QUnit.moduleStart(function( details ) {
    7250. 

  7250.                 blanket.noConflict().onModuleStart();
    7251. 

  7251.             });
    7252. 

  7252.             QUnit.testStart(function( details ) {
    7253. 

  7253.                 blanket.noConflict().onTestStart();
    7254. 

  7254.             });
    7255. 

  7255.             QUnit.testDone(function( details ) {
    7256. 

  7256.                 blanket.noConflict().onTestDone(details.total,details.passed);
    7257. 

  7257.             });
    7258. 

  7258.             blanket.noConflict().beforeStartTestRunner({
    7259. 

  7259.                 condition: allLoaded,
    7260. 

  7260.                 callback: function(){
    7261. 

  7261.                     if (!(blanket.options("existingRequireJS") && !blanket.options("autoStart"))){
    7262. 

  7262.                         QUnit.start();
    7263. 

  7263.                     }
    7264. 

  7264.                 }
    7265. 

  7265.             });
    7266. 

  7266.         }else{
    7267. 

  7267.             requirejs.load = _blanket.utils.oldloader;
    7268. 

  7268.             blanket.noConflict().beforeStartTestRunner({
    7269. 

  7269.                 condition: allLoaded,
    7270. 

  7270.                 callback: function(){
    7271. 

  7271.                     if (!(blanket.options("existingRequireJS") && !blanket.options("autoStart"))){
    7272. 

  7272.                         QUnit.start();
    7273. 

  7273.                     }
    7274. 

  7274.                 },
    7275. 

  7275.                 coverage:false
    7276. 

  7276.             });
    7277. 

  7277.         }
    7278. 

  7278.     }
    7279. 

  7279. }
    7280. 

  7280. })();
    7281.