third_party/blanketjs/src/blanket.js

   1 /*! blanket - v1.1.5 */
   2 (function(define){
   3
   4 /*
   5   Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>
   6   Copyright (C) 2012 Mathias Bynens <mathias@qiwi.be>
   7   Copyright (C) 2012 Joost-Wim Boekesteijn <joost-wim@boekesteijn.nl>
   8   Copyright (C) 2012 Kris Kowal <kris.kowal@cixar.com>
   9   Copyright (C) 2012 Yusuke Suzuki <utatane.tea@gmail.com>
  10   Copyright (C) 2012 Arpad Borsos <arpad.borsos@googlemail.com>
  11   Copyright (C) 2011 Ariya Hidayat <ariya.hidayat@gmail.com>
  12
  13   Redistribution and use in source and binary forms, with or without
  14   modification, are permitted provided that the following conditions are met:
  15
  16     * Redistributions of source code must retain the above copyright
  17       notice, this list of conditions and the following disclaimer.
  18     * Redistributions in binary form must reproduce the above copyright
  19       notice, this list of conditions and the following disclaimer in the
  20       documentation and/or other materials provided with the distribution.
  21
  22   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  23   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25   ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
  26   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  27   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  29   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  31   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32 */
  33
  34 /*jslint bitwise:true plusplus:true */
  35 /*global esprima:true, define:true, exports:true, window: true,
  36 throwError: true, createLiteral: true, generateStatement: true,
  37 parseAssignmentExpression: true, parseBlock: true, parseExpression: true,
  38 parseFunctionDeclaration: true, parseFunctionExpression: true,
  39 parseFunctionSourceElements: true, parseVariableIdentifier: true,
  40 parseLeftHandSideExpression: true,
  41 parseStatement: true, parseSourceElement: true */
  42
  43 (function (root, factory) {
  44     'use strict';
  45
  46     // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js,
  47     // Rhino, and plain browser loading.
  48     if (typeof define === 'function' && define.amd) {
  49         define(['exports'], factory);
  50     } else if (typeof exports !== 'undefined') {
  51         factory(exports);
  52     } else {
  53         factory((root.esprima = {}));
  54     }
  55 }(this, function (exports) {
  56     'use strict';
  57
  58     var Token,
  59         TokenName,
  60         Syntax,
  61         PropertyKind,
  62         Messages,
  63         Regex,
  64         source,
  65         strict,
  66         index,
  67         lineNumber,
  68         lineStart,
  69         length,
  70         buffer,
  71         state,
  72         extra;
  73
  74     Token = {
  75         BooleanLiteral: 1,
  76         EOF: 2,
  77         Identifier: 3,
  78         Keyword: 4,
  79         NullLiteral: 5,
  80         NumericLiteral: 6,
  81         Punctuator: 7,
  82         StringLiteral: 8
  83     };
  84
  85     TokenName = {};
  86     TokenName[Token.BooleanLiteral] = 'Boolean';
  87     TokenName[Token.EOF] = '<end>';
  88     TokenName[Token.Identifier] = 'Identifier';
  89     TokenName[Token.Keyword] = 'Keyword';
  90     TokenName[Token.NullLiteral] = 'Null';
  91     TokenName[Token.NumericLiteral] = 'Numeric';
  92     TokenName[Token.Punctuator] = 'Punctuator';
  93     TokenName[Token.StringLiteral] = 'String';
  94
  95     Syntax = {
  96         AssignmentExpression: 'AssignmentExpression',
  97         ArrayExpression: 'ArrayExpression',
  98         BlockStatement: 'BlockStatement',
  99         BinaryExpression: 'BinaryExpression',
 100         BreakStatement: 'BreakStatement',
 101         CallExpression: 'CallExpression',
 102         CatchClause: 'CatchClause',
 103         ConditionalExpression: 'ConditionalExpression',
 104         ContinueStatement: 'ContinueStatement',
 105         DoWhileStatement: 'DoWhileStatement',
 106         DebuggerStatement: 'DebuggerStatement',
 107         EmptyStatement: 'EmptyStatement',
 108         ExpressionStatement: 'ExpressionStatement',
 109         ForStatement: 'ForStatement',
 110         ForInStatement: 'ForInStatement',
 111         FunctionDeclaration: 'FunctionDeclaration',
 112         FunctionExpression: 'FunctionExpression',
 113         Identifier: 'Identifier',
 114         IfStatement: 'IfStatement',
 115         Literal: 'Literal',
 116         LabeledStatement: 'LabeledStatement',
 117         LogicalExpression: 'LogicalExpression',
 118         MemberExpression: 'MemberExpression',
 119         NewExpression: 'NewExpression',
 120         ObjectExpression: 'ObjectExpression',
 121         Program: 'Program',
 122         Property: 'Property',
 123         ReturnStatement: 'ReturnStatement',
 124         SequenceExpression: 'SequenceExpression',
 125         SwitchStatement: 'SwitchStatement',
 126         SwitchCase: 'SwitchCase',
 127         ThisExpression: 'ThisExpression',
 128         ThrowStatement: 'ThrowStatement',
 129         TryStatement: 'TryStatement',
 130         UnaryExpression: 'UnaryExpression',
 131         UpdateExpression: 'UpdateExpression',
 132         VariableDeclaration: 'VariableDeclaration',
 133         VariableDeclarator: 'VariableDeclarator',
 134         WhileStatement: 'WhileStatement',
 135         WithStatement: 'WithStatement'
 136     };
 137
 138     PropertyKind = {
 139         Data: 1,
 140         Get: 2,
 141         Set: 4
 142     };
 143
 144     // Error messages should be identical to V8.
 145     Messages = {
 146         UnexpectedToken:  'Unexpected token %0',
 147         UnexpectedNumber:  'Unexpected number',
 148         UnexpectedString:  'Unexpected string',
 149         UnexpectedIdentifier:  'Unexpected identifier',
 150         UnexpectedReserved:  'Unexpected reserved word',
 151         UnexpectedEOS:  'Unexpected end of input',
 152         NewlineAfterThrow:  'Illegal newline after throw',
 153         InvalidRegExp: 'Invalid regular expression',
 154         UnterminatedRegExp:  'Invalid regular expression: missing /',
 155         InvalidLHSInAssignment:  'Invalid left-hand side in assignment',
 156         InvalidLHSInForIn:  'Invalid left-hand side in for-in',
 157         MultipleDefaultsInSwitch: 'More than one default clause in switch statement',
 158         NoCatchOrFinally:  'Missing catch or finally after try',
 159         UnknownLabel: 'Undefined label \'%0\'',
 160         Redeclaration: '%0 \'%1\' has already been declared',
 161         IllegalContinue: 'Illegal continue statement',
 162         IllegalBreak: 'Illegal break statement',
 163         IllegalReturn: 'Illegal return statement',
 164         StrictModeWith:  'Strict mode code may not include a with statement',
 165         StrictCatchVariable:  'Catch variable may not be eval or arguments in strict mode',
 166         StrictVarName:  'Variable name may not be eval or arguments in strict mode',
 167         StrictParamName:  'Parameter name eval or arguments is not allowed in strict mode',
 168         StrictParamDupe: 'Strict mode function may not have duplicate parameter names',
 169         StrictFunctionName:  'Function name may not be eval or arguments in strict mode',
 170         StrictOctalLiteral:  'Octal literals are not allowed in strict mode.',
 171         StrictDelete:  'Delete of an unqualified identifier in strict mode.',
 172         StrictDuplicateProperty:  'Duplicate data property in object literal not allowed in strict mode',
 173         AccessorDataProperty:  'Object literal may not have data and accessor property with the same name',
 174         AccessorGetSet:  'Object literal may not have multiple get/set accessors with the same name',
 175         StrictLHSAssignment:  'Assignment to eval or arguments is not allowed in strict mode',
 176         StrictLHSPostfix:  'Postfix increment/decrement may not have eval or arguments operand in strict mode',
 177         StrictLHSPrefix:  'Prefix increment/decrement may not have eval or arguments operand in strict mode',
 178         StrictReservedWord:  'Use of future reserved word in strict mode'
 179     };
 180
 181     // See also tools/generate-unicode-regex.py.
 182     Regex = {
 183         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]'),
 184         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]')
 185     };
 186
 187     // Ensure the condition is true, otherwise throw an error.
 188     // This is only to have a better contract semantic, i.e. another safety net
 189     // to catch a logic error. The condition shall be fulfilled in normal case.
 190     // Do NOT use this to enforce a certain condition on any user input.
 191
 192     function assert(condition, message) {
 193         if (!condition) {
 194             throw new Error('ASSERT: ' + message);
 195         }
 196     }
 197
 198     function sliceSource(from, to) {
 199         return source.slice(from, to);
 200     }
 201
 202     if (typeof 'esprima'[0] === 'undefined') {
 203         sliceSource = function sliceArraySource(from, to) {
 204             return source.slice(from, to).join('');
 205         };
 206     }
 207
 208     function isDecimalDigit(ch) {
 209         return '0123456789'.indexOf(ch) >= 0;
 210     }
 211
 212     function isHexDigit(ch) {
 213         return '0123456789abcdefABCDEF'.indexOf(ch) >= 0;
 214     }
 215
 216     function isOctalDigit(ch) {
 217         return '01234567'.indexOf(ch) >= 0;
 218     }
 219
 220
 221     // 7.2 White Space
 222
 223     function isWhiteSpace(ch) {
 224         return (ch === ' ') || (ch === '\u0009') || (ch === '\u000B') ||
 225             (ch === '\u000C') || (ch === '\u00A0') ||
 226             (ch.charCodeAt(0) >= 0x1680 &&
 227              '\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\uFEFF'.indexOf(ch) >= 0);
 228     }
 229
 230     // 7.3 Line Terminators
 231
 232     function isLineTerminator(ch) {
 233         return (ch === '\n' || ch === '\r' || ch === '\u2028' || ch === '\u2029');
 234     }
 235
 236     // 7.6 Identifier Names and Identifiers
 237
 238     function isIdentifierStart(ch) {
 239         return (ch === '$') || (ch === '_') || (ch === '\\') ||
 240             (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||
 241             ((ch.charCodeAt(0) >= 0x80) && Regex.NonAsciiIdentifierStart.test(ch));
 242     }
 243
 244     function isIdentifierPart(ch) {
 245         return (ch === '$') || (ch === '_') || (ch === '\\') ||
 246             (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||
 247             ((ch >= '0') && (ch <= '9')) ||
 248             ((ch.charCodeAt(0) >= 0x80) && Regex.NonAsciiIdentifierPart.test(ch));
 249     }
 250
 251     // 7.6.1.2 Future Reserved Words
 252
 253     function isFutureReservedWord(id) {
 254         switch (id) {
 255
 256         // Future reserved words.
 257         case 'class':
 258         case 'enum':
 259         case 'export':
 260         case 'extends':
 261         case 'import':
 262         case 'super':
 263             return true;
 264         }
 265
 266         return false;
 267     }
 268
 269     function isStrictModeReservedWord(id) {
 270         switch (id) {
 271
 272         // Strict Mode reserved words.
 273         case 'implements':
 274         case 'interface':
 275         case 'package':
 276         case 'private':
 277         case 'protected':
 278         case 'public':
 279         case 'static':
 280         case 'yield':
 281         case 'let':
 282             return true;
 283         }
 284
 285         return false;
 286     }
 287
 288     function isRestrictedWord(id) {
 289         return id === 'eval' || id === 'arguments';
 290     }
 291
 292     // 7.6.1.1 Keywords
 293
 294     function isKeyword(id) {
 295         var keyword = false;
 296         switch (id.length) {
 297         case 2:
 298             keyword = (id === 'if') || (id === 'in') || (id === 'do');
 299             break;
 300         case 3:
 301             keyword = (id === 'var') || (id === 'for') || (id === 'new') || (id === 'try');
 302             break;
 303         case 4:
 304             keyword = (id === 'this') || (id === 'else') || (id === 'case') || (id === 'void') || (id === 'with');
 305             break;
 306         case 5:
 307             keyword = (id === 'while') || (id === 'break') || (id === 'catch') || (id === 'throw');
 308             break;
 309         case 6:
 310             keyword = (id === 'return') || (id === 'typeof') || (id === 'delete') || (id === 'switch');
 311             break;
 312         case 7:
 313             keyword = (id === 'default') || (id === 'finally');
 314             break;
 315         case 8:
 316             keyword = (id === 'function') || (id === 'continue') || (id === 'debugger');
 317             break;
 318         case 10:
 319             keyword = (id === 'instanceof');
 320             break;
 321         }
 322
 323         if (keyword) {
 324             return true;
 325         }
 326
 327         switch (id) {
 328         // Future reserved words.
 329         // 'const' is specialized as Keyword in V8.
 330         case 'const':
 331             return true;
 332
 333         // For compatiblity to SpiderMonkey and ES.next
 334         case 'yield':
 335         case 'let':
 336             return true;
 337         }
 338
 339         if (strict && isStrictModeReservedWord(id)) {
 340             return true;
 341         }
 342
 343         return isFutureReservedWord(id);
 344     }
 345
 346     // 7.4 Comments
 347
 348     function skipComment() {
 349         var ch, blockComment, lineComment;
 350
 351         blockComment = false;
 352         lineComment = false;
 353
 354         while (index < length) {
 355             ch = source[index];
 356
 357             if (lineComment) {
 358                 ch = source[index++];
 359                 if (isLineTerminator(ch)) {
 360                     lineComment = false;
 361                     if (ch === '\r' && source[index] === '\n') {
 362                         ++index;
 363                     }
 364                     ++lineNumber;
 365                     lineStart = index;
 366                 }
 367             } else if (blockComment) {
 368                 if (isLineTerminator(ch)) {
 369                     if (ch === '\r' && source[index + 1] === '\n') {
 370                         ++index;
 371                     }
 372                     ++lineNumber;
 373                     ++index;
 374                     lineStart = index;
 375                     if (index >= length) {
 376                         throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
 377                     }
 378                 } else {
 379                     ch = source[index++];
 380                     if (index >= length) {
 381                         throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
 382                     }
 383                     if (ch === '*') {
 384                         ch = source[index];
 385                         if (ch === '/') {
 386                             ++index;
 387                             blockComment = false;
 388                         }
 389                     }
 390                 }
 391             } else if (ch === '/') {
 392                 ch = source[index + 1];
 393                 if (ch === '/') {
 394                     index += 2;
 395                     lineComment = true;
 396                 } else if (ch === '*') {
 397                     index += 2;
 398                     blockComment = true;
 399                     if (index >= length) {
 400                         throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
 401                     }
 402                 } else {
 403                     break;
 404                 }
 405             } else if (isWhiteSpace(ch)) {
 406                 ++index;
 407             } else if (isLineTerminator(ch)) {
 408                 ++index;
 409                 if (ch ===  '\r' && source[index] === '\n') {
 410                     ++index;
 411                 }
 412                 ++lineNumber;
 413                 lineStart = index;
 414             } else {
 415                 break;
 416             }
 417         }
 418     }
 419
 420     function scanHexEscape(prefix) {
 421         var i, len, ch, code = 0;
 422
 423         len = (prefix === 'u') ? 4 : 2;
 424         for (i = 0; i < len; ++i) {
 425             if (index < length && isHexDigit(source[index])) {
 426                 ch = source[index++];
 427                 code = code * 16 + '0123456789abcdef'.indexOf(ch.toLowerCase());
 428             } else {
 429                 return '';
 430             }
 431         }
 432         return String.fromCharCode(code);
 433     }
 434
 435     function scanIdentifier() {
 436         var ch, start, id, restore;
 437
 438         ch = source[index];
 439         if (!isIdentifierStart(ch)) {
 440             return;
 441         }
 442
 443         start = index;
 444         if (ch === '\\') {
 445             ++index;
 446             if (source[index] !== 'u') {
 447                 return;
 448             }
 449             ++index;
 450             restore = index;
 451             ch = scanHexEscape('u');
 452             if (ch) {
 453                 if (ch === '\\' || !isIdentifierStart(ch)) {
 454                     return;
 455                 }
 456                 id = ch;
 457             } else {
 458                 index = restore;
 459                 id = 'u';
 460             }
 461         } else {
 462             id = source[index++];
 463         }
 464
 465         while (index < length) {
 466             ch = source[index];
 467             if (!isIdentifierPart(ch)) {
 468                 break;
 469             }
 470             if (ch === '\\') {
 471                 ++index;
 472                 if (source[index] !== 'u') {
 473                     return;
 474                 }
 475                 ++index;
 476                 restore = index;
 477                 ch = scanHexEscape('u');
 478                 if (ch) {
 479                     if (ch === '\\' || !isIdentifierPart(ch)) {
 480                         return;
 481                     }
 482                     id += ch;
 483                 } else {
 484                     index = restore;
 485                     id += 'u';
 486                 }
 487             } else {
 488                 id += source[index++];
 489             }
 490         }
 491
 492         // There is no keyword or literal with only one character.
 493         // Thus, it must be an identifier.
 494         if (id.length === 1) {
 495             return {
 496                 type: Token.Identifier,
 497                 value: id,
 498                 lineNumber: lineNumber,
 499                 lineStart: lineStart,
 500                 range: [start, index]
 501             };
 502         }
 503
 504         if (isKeyword(id)) {
 505             return {
 506                 type: Token.Keyword,
 507                 value: id,
 508                 lineNumber: lineNumber,
 509                 lineStart: lineStart,
 510                 range: [start, index]
 511             };
 512         }
 513
 514         // 7.8.1 Null Literals
 515
 516         if (id === 'null') {
 517             return {
 518                 type: Token.NullLiteral,
 519                 value: id,
 520                 lineNumber: lineNumber,
 521                 lineStart: lineStart,
 522                 range: [start, index]
 523             };
 524         }
 525
 526         // 7.8.2 Boolean Literals
 527
 528         if (id === 'true' || id === 'false') {
 529             return {
 530                 type: Token.BooleanLiteral,
 531                 value: id,
 532                 lineNumber: lineNumber,
 533                 lineStart: lineStart,
 534                 range: [start, index]
 535             };
 536         }
 537
 538         return {
 539             type: Token.Identifier,
 540             value: id,
 541             lineNumber: lineNumber,
 542             lineStart: lineStart,
 543             range: [start, index]
 544         };
 545     }
 546
 547     // 7.7 Punctuators
 548
 549     function scanPunctuator() {
 550         var start = index,
 551             ch1 = source[index],
 552             ch2,
 553             ch3,
 554             ch4;
 555
 556         // Check for most common single-character punctuators.
 557
 558         if (ch1 === ';' || ch1 === '{' || ch1 === '}') {
 559             ++index;
 560             return {
 561                 type: Token.Punctuator,
 562                 value: ch1,
 563                 lineNumber: lineNumber,
 564                 lineStart: lineStart,
 565                 range: [start, index]
 566             };
 567         }
 568
 569         if (ch1 === ',' || ch1 === '(' || ch1 === ')') {
 570             ++index;
 571             return {
 572                 type: Token.Punctuator,
 573                 value: ch1,
 574                 lineNumber: lineNumber,
 575                 lineStart: lineStart,
 576                 range: [start, index]
 577             };
 578         }
 579
 580         // Dot (.) can also start a floating-point number, hence the need
 581         // to check the next character.
 582
 583         ch2 = source[index + 1];
 584         if (ch1 === '.' && !isDecimalDigit(ch2)) {
 585             return {
 586                 type: Token.Punctuator,
 587                 value: source[index++],
 588                 lineNumber: lineNumber,
 589                 lineStart: lineStart,
 590                 range: [start, index]
 591             };
 592         }
 593
 594         // Peek more characters.
 595
 596         ch3 = source[index + 2];
 597         ch4 = source[index + 3];
 598
 599         // 4-character punctuator: >>>=
 600
 601         if (ch1 === '>' && ch2 === '>' && ch3 === '>') {
 602             if (ch4 === '=') {
 603                 index += 4;
 604                 return {
 605                     type: Token.Punctuator,
 606                     value: '>>>=',
 607                     lineNumber: lineNumber,
 608                     lineStart: lineStart,
 609                     range: [start, index]
 610                 };
 611             }
 612         }
 613
 614         // 3-character punctuators: === !== >>> <<= >>=
 615
 616         if (ch1 === '=' && ch2 === '=' && ch3 === '=') {
 617             index += 3;
 618             return {
 619                 type: Token.Punctuator,
 620                 value: '===',
 621                 lineNumber: lineNumber,
 622                 lineStart: lineStart,
 623                 range: [start, index]
 624             };
 625         }
 626
 627         if (ch1 === '!' && ch2 === '=' && ch3 === '=') {
 628             index += 3;
 629             return {
 630                 type: Token.Punctuator,
 631                 value: '!==',
 632                 lineNumber: lineNumber,
 633                 lineStart: lineStart,
 634                 range: [start, index]
 635             };
 636         }
 637
 638         if (ch1 === '>' && ch2 === '>' && ch3 === '>') {
 639             index += 3;
 640             return {
 641                 type: Token.Punctuator,
 642                 value: '>>>',
 643                 lineNumber: lineNumber,
 644                 lineStart: lineStart,
 645                 range: [start, index]
 646             };
 647         }
 648
 649         if (ch1 === '<' && ch2 === '<' && ch3 === '=') {
 650             index += 3;
 651             return {
 652                 type: Token.Punctuator,
 653                 value: '<<=',
 654                 lineNumber: lineNumber,
 655                 lineStart: lineStart,
 656                 range: [start, index]
 657             };
 658         }
 659
 660         if (ch1 === '>' && ch2 === '>' && ch3 === '=') {
 661             index += 3;
 662             return {
 663                 type: Token.Punctuator,
 664                 value: '>>=',
 665                 lineNumber: lineNumber,
 666                 lineStart: lineStart,
 667                 range: [start, index]
 668             };
 669         }
 670
 671         // 2-character punctuators: <= >= == != ++ -- << >> && ||
 672         // += -= *= %= &= |= ^= /=
 673
 674         if (ch2 === '=') {
 675             if ('<>=!+-*%&|^/'.indexOf(ch1) >= 0) {
 676                 index += 2;
 677                 return {
 678                     type: Token.Punctuator,
 679                     value: ch1 + ch2,
 680                     lineNumber: lineNumber,
 681                     lineStart: lineStart,
 682                     range: [start, index]
 683                 };
 684             }
 685         }
 686
 687         if (ch1 === ch2 && ('+-<>&|'.indexOf(ch1) >= 0)) {
 688             if ('+-<>&|'.indexOf(ch2) >= 0) {
 689                 index += 2;
 690                 return {
 691                     type: Token.Punctuator,
 692                     value: ch1 + ch2,
 693                     lineNumber: lineNumber,
 694                     lineStart: lineStart,
 695                     range: [start, index]
 696                 };
 697             }
 698         }
 699
 700         // The remaining 1-character punctuators.
 701
 702         if ('[]<>+-*%&|^!~?:=/'.indexOf(ch1) >= 0) {
 703             return {
 704                 type: Token.Punctuator,
 705                 value: source[index++],
 706                 lineNumber: lineNumber,
 707                 lineStart: lineStart,
 708                 range: [start, index]
 709             };
 710         }
 711     }
 712
 713     // 7.8.3 Numeric Literals
 714
 715     function scanNumericLiteral() {
 716         var number, start, ch;
 717
 718         ch = source[index];
 719         assert(isDecimalDigit(ch) || (ch === '.'),
 720             'Numeric literal must start with a decimal digit or a decimal point');
 721
 722         start = index;
 723         number = '';
 724         if (ch !== '.') {
 725             number = source[index++];
 726             ch = source[index];
 727
 728             // Hex number starts with '0x'.
 729             // Octal number starts with '0'.
 730             if (number === '0') {
 731                 if (ch === 'x' || ch === 'X') {
 732                     number += source[index++];
 733                     while (index < length) {
 734                         ch = source[index];
 735                         if (!isHexDigit(ch)) {
 736                             break;
 737                         }
 738                         number += source[index++];
 739                     }
 740
 741                     if (number.length <= 2) {
 742                         // only 0x
 743                         throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
 744                     }
 745
 746                     if (index < length) {
 747                         ch = source[index];
 748                         if (isIdentifierStart(ch)) {
 749                             throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
 750                         }
 751                     }
 752                     return {
 753                         type: Token.NumericLiteral,
 754                         value: parseInt(number, 16),
 755                         lineNumber: lineNumber,
 756                         lineStart: lineStart,
 757                         range: [start, index]
 758                     };
 759                 } else if (isOctalDigit(ch)) {
 760                     number += source[index++];
 761                     while (index < length) {
 762                         ch = source[index];
 763                         if (!isOctalDigit(ch)) {
 764                             break;
 765                         }
 766                         number += source[index++];
 767                     }
 768
 769                     if (index < length) {
 770                         ch = source[index];
 771                         if (isIdentifierStart(ch) || isDecimalDigit(ch)) {
 772                             throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
 773                         }
 774                     }
 775                     return {
 776                         type: Token.NumericLiteral,
 777                         value: parseInt(number, 8),
 778                         octal: true,
 779                         lineNumber: lineNumber,
 780                         lineStart: lineStart,
 781                         range: [start, index]
 782                     };
 783                 }
 784
 785                 // decimal number starts with '0' such as '09' is illegal.
 786                 if (isDecimalDigit(ch)) {
 787                     throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
 788                 }
 789             }
 790
 791             while (index < length) {
 792                 ch = source[index];
 793                 if (!isDecimalDigit(ch)) {
 794                     break;
 795                 }
 796                 number += source[index++];
 797             }
 798         }
 799
 800         if (ch === '.') {
 801             number += source[index++];
 802             while (index < length) {
 803                 ch = source[index];
 804                 if (!isDecimalDigit(ch)) {
 805                     break;
 806                 }
 807                 number += source[index++];
 808             }
 809         }
 810
 811         if (ch === 'e' || ch === 'E') {
 812             number += source[index++];
 813
 814             ch = source[index];
 815             if (ch === '+' || ch === '-') {
 816                 number += source[index++];
 817             }
 818
 819             ch = source[index];
 820             if (isDecimalDigit(ch)) {
 821                 number += source[index++];
 822                 while (index < length) {
 823                     ch = source[index];
 824                     if (!isDecimalDigit(ch)) {
 825                         break;
 826                     }
 827                     number += source[index++];
 828                 }
 829             } else {
 830                 ch = 'character ' + ch;
 831                 if (index >= length) {
 832                     ch = '<end>';
 833                 }
 834                 throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
 835             }
 836         }
 837
 838         if (index < length) {
 839             ch = source[index];
 840             if (isIdentifierStart(ch)) {
 841                 throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
 842             }
 843         }
 844
 845         return {
 846             type: Token.NumericLiteral,
 847             value: parseFloat(number),
 848             lineNumber: lineNumber,
 849             lineStart: lineStart,
 850             range: [start, index]
 851         };
 852     }
 853
 854     // 7.8.4 String Literals
 855
 856     function scanStringLiteral() {
 857         var str = '', quote, start, ch, code, unescaped, restore, octal = false;
 858
 859         quote = source[index];
 860         assert((quote === '\'' || quote === '"'),
 861             'String literal must starts with a quote');
 862
 863         start = index;
 864         ++index;
 865
 866         while (index < length) {
 867             ch = source[index++];
 868
 869             if (ch === quote) {
 870                 quote = '';
 871                 break;
 872             } else if (ch === '\\') {
 873                 ch = source[index++];
 874                 if (!isLineTerminator(ch)) {
 875                     switch (ch) {
 876                     case 'n':
 877                         str += '\n';
 878                         break;
 879                     case 'r':
 880                         str += '\r';
 881                         break;
 882                     case 't':
 883                         str += '\t';
 884                         break;
 885                     case 'u':
 886                     case 'x':
 887                         restore = index;
 888                         unescaped = scanHexEscape(ch);
 889                         if (unescaped) {
 890                             str += unescaped;
 891                         } else {
 892                             index = restore;
 893                             str += ch;
 894                         }
 895                         break;
 896                     case 'b':
 897                         str += '\b';
 898                         break;
 899                     case 'f':
 900                         str += '\f';
 901                         break;
 902                     case 'v':
 903                         str += '\v';
 904                         break;
 905
 906                     default:
 907                         if (isOctalDigit(ch)) {
 908                             code = '01234567'.indexOf(ch);
 909
 910                             // \0 is not octal escape sequence
 911                             if (code !== 0) {
 912                                 octal = true;
 913                             }
 914
 915                             if (index < length && isOctalDigit(source[index])) {
 916                                 octal = true;
 917                                 code = code * 8 + '01234567'.indexOf(source[index++]);
 918
 919                                 // 3 digits are only allowed when string starts
 920                                 // with 0, 1, 2, 3
 921                                 if ('0123'.indexOf(ch) >= 0 &&
 922                                         index < length &&
 923                                         isOctalDigit(source[index])) {
 924                                     code = code * 8 + '01234567'.indexOf(source[index++]);
 925                                 }
 926                             }
 927                             str += String.fromCharCode(code);
 928                         } else {
 929                             str += ch;
 930                         }
 931                         break;
 932                     }
 933                 } else {
 934                     ++lineNumber;
 935                     if (ch ===  '\r' && source[index] === '\n') {
 936                         ++index;
 937                     }
 938                 }
 939             } else if (isLineTerminator(ch)) {
 940                 break;
 941             } else {
 942                 str += ch;
 943             }
 944         }
 945
 946         if (quote !== '') {
 947             throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
 948         }
 949
 950         return {
 951             type: Token.StringLiteral,
 952             value: str,
 953             octal: octal,
 954             lineNumber: lineNumber,
 955             lineStart: lineStart,
 956             range: [start, index]
 957         };
 958     }
 959
 960     function scanRegExp() {
 961         var str, ch, start, pattern, flags, value, classMarker = false, restore, terminated = false;
 962
 963         buffer = null;
 964         skipComment();
 965
 966         start = index;
 967         ch = source[index];
 968         assert(ch === '/', 'Regular expression literal must start with a slash');
 969         str = source[index++];
 970
 971         while (index < length) {
 972             ch = source[index++];
 973             str += ch;
 974             if (classMarker) {
 975                 if (ch === ']') {
 976                     classMarker = false;
 977                 }
 978             } else {
 979                 if (ch === '\\') {
 980                     ch = source[index++];
 981                     // ECMA-262 7.8.5
 982                     if (isLineTerminator(ch)) {
 983                         throwError({}, Messages.UnterminatedRegExp);
 984                     }
 985                     str += ch;
 986                 } else if (ch === '/') {
 987                     terminated = true;
 988                     break;
 989                 } else if (ch === '[') {
 990                     classMarker = true;
 991                 } else if (isLineTerminator(ch)) {
 992                     throwError({}, Messages.UnterminatedRegExp);
 993                 }
 994             }
 995         }
 996
 997         if (!terminated) {
 998             throwError({}, Messages.UnterminatedRegExp);
 999         }
1000
1001         // Exclude leading and trailing slash.
1002         pattern = str.substr(1, str.length - 2);
1003
1004         flags = '';
1005         while (index < length) {
1006             ch = source[index];
1007             if (!isIdentifierPart(ch)) {
1008                 break;
1009             }
1010
1011             ++index;
1012             if (ch === '\\' && index < length) {
1013                 ch = source[index];
1014                 if (ch === 'u') {
1015                     ++index;
1016                     restore = index;
1017                     ch = scanHexEscape('u');
1018                     if (ch) {
1019                         flags += ch;
1020                         str += '\\u';
1021                         for (; restore < index; ++restore) {
1022                             str += source[restore];
1023                         }
1024                     } else {
1025                         index = restore;
1026                         flags += 'u';
1027                         str += '\\u';
1028                     }
1029                 } else {
1030                     str += '\\';
1031                 }
1032             } else {
1033                 flags += ch;
1034                 str += ch;
1035             }
1036         }
1037
1038         try {
1039             value = new RegExp(pattern, flags);
1040         } catch (e) {
1041             throwError({}, Messages.InvalidRegExp);
1042         }
1043
1044         return {
1045             literal: str,
1046             value: value,
1047             range: [start, index]
1048         };
1049     }
1050
1051     function isIdentifierName(token) {
1052         return token.type === Token.Identifier ||
1053             token.type === Token.Keyword ||
1054             token.type === Token.BooleanLiteral ||
1055             token.type === Token.NullLiteral;
1056     }
1057
1058     function advance() {
1059         var ch, token;
1060
1061         skipComment();
1062
1063         if (index >= length) {
1064             return {
1065                 type: Token.EOF,
1066                 lineNumber: lineNumber,
1067                 lineStart: lineStart,
1068                 range: [index, index]
1069             };
1070         }
1071
1072         token = scanPunctuator();
1073         if (typeof token !== 'undefined') {
1074             return token;
1075         }
1076
1077         ch = source[index];
1078
1079         if (ch === '\'' || ch === '"') {
1080             return scanStringLiteral();
1081         }
1082
1083         if (ch === '.' || isDecimalDigit(ch)) {
1084             return scanNumericLiteral();
1085         }
1086
1087         token = scanIdentifier();
1088         if (typeof token !== 'undefined') {
1089             return token;
1090         }
1091
1092         throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
1093     }
1094
1095     function lex() {
1096         var token;
1097
1098         if (buffer) {
1099             index = buffer.range[1];
1100             lineNumber = buffer.lineNumber;
1101             lineStart = buffer.lineStart;
1102             token = buffer;
1103             buffer = null;
1104             return token;
1105         }
1106
1107         buffer = null;
1108         return advance();
1109     }
1110
1111     function lookahead() {
1112         var pos, line, start;
1113
1114         if (buffer !== null) {
1115             return buffer;
1116         }
1117
1118         pos = index;
1119         line = lineNumber;
1120         start = lineStart;
1121         buffer = advance();
1122         index = pos;
1123         lineNumber = line;
1124         lineStart = start;
1125
1126         return buffer;
1127     }
1128
1129     // Return true if there is a line terminator before the next token.
1130
1131     function peekLineTerminator() {
1132         var pos, line, start, found;
1133
1134         pos = index;
1135         line = lineNumber;
1136         start = lineStart;
1137         skipComment();
1138         found = lineNumber !== line;
1139         index = pos;
1140         lineNumber = line;
1141         lineStart = start;
1142
1143         return found;
1144     }
1145
1146     // Throw an exception
1147
1148     function throwError(token, messageFormat) {
1149         var error,
1150             args = Array.prototype.slice.call(arguments, 2),
1151             msg = messageFormat.replace(
1152                 /%(\d)/g,
1153                 function (whole, index) {
1154                     return args[index] || '';
1155                 }
1156             );
1157
1158         if (typeof token.lineNumber === 'number') {
1159             error = new Error('Line ' + token.lineNumber + ': ' + msg);
1160             error.index = token.range[0];
1161             error.lineNumber = token.lineNumber;
1162             error.column = token.range[0] - lineStart + 1;
1163         } else {
1164             error = new Error('Line ' + lineNumber + ': ' + msg);
1165             error.index = index;
1166             error.lineNumber = lineNumber;
1167             error.column = index - lineStart + 1;
1168         }
1169
1170         throw error;
1171     }
1172
1173     function throwErrorTolerant() {
1174         try {
1175             throwError.apply(null, arguments);
1176         } catch (e) {
1177             if (extra.errors) {
1178                 extra.errors.push(e);
1179             } else {
1180                 throw e;
1181             }
1182         }
1183     }
1184
1185
1186     // Throw an exception because of the token.
1187
1188     function throwUnexpected(token) {
1189         if (token.type === Token.EOF) {
1190             throwError(token, Messages.UnexpectedEOS);
1191         }
1192
1193         if (token.type === Token.NumericLiteral) {
1194             throwError(token, Messages.UnexpectedNumber);
1195         }
1196
1197         if (token.type === Token.StringLiteral) {
1198             throwError(token, Messages.UnexpectedString);
1199         }
1200
1201         if (token.type === Token.Identifier) {
1202             throwError(token, Messages.UnexpectedIdentifier);
1203         }
1204
1205         if (token.type === Token.Keyword) {
1206             if (isFutureReservedWord(token.value)) {
1207                 throwError(token, Messages.UnexpectedReserved);
1208             } else if (strict && isStrictModeReservedWord(token.value)) {
1209                 throwErrorTolerant(token, Messages.StrictReservedWord);
1210                 return;
1211             }
1212             throwError(token, Messages.UnexpectedToken, token.value);
1213         }
1214
1215         // BooleanLiteral, NullLiteral, or Punctuator.
1216         throwError(token, Messages.UnexpectedToken, token.value);
1217     }
1218
1219     // Expect the next token to match the specified punctuator.
1220     // If not, an exception will be thrown.
1221
1222     function expect(value) {
1223         var token = lex();
1224         if (token.type !== Token.Punctuator || token.value !== value) {
1225             throwUnexpected(token);
1226         }
1227     }
1228
1229     // Expect the next token to match the specified keyword.
1230     // If not, an exception will be thrown.
1231
1232     function expectKeyword(keyword) {
1233         var token = lex();
1234         if (token.type !== Token.Keyword || token.value !== keyword) {
1235             throwUnexpected(token);
1236         }
1237     }
1238
1239     // Return true if the next token matches the specified punctuator.
1240
1241     function match(value) {
1242         var token = lookahead();
1243         return token.type === Token.Punctuator && token.value === value;
1244     }
1245
1246     // Return true if the next token matches the specified keyword
1247
1248     function matchKeyword(keyword) {
1249         var token = lookahead();
1250         return token.type === Token.Keyword && token.value === keyword;
1251     }
1252
1253     // Return true if the next token is an assignment operator
1254
1255     function matchAssign() {
1256         var token = lookahead(),
1257             op = token.value;
1258
1259         if (token.type !== Token.Punctuator) {
1260             return false;
1261         }
1262         return op === '=' ||
1263             op === '*=' ||
1264             op === '/=' ||
1265             op === '%=' ||
1266             op === '+=' ||
1267             op === '-=' ||
1268             op === '<<=' ||
1269             op === '>>=' ||
1270             op === '>>>=' ||
1271             op === '&=' ||
1272             op === '^=' ||
1273             op === '|=';
1274     }
1275
1276     function consumeSemicolon() {
1277         var token, line;
1278
1279         // Catch the very common case first.
1280         if (source[index] === ';') {
1281             lex();
1282             return;
1283         }
1284
1285         line = lineNumber;
1286         skipComment();
1287         if (lineNumber !== line) {
1288             return;
1289         }
1290
1291         if (match(';')) {
1292             lex();
1293             return;
1294         }
1295
1296         token = lookahead();
1297         if (token.type !== Token.EOF && !match('}')) {
1298             throwUnexpected(token);
1299         }
1300     }
1301
1302     // Return true if provided expression is LeftHandSideExpression
1303
1304     function isLeftHandSide(expr) {
1305         return expr.type === Syntax.Identifier || expr.type === Syntax.MemberExpression;
1306     }
1307
1308     // 11.1.4 Array Initialiser
1309
1310     function parseArrayInitialiser() {
1311         var elements = [];
1312
1313         expect('[');
1314
1315         while (!match(']')) {
1316             if (match(',')) {
1317                 lex();
1318                 elements.push(null);
1319             } else {
1320                 elements.push(parseAssignmentExpression());
1321
1322                 if (!match(']')) {
1323                     expect(',');
1324                 }
1325             }
1326         }
1327
1328         expect(']');
1329
1330         return {
1331             type: Syntax.ArrayExpression,
1332             elements: elements
1333         };
1334     }
1335
1336     // 11.1.5 Object Initialiser
1337
1338     function parsePropertyFunction(param, first) {
1339         var previousStrict, body;
1340
1341         previousStrict = strict;
1342         body = parseFunctionSourceElements();
1343         if (first && strict && isRestrictedWord(param[0].name)) {
1344             throwErrorTolerant(first, Messages.StrictParamName);
1345         }
1346         strict = previousStrict;
1347
1348         return {
1349             type: Syntax.FunctionExpression,
1350             id: null,
1351             params: param,
1352             defaults: [],
1353             body: body,
1354             rest: null,
1355             generator: false,
1356             expression: false
1357         };
1358     }
1359
1360     function parseObjectPropertyKey() {
1361         var token = lex();
1362
1363         // Note: This function is called only from parseObjectProperty(), where
1364         // EOF and Punctuator tokens are already filtered out.
1365
1366         if (token.type === Token.StringLiteral || token.type === Token.NumericLiteral) {
1367             if (strict && token.octal) {
1368                 throwErrorTolerant(token, Messages.StrictOctalLiteral);
1369             }
1370             return createLiteral(token);
1371         }
1372
1373         return {
1374             type: Syntax.Identifier,
1375             name: token.value
1376         };
1377     }
1378
1379     function parseObjectProperty() {
1380         var token, key, id, param;
1381
1382         token = lookahead();
1383
1384         if (token.type === Token.Identifier) {
1385
1386             id = parseObjectPropertyKey();
1387
1388             // Property Assignment: Getter and Setter.
1389
1390             if (token.value === 'get' && !match(':')) {
1391                 key = parseObjectPropertyKey();
1392                 expect('(');
1393                 expect(')');
1394                 return {
1395                     type: Syntax.Property,
1396                     key: key,
1397                     value: parsePropertyFunction([]),
1398                     kind: 'get'
1399                 };
1400             } else if (token.value === 'set' && !match(':')) {
1401                 key = parseObjectPropertyKey();
1402                 expect('(');
1403                 token = lookahead();
1404                 if (token.type !== Token.Identifier) {
1405                     throwUnexpected(lex());
1406                 }
1407                 param = [ parseVariableIdentifier() ];
1408                 expect(')');
1409                 return {
1410                     type: Syntax.Property,
1411                     key: key,
1412                     value: parsePropertyFunction(param, token),
1413                     kind: 'set'
1414                 };
1415             } else {
1416                 expect(':');
1417                 return {
1418                     type: Syntax.Property,
1419                     key: id,
1420                     value: parseAssignmentExpression(),
1421                     kind: 'init'
1422                 };
1423             }
1424         } else if (token.type === Token.EOF || token.type === Token.Punctuator) {
1425             throwUnexpected(token);
1426         } else {
1427             key = parseObjectPropertyKey();
1428             expect(':');
1429             return {
1430                 type: Syntax.Property,
1431                 key: key,
1432                 value: parseAssignmentExpression(),
1433                 kind: 'init'
1434             };
1435         }
1436     }
1437
1438     function parseObjectInitialiser() {
1439         var properties = [], property, name, kind, map = {}, toString = String;
1440
1441         expect('{');
1442
1443         while (!match('}')) {
1444             property = parseObjectProperty();
1445
1446             if (property.key.type === Syntax.Identifier) {
1447                 name = property.key.name;
1448             } else {
1449                 name = toString(property.key.value);
1450             }
1451             kind = (property.kind === 'init') ? PropertyKind.Data : (property.kind === 'get') ? PropertyKind.Get : PropertyKind.Set;
1452             if (Object.prototype.hasOwnProperty.call(map, name)) {
1453                 if (map[name] === PropertyKind.Data) {
1454                     if (strict && kind === PropertyKind.Data) {
1455                         throwErrorTolerant({}, Messages.StrictDuplicateProperty);
1456                     } else if (kind !== PropertyKind.Data) {
1457                         throwErrorTolerant({}, Messages.AccessorDataProperty);
1458                     }
1459                 } else {
1460                     if (kind === PropertyKind.Data) {
1461                         throwErrorTolerant({}, Messages.AccessorDataProperty);
1462                     } else if (map[name] & kind) {
1463                         throwErrorTolerant({}, Messages.AccessorGetSet);
1464                     }
1465                 }
1466                 map[name] |= kind;
1467             } else {
1468                 map[name] = kind;
1469             }
1470
1471             properties.push(property);
1472
1473             if (!match('}')) {
1474                 expect(',');
1475             }
1476         }
1477
1478         expect('}');
1479
1480         return {
1481             type: Syntax.ObjectExpression,
1482             properties: properties
1483         };
1484     }
1485
1486     // 11.1.6 The Grouping Operator
1487
1488     function parseGroupExpression() {
1489         var expr;
1490
1491         expect('(');
1492
1493         expr = parseExpression();
1494
1495         expect(')');
1496
1497         return expr;
1498     }
1499
1500
1501     // 11.1 Primary Expressions
1502
1503     function parsePrimaryExpression() {
1504         var token = lookahead(),
1505             type = token.type;
1506
1507         if (type === Token.Identifier) {
1508             return {
1509                 type: Syntax.Identifier,
1510                 name: lex().value
1511             };
1512         }
1513
1514         if (type === Token.StringLiteral || type === Token.NumericLiteral) {
1515             if (strict && token.octal) {
1516                 throwErrorTolerant(token, Messages.StrictOctalLiteral);
1517             }
1518             return createLiteral(lex());
1519         }
1520
1521         if (type === Token.Keyword) {
1522             if (matchKeyword('this')) {
1523                 lex();
1524                 return {
1525                     type: Syntax.ThisExpression
1526                 };
1527             }
1528
1529             if (matchKeyword('function')) {
1530                 return parseFunctionExpression();
1531             }
1532         }
1533
1534         if (type === Token.BooleanLiteral) {
1535             lex();
1536             token.value = (token.value === 'true');
1537             return createLiteral(token);
1538         }
1539
1540         if (type === Token.NullLiteral) {
1541             lex();
1542             token.value = null;
1543             return createLiteral(token);
1544         }
1545
1546         if (match('[')) {
1547             return parseArrayInitialiser();
1548         }
1549
1550         if (match('{')) {
1551             return parseObjectInitialiser();
1552         }
1553
1554         if (match('(')) {
1555             return parseGroupExpression();
1556         }
1557
1558         if (match('/') || match('/=')) {
1559             return createLiteral(scanRegExp());
1560         }
1561
1562         return throwUnexpected(lex());
1563     }
1564
1565     // 11.2 Left-Hand-Side Expressions
1566
1567     function parseArguments() {
1568         var args = [];
1569
1570         expect('(');
1571
1572         if (!match(')')) {
1573             while (index < length) {
1574                 args.push(parseAssignmentExpression());
1575                 if (match(')')) {
1576                     break;
1577                 }
1578                 expect(',');
1579             }
1580         }
1581
1582         expect(')');
1583
1584         return args;
1585     }
1586
1587     function parseNonComputedProperty() {
1588         var token = lex();
1589
1590         if (!isIdentifierName(token)) {
1591             throwUnexpected(token);
1592         }
1593
1594         return {
1595             type: Syntax.Identifier,
1596             name: token.value
1597         };
1598     }
1599
1600     function parseNonComputedMember() {
1601         expect('.');
1602
1603         return parseNonComputedProperty();
1604     }
1605
1606     function parseComputedMember() {
1607         var expr;
1608
1609         expect('[');
1610
1611         expr = parseExpression();
1612
1613         expect(']');
1614
1615         return expr;
1616     }
1617
1618     function parseNewExpression() {
1619         var expr;
1620
1621         expectKeyword('new');
1622
1623         expr = {
1624             type: Syntax.NewExpression,
1625             callee: parseLeftHandSideExpression(),
1626             'arguments': []
1627         };
1628
1629         if (match('(')) {
1630             expr['arguments'] = parseArguments();
1631         }
1632
1633         return expr;
1634     }
1635
1636     function parseLeftHandSideExpressionAllowCall() {
1637         var expr;
1638
1639         expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();
1640
1641         while (match('.') || match('[') || match('(')) {
1642             if (match('(')) {
1643                 expr = {
1644                     type: Syntax.CallExpression,
1645                     callee: expr,
1646                     'arguments': parseArguments()
1647                 };
1648             } else if (match('[')) {
1649                 expr = {
1650                     type: Syntax.MemberExpression,
1651                     computed: true,
1652                     object: expr,
1653                     property: parseComputedMember()
1654                 };
1655             } else {
1656                 expr = {
1657                     type: Syntax.MemberExpression,
1658                     computed: false,
1659                     object: expr,
1660                     property: parseNonComputedMember()
1661                 };
1662             }
1663         }
1664
1665         return expr;
1666     }
1667
1668
1669     function parseLeftHandSideExpression() {
1670         var expr;
1671
1672         expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();
1673
1674         while (match('.') || match('[')) {
1675             if (match('[')) {
1676                 expr = {
1677                     type: Syntax.MemberExpression,
1678                     computed: true,
1679                     object: expr,
1680                     property: parseComputedMember()
1681                 };
1682             } else {
1683                 expr = {
1684                     type: Syntax.MemberExpression,
1685                     computed: false,
1686                     object: expr,
1687                     property: parseNonComputedMember()
1688                 };
1689             }
1690         }
1691
1692         return expr;
1693     }
1694
1695     // 11.3 Postfix Expressions
1696
1697     function parsePostfixExpression() {
1698         var expr = parseLeftHandSideExpressionAllowCall(), token;
1699
1700         token = lookahead();
1701         if (token.type !== Token.Punctuator) {
1702             return expr;
1703         }
1704
1705         if ((match('++') || match('--')) && !peekLineTerminator()) {
1706             // 11.3.1, 11.3.2
1707             if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {
1708                 throwErrorTolerant({}, Messages.StrictLHSPostfix);
1709             }
1710
1711             if (!isLeftHandSide(expr)) {
1712                 throwError({}, Messages.InvalidLHSInAssignment);
1713             }
1714
1715             expr = {
1716                 type: Syntax.UpdateExpression,
1717                 operator: lex().value,
1718                 argument: expr,
1719                 prefix: false
1720             };
1721         }
1722
1723         return expr;
1724     }
1725
1726     // 11.4 Unary Operators
1727
1728     function parseUnaryExpression() {
1729         var token, expr;
1730
1731         token = lookahead();
1732         if (token.type !== Token.Punctuator && token.type !== Token.Keyword) {
1733             return parsePostfixExpression();
1734         }
1735
1736         if (match('++') || match('--')) {
1737             token = lex();
1738             expr = parseUnaryExpression();
1739             // 11.4.4, 11.4.5
1740             if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {
1741                 throwErrorTolerant({}, Messages.StrictLHSPrefix);
1742             }
1743
1744             if (!isLeftHandSide(expr)) {
1745                 throwError({}, Messages.InvalidLHSInAssignment);
1746             }
1747
1748             expr = {
1749                 type: Syntax.UpdateExpression,
1750                 operator: token.value,
1751                 argument: expr,
1752                 prefix: true
1753             };
1754             return expr;
1755         }
1756
1757         if (match('+') || match('-') || match('~') || match('!')) {
1758             expr = {
1759                 type: Syntax.UnaryExpression,
1760                 operator: lex().value,
1761                 argument: parseUnaryExpression()
1762             };
1763             return expr;
1764         }
1765
1766         if (matchKeyword('delete') || matchKeyword('void') || matchKeyword('typeof')) {
1767             expr = {
1768                 type: Syntax.UnaryExpression,
1769                 operator: lex().value,
1770                 argument: parseUnaryExpression()
1771             };
1772             if (strict && expr.operator === 'delete' && expr.argument.type === Syntax.Identifier) {
1773                 throwErrorTolerant({}, Messages.StrictDelete);
1774             }
1775             return expr;
1776         }
1777
1778         return parsePostfixExpression();
1779     }
1780
1781     // 11.5 Multiplicative Operators
1782
1783     function parseMultiplicativeExpression() {
1784         var expr = parseUnaryExpression();
1785
1786         while (match('*') || match('/') || match('%')) {
1787             expr = {
1788                 type: Syntax.BinaryExpression,
1789                 operator: lex().value,
1790                 left: expr,
1791                 right: parseUnaryExpression()
1792             };
1793         }
1794
1795         return expr;
1796     }
1797
1798     // 11.6 Additive Operators
1799
1800     function parseAdditiveExpression() {
1801         var expr = parseMultiplicativeExpression();
1802
1803         while (match('+') || match('-')) {
1804             expr = {
1805                 type: Syntax.BinaryExpression,
1806                 operator: lex().value,
1807                 left: expr,
1808                 right: parseMultiplicativeExpression()
1809             };
1810         }
1811
1812         return expr;
1813     }
1814
1815     // 11.7 Bitwise Shift Operators
1816
1817     function parseShiftExpression() {
1818         var expr = parseAdditiveExpression();
1819
1820         while (match('<<') || match('>>') || match('>>>')) {
1821             expr = {
1822                 type: Syntax.BinaryExpression,
1823                 operator: lex().value,
1824                 left: expr,
1825                 right: parseAdditiveExpression()
1826             };
1827         }
1828
1829         return expr;
1830     }
1831     // 11.8 Relational Operators
1832
1833     function parseRelationalExpression() {
1834         var expr, previousAllowIn;
1835
1836         previousAllowIn = state.allowIn;
1837         state.allowIn = true;
1838
1839         expr = parseShiftExpression();
1840
1841         while (match('<') || match('>') || match('<=') || match('>=') || (previousAllowIn && matchKeyword('in')) || matchKeyword('instanceof')) {
1842             expr = {
1843                 type: Syntax.BinaryExpression,
1844                 operator: lex().value,
1845                 left: expr,
1846                 right: parseShiftExpression()
1847             };
1848         }
1849
1850         state.allowIn = previousAllowIn;
1851         return expr;
1852     }
1853
1854     // 11.9 Equality Operators
1855
1856     function parseEqualityExpression() {
1857         var expr = parseRelationalExpression();
1858
1859         while (match('==') || match('!=') || match('===') || match('!==')) {
1860             expr = {
1861                 type: Syntax.BinaryExpression,
1862                 operator: lex().value,
1863                 left: expr,
1864                 right: parseRelationalExpression()
1865             };
1866         }
1867
1868         return expr;
1869     }
1870
1871     // 11.10 Binary Bitwise Operators
1872
1873     function parseBitwiseANDExpression() {
1874         var expr = parseEqualityExpression();
1875
1876         while (match('&')) {
1877             lex();
1878             expr = {
1879                 type: Syntax.BinaryExpression,
1880                 operator: '&',
1881                 left: expr,
1882                 right: parseEqualityExpression()
1883             };
1884         }
1885
1886         return expr;
1887     }
1888
1889     function parseBitwiseXORExpression() {
1890         var expr = parseBitwiseANDExpression();
1891
1892         while (match('^')) {
1893             lex();
1894             expr = {
1895                 type: Syntax.BinaryExpression,
1896                 operator: '^',
1897                 left: expr,
1898                 right: parseBitwiseANDExpression()
1899             };
1900         }
1901
1902         return expr;
1903     }
1904
1905     function parseBitwiseORExpression() {
1906         var expr = parseBitwiseXORExpression();
1907
1908         while (match('|')) {
1909             lex();
1910             expr = {
1911                 type: Syntax.BinaryExpression,
1912                 operator: '|',
1913                 left: expr,
1914                 right: parseBitwiseXORExpression()
1915             };
1916         }
1917
1918         return expr;
1919     }
1920
1921     // 11.11 Binary Logical Operators
1922
1923     function parseLogicalANDExpression() {
1924         var expr = parseBitwiseORExpression();
1925
1926         while (match('&&')) {
1927             lex();
1928             expr = {
1929                 type: Syntax.LogicalExpression,
1930                 operator: '&&',
1931                 left: expr,
1932                 right: parseBitwiseORExpression()
1933             };
1934         }
1935
1936         return expr;
1937     }
1938
1939     function parseLogicalORExpression() {
1940         var expr = parseLogicalANDExpression();
1941
1942         while (match('||')) {
1943             lex();
1944             expr = {
1945                 type: Syntax.LogicalExpression,
1946                 operator: '||',
1947                 left: expr,
1948                 right: parseLogicalANDExpression()
1949             };
1950         }
1951
1952         return expr;
1953     }
1954
1955     // 11.12 Conditional Operator
1956
1957     function parseConditionalExpression() {
1958         var expr, previousAllowIn, consequent;
1959
1960         expr = parseLogicalORExpression();
1961
1962         if (match('?')) {
1963             lex();
1964             previousAllowIn = state.allowIn;
1965             state.allowIn = true;
1966             consequent = parseAssignmentExpression();
1967             state.allowIn = previousAllowIn;
1968             expect(':');
1969
1970             expr = {
1971                 type: Syntax.ConditionalExpression,
1972                 test: expr,
1973                 consequent: consequent,
1974                 alternate: parseAssignmentExpression()
1975             };
1976         }
1977
1978         return expr;
1979     }
1980
1981     // 11.13 Assignment Operators
1982
1983     function parseAssignmentExpression() {
1984         var token, expr;
1985
1986         token = lookahead();
1987         expr = parseConditionalExpression();
1988
1989         if (matchAssign()) {
1990             // LeftHandSideExpression
1991             if (!isLeftHandSide(expr)) {
1992                 throwError({}, Messages.InvalidLHSInAssignment);
1993             }
1994
1995             // 11.13.1
1996             if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {
1997                 throwErrorTolerant(token, Messages.StrictLHSAssignment);
1998             }
1999
2000             expr = {
2001                 type: Syntax.AssignmentExpression,
2002                 operator: lex().value,
2003                 left: expr,
2004                 right: parseAssignmentExpression()
2005             };
2006         }
2007
2008         return expr;
2009     }
2010
2011     // 11.14 Comma Operator
2012
2013     function parseExpression() {
2014         var expr = parseAssignmentExpression();
2015
2016         if (match(',')) {
2017             expr = {
2018                 type: Syntax.SequenceExpression,
2019                 expressions: [ expr ]
2020             };
2021
2022             while (index < length) {
2023                 if (!match(',')) {
2024                     break;
2025                 }
2026                 lex();
2027                 expr.expressions.push(parseAssignmentExpression());
2028             }
2029
2030         }
2031         return expr;
2032     }
2033
2034     // 12.1 Block
2035
2036     function parseStatementList() {
2037         var list = [],
2038             statement;
2039
2040         while (index < length) {
2041             if (match('}')) {
2042                 break;
2043             }
2044             statement = parseSourceElement();
2045             if (typeof statement === 'undefined') {
2046                 break;
2047             }
2048             list.push(statement);
2049         }
2050
2051         return list;
2052     }
2053
2054     function parseBlock() {
2055         var block;
2056
2057         expect('{');
2058
2059         block = parseStatementList();
2060
2061         expect('}');
2062
2063         return {
2064             type: Syntax.BlockStatement,
2065             body: block
2066         };
2067     }
2068
2069     // 12.2 Variable Statement
2070
2071     function parseVariableIdentifier() {
2072         var token = lex();
2073
2074         if (token.type !== Token.Identifier) {
2075             throwUnexpected(token);
2076         }
2077
2078         return {
2079             type: Syntax.Identifier,
2080             name: token.value
2081         };
2082     }
2083
2084     function parseVariableDeclaration(kind) {
2085         var id = parseVariableIdentifier(),
2086             init = null;
2087
2088         // 12.2.1
2089         if (strict && isRestrictedWord(id.name)) {
2090             throwErrorTolerant({}, Messages.StrictVarName);
2091         }
2092
2093         if (kind === 'const') {
2094             expect('=');
2095             init = parseAssignmentExpression();
2096         } else if (match('=')) {
2097             lex();
2098             init = parseAssignmentExpression();
2099         }
2100
2101         return {
2102             type: Syntax.VariableDeclarator,
2103             id: id,
2104             init: init
2105         };
2106     }
2107
2108     function parseVariableDeclarationList(kind) {
2109         var list = [];
2110
2111         while (index < length) {
2112             list.push(parseVariableDeclaration(kind));
2113             if (!match(',')) {
2114                 break;
2115             }
2116             lex();
2117         }
2118
2119         return list;
2120     }
2121
2122     function parseVariableStatement() {
2123         var declarations;
2124
2125         expectKeyword('var');
2126
2127         declarations = parseVariableDeclarationList();
2128
2129         consumeSemicolon();
2130
2131         return {
2132             type: Syntax.VariableDeclaration,
2133             declarations: declarations,
2134             kind: 'var'
2135         };
2136     }
2137
2138     // kind may be `const` or `let`
2139     // Both are experimental and not in the specification yet.
2140     // see http://wiki.ecmascript.org/doku.php?id=harmony:const
2141     // and http://wiki.ecmascript.org/doku.php?id=harmony:let
2142     function parseConstLetDeclaration(kind) {
2143         var declarations;
2144
2145         expectKeyword(kind);
2146
2147         declarations = parseVariableDeclarationList(kind);
2148
2149         consumeSemicolon();
2150
2151         return {
2152             type: Syntax.VariableDeclaration,
2153             declarations: declarations,
2154             kind: kind
2155         };
2156     }
2157
2158     // 12.3 Empty Statement
2159
2160     function parseEmptyStatement() {
2161         expect(';');
2162
2163         return {
2164             type: Syntax.EmptyStatement
2165         };
2166     }
2167
2168     // 12.4 Expression Statement
2169
2170     function parseExpressionStatement() {
2171         var expr = parseExpression();
2172
2173         consumeSemicolon();
2174
2175         return {
2176             type: Syntax.ExpressionStatement,
2177             expression: expr
2178         };
2179     }
2180
2181     // 12.5 If statement
2182
2183     function parseIfStatement() {
2184         var test, consequent, alternate;
2185
2186         expectKeyword('if');
2187
2188         expect('(');
2189
2190         test = parseExpression();
2191
2192         expect(')');
2193
2194         consequent = parseStatement();
2195
2196         if (matchKeyword('else')) {
2197             lex();
2198             alternate = parseStatement();
2199         } else {
2200             alternate = null;
2201         }
2202
2203         return {
2204             type: Syntax.IfStatement,
2205             test: test,
2206             consequent: consequent,
2207             alternate: alternate
2208         };
2209     }
2210
2211     // 12.6 Iteration Statements
2212
2213     function parseDoWhileStatement() {
2214         var body, test, oldInIteration;
2215
2216         expectKeyword('do');
2217
2218         oldInIteration = state.inIteration;
2219         state.inIteration = true;
2220
2221         body = parseStatement();
2222
2223         state.inIteration = oldInIteration;
2224
2225         expectKeyword('while');
2226
2227         expect('(');
2228
2229         test = parseExpression();
2230
2231         expect(')');
2232
2233         if (match(';')) {
2234             lex();
2235         }
2236
2237         return {
2238             type: Syntax.DoWhileStatement,
2239             body: body,
2240             test: test
2241         };
2242     }
2243
2244     function parseWhileStatement() {
2245         var test, body, oldInIteration;
2246
2247         expectKeyword('while');
2248
2249         expect('(');
2250
2251         test = parseExpression();
2252
2253         expect(')');
2254
2255         oldInIteration = state.inIteration;
2256         state.inIteration = true;
2257
2258         body = parseStatement();
2259
2260         state.inIteration = oldInIteration;
2261
2262         return {
2263             type: Syntax.WhileStatement,
2264             test: test,
2265             body: body
2266         };
2267     }
2268
2269     function parseForVariableDeclaration() {
2270         var token = lex();
2271
2272         return {
2273             type: Syntax.VariableDeclaration,
2274             declarations: parseVariableDeclarationList(),
2275             kind: token.value
2276         };
2277     }
2278
2279     function parseForStatement() {
2280         var init, test, update, left, right, body, oldInIteration;
2281
2282         init = test = update = null;
2283
2284         expectKeyword('for');
2285
2286         expect('(');
2287
2288         if (match(';')) {
2289             lex();
2290         } else {
2291             if (matchKeyword('var') || matchKeyword('let')) {
2292                 state.allowIn = false;
2293                 init = parseForVariableDeclaration();
2294                 state.allowIn = true;
2295
2296                 if (init.declarations.length === 1 && matchKeyword('in')) {
2297                     lex();
2298                     left = init;
2299                     right = parseExpression();
2300                     init = null;
2301                 }
2302             } else {
2303                 state.allowIn = false;
2304                 init = parseExpression();
2305                 state.allowIn = true;
2306
2307                 if (matchKeyword('in')) {
2308                     // LeftHandSideExpression
2309                     if (!isLeftHandSide(init)) {
2310                         throwError({}, Messages.InvalidLHSInForIn);
2311                     }
2312
2313                     lex();
2314                     left = init;
2315                     right = parseExpression();
2316                     init = null;
2317                 }
2318             }
2319
2320             if (typeof left === 'undefined') {
2321                 expect(';');
2322             }
2323         }
2324
2325         if (typeof left === 'undefined') {
2326
2327             if (!match(';')) {
2328                 test = parseExpression();
2329             }
2330             expect(';');
2331
2332             if (!match(')')) {
2333                 update = parseExpression();
2334             }
2335         }
2336
2337         expect(')');
2338
2339         oldInIteration = state.inIteration;
2340         state.inIteration = true;
2341
2342         body = parseStatement();
2343
2344         state.inIteration = oldInIteration;
2345
2346         if (typeof left === 'undefined') {
2347             return {
2348                 type: Syntax.ForStatement,
2349                 init: init,
2350                 test: test,
2351                 update: update,
2352                 body: body
2353             };
2354         }
2355
2356         return {
2357             type: Syntax.ForInStatement,
2358             left: left,
2359             right: right,
2360             body: body,
2361             each: false
2362         };
2363     }
2364
2365     // 12.7 The continue statement
2366
2367     function parseContinueStatement() {
2368         var token, label = null;
2369
2370         expectKeyword('continue');
2371
2372         // Optimize the most common form: 'continue;'.
2373         if (source[index] === ';') {
2374             lex();
2375
2376             if (!state.inIteration) {
2377                 throwError({}, Messages.IllegalContinue);
2378             }
2379
2380             return {
2381                 type: Syntax.ContinueStatement,
2382                 label: null
2383             };
2384         }
2385
2386         if (peekLineTerminator()) {
2387             if (!state.inIteration) {
2388                 throwError({}, Messages.IllegalContinue);
2389             }
2390
2391             return {
2392                 type: Syntax.ContinueStatement,
2393                 label: null
2394             };
2395         }
2396
2397         token = lookahead();
2398         if (token.type === Token.Identifier) {
2399             label = parseVariableIdentifier();
2400
2401             if (!Object.prototype.hasOwnProperty.call(state.labelSet, label.name)) {
2402                 throwError({}, Messages.UnknownLabel, label.name);
2403             }
2404         }
2405
2406         consumeSemicolon();
2407
2408         if (label === null && !state.inIteration) {
2409             throwError({}, Messages.IllegalContinue);
2410         }
2411
2412         return {
2413             type: Syntax.ContinueStatement,
2414             label: label
2415         };
2416     }
2417
2418     // 12.8 The break statement
2419
2420     function parseBreakStatement() {
2421         var token, label = null;
2422
2423         expectKeyword('break');
2424
2425         // Optimize the most common form: 'break;'.
2426         if (source[index] === ';') {
2427             lex();
2428
2429             if (!(state.inIteration || state.inSwitch)) {
2430                 throwError({}, Messages.IllegalBreak);
2431             }
2432
2433             return {
2434                 type: Syntax.BreakStatement,
2435                 label: null
2436             };
2437         }
2438
2439         if (peekLineTerminator()) {
2440             if (!(state.inIteration || state.inSwitch)) {
2441                 throwError({}, Messages.IllegalBreak);
2442             }
2443
2444             return {
2445                 type: Syntax.BreakStatement,
2446                 label: null
2447             };
2448         }
2449
2450         token = lookahead();
2451         if (token.type === Token.Identifier) {
2452             label = parseVariableIdentifier();
2453
2454             if (!Object.prototype.hasOwnProperty.call(state.labelSet, label.name)) {
2455                 throwError({}, Messages.UnknownLabel, label.name);
2456             }
2457         }
2458
2459         consumeSemicolon();
2460
2461         if (label === null && !(state.inIteration || state.inSwitch)) {
2462             throwError({}, Messages.IllegalBreak);
2463         }
2464
2465         return {
2466             type: Syntax.BreakStatement,
2467             label: label
2468         };
2469     }
2470
2471     // 12.9 The return statement
2472
2473     function parseReturnStatement() {
2474         var token, argument = null;
2475
2476         expectKeyword('return');
2477
2478         if (!state.inFunctionBody) {
2479             throwErrorTolerant({}, Messages.IllegalReturn);
2480         }
2481
2482         // 'return' followed by a space and an identifier is very common.
2483         if (source[index] === ' ') {
2484             if (isIdentifierStart(source[index + 1])) {
2485                 argument = parseExpression();
2486                 consumeSemicolon();
2487                 return {
2488                     type: Syntax.ReturnStatement,
2489                     argument: argument
2490                 };
2491             }
2492         }
2493
2494         if (peekLineTerminator()) {
2495             return {
2496                 type: Syntax.ReturnStatement,
2497                 argument: null
2498             };
2499         }
2500
2501         if (!match(';')) {
2502             token = lookahead();
2503             if (!match('}') && token.type !== Token.EOF) {
2504                 argument = parseExpression();
2505             }
2506         }
2507
2508         consumeSemicolon();
2509
2510         return {
2511             type: Syntax.ReturnStatement,
2512             argument: argument
2513         };
2514     }
2515
2516     // 12.10 The with statement
2517
2518     function parseWithStatement() {
2519         var object, body;
2520
2521         if (strict) {
2522             throwErrorTolerant({}, Messages.StrictModeWith);
2523         }
2524
2525         expectKeyword('with');
2526
2527         expect('(');
2528
2529         object = parseExpression();
2530
2531         expect(')');
2532
2533         body = parseStatement();
2534
2535         return {
2536             type: Syntax.WithStatement,
2537             object: object,
2538             body: body
2539         };
2540     }
2541
2542     // 12.10 The swith statement
2543
2544     function parseSwitchCase() {
2545         var test,
2546             consequent = [],
2547             statement;
2548
2549         if (matchKeyword('default')) {
2550             lex();
2551             test = null;
2552         } else {
2553             expectKeyword('case');
2554             test = parseExpression();
2555         }
2556         expect(':');
2557
2558         while (index < length) {
2559             if (match('}') || matchKeyword('default') || matchKeyword('case')) {
2560                 break;
2561             }
2562             statement = parseStatement();
2563             if (typeof statement === 'undefined') {
2564                 break;
2565             }
2566             consequent.push(statement);
2567         }
2568
2569         return {
2570             type: Syntax.SwitchCase,
2571             test: test,
2572             consequent: consequent
2573         };
2574     }
2575
2576     function parseSwitchStatement() {
2577         var discriminant, cases, clause, oldInSwitch, defaultFound;
2578
2579         expectKeyword('switch');
2580
2581         expect('(');
2582
2583         discriminant = parseExpression();
2584
2585         expect(')');
2586
2587         expect('{');
2588
2589         if (match('}')) {
2590             lex();
2591             return {
2592                 type: Syntax.SwitchStatement,
2593                 discriminant: discriminant
2594             };
2595         }
2596
2597         cases = [];
2598
2599         oldInSwitch = state.inSwitch;
2600         state.inSwitch = true;
2601         defaultFound = false;
2602
2603         while (index < length) {
2604             if (match('}')) {
2605                 break;
2606             }
2607             clause = parseSwitchCase();
2608             if (clause.test === null) {
2609                 if (defaultFound) {
2610                     throwError({}, Messages.MultipleDefaultsInSwitch);
2611                 }
2612                 defaultFound = true;
2613             }
2614             cases.push(clause);
2615         }
2616
2617         state.inSwitch = oldInSwitch;
2618
2619         expect('}');
2620
2621         return {
2622             type: Syntax.SwitchStatement,
2623             discriminant: discriminant,
2624             cases: cases
2625         };
2626     }
2627
2628     // 12.13 The throw statement
2629
2630     function parseThrowStatement() {
2631         var argument;
2632
2633         expectKeyword('throw');
2634
2635         if (peekLineTerminator()) {
2636             throwError({}, Messages.NewlineAfterThrow);
2637         }
2638
2639         argument = parseExpression();
2640
2641         consumeSemicolon();
2642
2643         return {
2644             type: Syntax.ThrowStatement,
2645             argument: argument
2646         };
2647     }
2648
2649     // 12.14 The try statement
2650
2651     function parseCatchClause() {
2652         var param;
2653
2654         expectKeyword('catch');
2655
2656         expect('(');
2657         if (!match(')')) {
2658             param = parseExpression();
2659             // 12.14.1
2660             if (strict && param.type === Syntax.Identifier && isRestrictedWord(param.name)) {
2661                 throwErrorTolerant({}, Messages.StrictCatchVariable);
2662             }
2663         }
2664         expect(')');
2665
2666         return {
2667             type: Syntax.CatchClause,
2668             param: param,
2669             body: parseBlock()
2670         };
2671     }
2672
2673     function parseTryStatement() {
2674         var block, handlers = [], finalizer = null;
2675
2676         expectKeyword('try');
2677
2678         block = parseBlock();
2679
2680         if (matchKeyword('catch')) {
2681             handlers.push(parseCatchClause());
2682         }
2683
2684         if (matchKeyword('finally')) {
2685             lex();
2686             finalizer = parseBlock();
2687         }
2688
2689         if (handlers.length === 0 && !finalizer) {
2690             throwError({}, Messages.NoCatchOrFinally);
2691         }
2692
2693         return {
2694             type: Syntax.TryStatement,
2695             block: block,
2696             guardedHandlers: [],
2697             handlers: handlers,
2698             finalizer: finalizer
2699         };
2700     }
2701
2702     // 12.15 The debugger statement
2703
2704     function parseDebuggerStatement() {
2705         expectKeyword('debugger');
2706
2707         consumeSemicolon();
2708
2709         return {
2710             type: Syntax.DebuggerStatement
2711         };
2712     }
2713
2714     // 12 Statements
2715
2716     function parseStatement() {
2717         var token = lookahead(),
2718             expr,
2719             labeledBody;
2720
2721         if (token.type === Token.EOF) {
2722             throwUnexpected(token);
2723         }
2724
2725         if (token.type === Token.Punctuator) {
2726             switch (token.value) {
2727             case ';':
2728                 return parseEmptyStatement();
2729             case '{':
2730                 return parseBlock();
2731             case '(':
2732                 return parseExpressionStatement();
2733             default:
2734                 break;
2735             }
2736         }
2737
2738         if (token.type === Token.Keyword) {
2739             switch (token.value) {
2740             case 'break':
2741                 return parseBreakStatement();
2742             case 'continue':
2743                 return parseContinueStatement();
2744             case 'debugger':
2745                 return parseDebuggerStatement();
2746             case 'do':
2747                 return parseDoWhileStatement();
2748             case 'for':
2749                 return parseForStatement();
2750             case 'function':
2751                 return parseFunctionDeclaration();
2752             case 'if':
2753                 return parseIfStatement();
2754             case 'return':
2755                 return parseReturnStatement();
2756             case 'switch':
2757                 return parseSwitchStatement();
2758             case 'throw':
2759                 return parseThrowStatement();
2760             case 'try':
2761                 return parseTryStatement();
2762             case 'var':
2763                 return parseVariableStatement();
2764             case 'while':
2765                 return parseWhileStatement();
2766             case 'with':
2767                 return parseWithStatement();
2768             default:
2769                 break;
2770             }
2771         }
2772
2773         expr = parseExpression();
2774
2775         // 12.12 Labelled Statements
2776         if ((expr.type === Syntax.Identifier) && match(':')) {
2777             lex();
2778
2779             if (Object.prototype.hasOwnProperty.call(state.labelSet, expr.name)) {
2780                 throwError({}, Messages.Redeclaration, 'Label', expr.name);
2781             }
2782
2783             state.labelSet[expr.name] = true;
2784             labeledBody = parseStatement();
2785             delete state.labelSet[expr.name];
2786
2787             return {
2788                 type: Syntax.LabeledStatement,
2789                 label: expr,
2790                 body: labeledBody
2791             };
2792         }
2793
2794         consumeSemicolon();
2795
2796         return {
2797             type: Syntax.ExpressionStatement,
2798             expression: expr
2799         };
2800     }
2801
2802     // 13 Function Definition
2803
2804     function parseFunctionSourceElements() {
2805         var sourceElement, sourceElements = [], token, directive, firstRestricted,
2806             oldLabelSet, oldInIteration, oldInSwitch, oldInFunctionBody;
2807
2808         expect('{');
2809
2810         while (index < length) {
2811             token = lookahead();
2812             if (token.type !== Token.StringLiteral) {
2813                 break;
2814             }
2815
2816             sourceElement = parseSourceElement();
2817             sourceElements.push(sourceElement);
2818             if (sourceElement.expression.type !== Syntax.Literal) {
2819                 // this is not directive
2820                 break;
2821             }
2822             directive = sliceSource(token.range[0] + 1, token.range[1] - 1);
2823             if (directive === 'use strict') {
2824                 strict = true;
2825                 if (firstRestricted) {
2826                     throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral);
2827                 }
2828             } else {
2829                 if (!firstRestricted && token.octal) {
2830                     firstRestricted = token;
2831                 }
2832             }
2833         }
2834
2835         oldLabelSet = state.labelSet;
2836         oldInIteration = state.inIteration;
2837         oldInSwitch = state.inSwitch;
2838         oldInFunctionBody = state.inFunctionBody;
2839
2840         state.labelSet = {};
2841         state.inIteration = false;
2842         state.inSwitch = false;
2843         state.inFunctionBody = true;
2844
2845         while (index < length) {
2846             if (match('}')) {
2847                 break;
2848             }
2849             sourceElement = parseSourceElement();
2850             if (typeof sourceElement === 'undefined') {
2851                 break;
2852             }
2853             sourceElements.push(sourceElement);
2854         }
2855
2856         expect('}');
2857
2858         state.labelSet = oldLabelSet;
2859         state.inIteration = oldInIteration;
2860         state.inSwitch = oldInSwitch;
2861         state.inFunctionBody = oldInFunctionBody;
2862
2863         return {
2864             type: Syntax.BlockStatement,
2865             body: sourceElements
2866         };
2867     }
2868
2869     function parseFunctionDeclaration() {
2870         var id, param, params = [], body, token, stricted, firstRestricted, message, previousStrict, paramSet;
2871
2872         expectKeyword('function');
2873         token = lookahead();
2874         id = parseVariableIdentifier();
2875         if (strict) {
2876             if (isRestrictedWord(token.value)) {
2877                 throwErrorTolerant(token, Messages.StrictFunctionName);
2878             }
2879         } else {
2880             if (isRestrictedWord(token.value)) {
2881                 firstRestricted = token;
2882                 message = Messages.StrictFunctionName;
2883             } else if (isStrictModeReservedWord(token.value)) {
2884                 firstRestricted = token;
2885                 message = Messages.StrictReservedWord;
2886             }
2887         }
2888
2889         expect('(');
2890
2891         if (!match(')')) {
2892             paramSet = {};
2893             while (index < length) {
2894                 token = lookahead();
2895                 param = parseVariableIdentifier();
2896                 if (strict) {
2897                     if (isRestrictedWord(token.value)) {
2898                         stricted = token;
2899                         message = Messages.StrictParamName;
2900                     }
2901                     if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {
2902                         stricted = token;
2903                         message = Messages.StrictParamDupe;
2904                     }
2905                 } else if (!firstRestricted) {
2906                     if (isRestrictedWord(token.value)) {
2907                         firstRestricted = token;
2908                         message = Messages.StrictParamName;
2909                     } else if (isStrictModeReservedWord(token.value)) {
2910                         firstRestricted = token;
2911                         message = Messages.StrictReservedWord;
2912                     } else if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {
2913                         firstRestricted = token;
2914                         message = Messages.StrictParamDupe;
2915                     }
2916                 }
2917                 params.push(param);
2918                 paramSet[param.name] = true;
2919                 if (match(')')) {
2920                     break;
2921                 }
2922                 expect(',');
2923             }
2924         }
2925
2926         expect(')');
2927
2928         previousStrict = strict;
2929         body = parseFunctionSourceElements();
2930         if (strict && firstRestricted) {
2931             throwError(firstRestricted, message);
2932         }
2933         if (strict && stricted) {
2934             throwErrorTolerant(stricted, message);
2935         }
2936         strict = previousStrict;
2937
2938         return {
2939             type: Syntax.FunctionDeclaration,
2940             id: id,
2941             params: params,
2942             defaults: [],
2943             body: body,
2944             rest: null,
2945             generator: false,
2946             expression: false
2947         };
2948     }
2949
2950     function parseFunctionExpression() {
2951         var token, id = null, stricted, firstRestricted, message, param, params = [], body, previousStrict, paramSet;
2952
2953         expectKeyword('function');
2954
2955         if (!match('(')) {
2956             token = lookahead();
2957             id = parseVariableIdentifier();
2958             if (strict) {
2959                 if (isRestrictedWord(token.value)) {
2960                     throwErrorTolerant(token, Messages.StrictFunctionName);
2961                 }
2962             } else {
2963                 if (isRestrictedWord(token.value)) {
2964                     firstRestricted = token;
2965                     message = Messages.StrictFunctionName;
2966                 } else if (isStrictModeReservedWord(token.value)) {
2967                     firstRestricted = token;
2968                     message = Messages.StrictReservedWord;
2969                 }
2970             }
2971         }
2972
2973         expect('(');
2974
2975         if (!match(')')) {
2976             paramSet = {};
2977             while (index < length) {
2978                 token = lookahead();
2979                 param = parseVariableIdentifier();
2980                 if (strict) {
2981                     if (isRestrictedWord(token.value)) {
2982                         stricted = token;
2983                         message = Messages.StrictParamName;
2984                     }
2985                     if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {
2986                         stricted = token;
2987                         message = Messages.StrictParamDupe;
2988                     }
2989                 } else if (!firstRestricted) {
2990                     if (isRestrictedWord(token.value)) {
2991                         firstRestricted = token;
2992                         message = Messages.StrictParamName;
2993                     } else if (isStrictModeReservedWord(token.value)) {
2994                         firstRestricted = token;
2995                         message = Messages.StrictReservedWord;
2996                     } else if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {
2997                         firstRestricted = token;
2998                         message = Messages.StrictParamDupe;
2999                     }
3000                 }
3001                 params.push(param);
3002                 paramSet[param.name] = true;
3003                 if (match(')')) {
3004                     break;
3005                 }
3006                 expect(',');
3007             }
3008         }
3009
3010         expect(')');
3011
3012         previousStrict = strict;
3013         body = parseFunctionSourceElements();
3014         if (strict && firstRestricted) {
3015             throwError(firstRestricted, message);
3016         }
3017         if (strict && stricted) {
3018             throwErrorTolerant(stricted, message);
3019         }
3020         strict = previousStrict;
3021
3022         return {
3023             type: Syntax.FunctionExpression,
3024             id: id,
3025             params: params,
3026             defaults: [],
3027             body: body,
3028             rest: null,
3029             generator: false,
3030             expression: false
3031         };
3032     }
3033
3034     // 14 Program
3035
3036     function parseSourceElement() {
3037         var token = lookahead();
3038
3039         if (token.type === Token.Keyword) {
3040             switch (token.value) {
3041             case 'const':
3042             case 'let':
3043                 return parseConstLetDeclaration(token.value);
3044             case 'function':
3045                 return parseFunctionDeclaration();
3046             default:
3047                 return parseStatement();
3048             }
3049         }
3050
3051         if (token.type !== Token.EOF) {
3052             return parseStatement();
3053         }
3054     }
3055
3056     function parseSourceElements() {
3057         var sourceElement, sourceElements = [], token, directive, firstRestricted;
3058
3059         while (index < length) {
3060             token = lookahead();
3061             if (token.type !== Token.StringLiteral) {
3062                 break;
3063             }
3064
3065             sourceElement = parseSourceElement();
3066             sourceElements.push(sourceElement);
3067             if (sourceElement.expression.type !== Syntax.Literal) {
3068                 // this is not directive
3069                 break;
3070             }
3071             directive = sliceSource(token.range[0] + 1, token.range[1] - 1);
3072             if (directive === 'use strict') {
3073                 strict = true;
3074                 if (firstRestricted) {
3075                     throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral);
3076                 }
3077             } else {
3078                 if (!firstRestricted && token.octal) {
3079                     firstRestricted = token;
3080                 }
3081             }
3082         }
3083
3084         while (index < length) {
3085             sourceElement = parseSourceElement();
3086             if (typeof sourceElement === 'undefined') {
3087                 break;
3088             }
3089             sourceElements.push(sourceElement);
3090         }
3091         return sourceElements;
3092     }
3093
3094     function parseProgram() {
3095         var program;
3096         strict = false;
3097         program = {
3098             type: Syntax.Program,
3099             body: parseSourceElements()
3100         };
3101         return program;
3102     }
3103
3104     // The following functions are needed only when the option to preserve
3105     // the comments is active.
3106
3107     function addComment(type, value, start, end, loc) {
3108         assert(typeof start === 'number', 'Comment must have valid position');
3109
3110         // Because the way the actual token is scanned, often the comments
3111         // (if any) are skipped twice during the lexical analysis.
3112         // Thus, we need to skip adding a comment if the comment array already
3113         // handled it.
3114         if (extra.comments.length > 0) {
3115             if (extra.comments[extra.comments.length - 1].range[1] > start) {
3116                 return;
3117             }
3118         }
3119
3120         extra.comments.push({
3121             type: type,
3122             value: value,
3123             range: [start, end],
3124             loc: loc
3125         });
3126     }
3127
3128     function scanComment() {
3129         var comment, ch, loc, start, blockComment, lineComment;
3130
3131         comment = '';
3132         blockComment = false;
3133         lineComment = false;
3134
3135         while (index < length) {
3136             ch = source[index];
3137
3138             if (lineComment) {
3139                 ch = source[index++];
3140                 if (isLineTerminator(ch)) {
3141                     loc.end = {
3142                         line: lineNumber,
3143                         column: index - lineStart - 1
3144                     };
3145                     lineComment = false;
3146                     addComment('Line', comment, start, index - 1, loc);
3147                     if (ch === '\r' && source[index] === '\n') {
3148                         ++index;
3149                     }
3150                     ++lineNumber;
3151                     lineStart = index;
3152                     comment = '';
3153                 } else if (index >= length) {
3154                     lineComment = false;
3155                     comment += ch;
3156                     loc.end = {
3157                         line: lineNumber,
3158                         column: length - lineStart
3159                     };
3160                     addComment('Line', comment, start, length, loc);
3161                 } else {
3162                     comment += ch;
3163                 }
3164             } else if (blockComment) {
3165                 if (isLineTerminator(ch)) {
3166                     if (ch === '\r' && source[index + 1] === '\n') {
3167                         ++index;
3168                         comment += '\r\n';
3169                     } else {
3170                         comment += ch;
3171                     }
3172                     ++lineNumber;
3173                     ++index;
3174                     lineStart = index;
3175                     if (index >= length) {
3176                         throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
3177                     }
3178                 } else {
3179                     ch = source[index++];
3180                     if (index >= length) {
3181                         throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
3182                     }
3183                     comment += ch;
3184                     if (ch === '*') {
3185                         ch = source[index];
3186                         if (ch === '/') {
3187                             comment = comment.substr(0, comment.length - 1);
3188                             blockComment = false;
3189                             ++index;
3190                             loc.end = {
3191                                 line: lineNumber,
3192                                 column: index - lineStart
3193                             };
3194                             addComment('Block', comment, start, index, loc);
3195                             comment = '';
3196                         }
3197                     }
3198                 }
3199             } else if (ch === '/') {
3200                 ch = source[index + 1];
3201                 if (ch === '/') {
3202                     loc = {
3203                         start: {
3204                             line: lineNumber,
3205                             column: index - lineStart
3206                         }
3207                     };
3208                     start = index;
3209                     index += 2;
3210                     lineComment = true;
3211                     if (index >= length) {
3212                         loc.end = {
3213                             line: lineNumber,
3214                             column: index - lineStart
3215                         };
3216                         lineComment = false;
3217                         addComment('Line', comment, start, index, loc);
3218                     }
3219                 } else if (ch === '*') {
3220                     start = index;
3221                     index += 2;
3222                     blockComment = true;
3223                     loc = {
3224                         start: {
3225                             line: lineNumber,
3226                             column: index - lineStart - 2
3227                         }
3228                     };
3229                     if (index >= length) {
3230                         throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
3231                     }
3232                 } else {
3233                     break;
3234                 }
3235             } else if (isWhiteSpace(ch)) {
3236                 ++index;
3237             } else if (isLineTerminator(ch)) {
3238                 ++index;
3239                 if (ch ===  '\r' && source[index] === '\n') {
3240                     ++index;
3241                 }
3242                 ++lineNumber;
3243                 lineStart = index;
3244             } else {
3245                 break;
3246             }
3247         }
3248     }
3249
3250     function filterCommentLocation() {
3251         var i, entry, comment, comments = [];
3252
3253         for (i = 0; i < extra.comments.length; ++i) {
3254             entry = extra.comments[i];
3255             comment = {
3256                 type: entry.type,
3257                 value: entry.value
3258             };
3259             if (extra.range) {
3260                 comment.range = entry.range;
3261             }
3262             if (extra.loc) {
3263                 comment.loc = entry.loc;
3264             }
3265             comments.push(comment);
3266         }
3267
3268         extra.comments = comments;
3269     }
3270
3271     function collectToken() {
3272         var start, loc, token, range, value;
3273
3274         skipComment();
3275         start = index;
3276         loc = {
3277             start: {
3278                 line: lineNumber,
3279                 column: index - lineStart
3280             }
3281         };
3282
3283         token = extra.advance();
3284         loc.end = {
3285             line: lineNumber,
3286             column: index - lineStart
3287         };
3288
3289         if (token.type !== Token.EOF) {
3290             range = [token.range[0], token.range[1]];
3291             value = sliceSource(token.range[0], token.range[1]);
3292             extra.tokens.push({
3293                 type: TokenName[token.type],
3294                 value: value,
3295                 range: range,
3296                 loc: loc
3297             });
3298         }
3299
3300         return token;
3301     }
3302
3303     function collectRegex() {
3304         var pos, loc, regex, token;
3305
3306         skipComment();
3307
3308         pos = index;
3309         loc = {
3310             start: {
3311                 line: lineNumber,
3312                 column: index - lineStart
3313             }
3314         };
3315
3316         regex = extra.scanRegExp();
3317         loc.end = {
3318             line: lineNumber,
3319             column: index - lineStart
3320         };
3321
3322         // Pop the previous token, which is likely '/' or '/='
3323         if (extra.tokens.length > 0) {
3324             token = extra.tokens[extra.tokens.length - 1];
3325             if (token.range[0] === pos && token.type === 'Punctuator') {
3326                 if (token.value === '/' || token.value === '/=') {
3327                     extra.tokens.pop();
3328                 }
3329             }
3330         }
3331
3332         extra.tokens.push({
3333             type: 'RegularExpression',
3334             value: regex.literal,
3335             range: [pos, index],
3336             loc: loc
3337         });
3338
3339         return regex;
3340     }
3341
3342     function filterTokenLocation() {
3343         var i, entry, token, tokens = [];
3344
3345         for (i = 0; i < extra.tokens.length; ++i) {
3346             entry = extra.tokens[i];
3347             token = {
3348                 type: entry.type,
3349                 value: entry.value
3350             };
3351             if (extra.range) {
3352                 token.range = entry.range;
3353             }
3354             if (extra.loc) {
3355                 token.loc = entry.loc;
3356             }
3357             tokens.push(token);
3358         }
3359
3360         extra.tokens = tokens;
3361     }
3362
3363     function createLiteral(token) {
3364         return {
3365             type: Syntax.Literal,
3366             value: token.value
3367         };
3368     }
3369
3370     function createRawLiteral(token) {
3371         return {
3372             type: Syntax.Literal,
3373             value: token.value,
3374             raw: sliceSource(token.range[0], token.range[1])
3375         };
3376     }
3377
3378     function createLocationMarker() {
3379         var marker = {};
3380
3381         marker.range = [index, index];
3382         marker.loc = {
3383             start: {
3384                 line: lineNumber,
3385                 column: index - lineStart
3386             },
3387             end: {
3388                 line: lineNumber,
3389                 column: index - lineStart
3390             }
3391         };
3392
3393         marker.end = function () {
3394             this.range[1] = index;
3395             this.loc.end.line = lineNumber;
3396             this.loc.end.column = index - lineStart;
3397         };
3398
3399         marker.applyGroup = function (node) {
3400             if (extra.range) {
3401                 node.groupRange = [this.range[0], this.range[1]];
3402             }
3403             if (extra.loc) {
3404                 node.groupLoc = {
3405                     start: {
3406                         line: this.loc.start.line,
3407                         column: this.loc.start.column
3408                     },
3409                     end: {
3410                         line: this.loc.end.line,
3411                         column: this.loc.end.column
3412                     }
3413                 };
3414             }
3415         };
3416
3417         marker.apply = function (node) {
3418             if (extra.range) {
3419                 node.range = [this.range[0], this.range[1]];
3420             }
3421             if (extra.loc) {
3422                 node.loc = {
3423                     start: {
3424                         line: this.loc.start.line,
3425                         column: this.loc.start.column
3426                     },
3427                     end: {
3428                         line: this.loc.end.line,
3429                         column: this.loc.end.column
3430                     }
3431                 };
3432             }
3433         };
3434
3435         return marker;
3436     }
3437
3438     function trackGroupExpression() {
3439         var marker, expr;
3440
3441         skipComment();
3442         marker = createLocationMarker();
3443         expect('(');
3444
3445         expr = parseExpression();
3446
3447         expect(')');
3448
3449         marker.end();
3450         marker.applyGroup(expr);
3451
3452         return expr;
3453     }
3454
3455     function trackLeftHandSideExpression() {
3456         var marker, expr;
3457
3458         skipComment();
3459         marker = createLocationMarker();
3460
3461         expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();
3462
3463         while (match('.') || match('[')) {
3464             if (match('[')) {
3465                 expr = {
3466                     type: Syntax.MemberExpression,
3467                     computed: true,
3468                     object: expr,
3469                     property: parseComputedMember()
3470                 };
3471                 marker.end();
3472                 marker.apply(expr);
3473             } else {
3474                 expr = {
3475                     type: Syntax.MemberExpression,
3476                     computed: false,
3477                     object: expr,
3478                     property: parseNonComputedMember()
3479                 };
3480                 marker.end();
3481                 marker.apply(expr);
3482             }
3483         }
3484
3485         return expr;
3486     }
3487
3488     function trackLeftHandSideExpressionAllowCall() {
3489         var marker, expr;
3490
3491         skipComment();
3492         marker = createLocationMarker();
3493
3494         expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();
3495
3496         while (match('.') || match('[') || match('(')) {
3497             if (match('(')) {
3498                 expr = {
3499                     type: Syntax.CallExpression,
3500                     callee: expr,
3501                     'arguments': parseArguments()
3502                 };
3503                 marker.end();
3504                 marker.apply(expr);
3505             } else if (match('[')) {
3506                 expr = {
3507                     type: Syntax.MemberExpression,
3508                     computed: true,
3509                     object: expr,
3510                     property: parseComputedMember()
3511                 };
3512                 marker.end();
3513                 marker.apply(expr);
3514             } else {
3515                 expr = {
3516                     type: Syntax.MemberExpression,
3517                     computed: false,
3518                     object: expr,
3519                     property: parseNonComputedMember()
3520                 };
3521                 marker.end();
3522                 marker.apply(expr);
3523             }
3524         }
3525
3526         return expr;
3527     }
3528
3529     function filterGroup(node) {
3530         var n, i, entry;
3531
3532         n = (Object.prototype.toString.apply(node) === '[object Array]') ? [] : {};
3533         for (i in node) {
3534             if (node.hasOwnProperty(i) && i !== 'groupRange' && i !== 'groupLoc') {
3535                 entry = node[i];
3536                 if (entry === null || typeof entry !== 'object' || entry instanceof RegExp) {
3537                     n[i] = entry;
3538                 } else {
3539                     n[i] = filterGroup(entry);
3540                 }
3541             }
3542         }
3543         return n;
3544     }
3545
3546     function wrapTrackingFunction(range, loc) {
3547
3548         return function (parseFunction) {
3549
3550             function isBinary(node) {
3551                 return node.type === Syntax.LogicalExpression ||
3552                     node.type === Syntax.BinaryExpression;
3553             }
3554
3555             function visit(node) {
3556                 var start, end;
3557
3558                 if (isBinary(node.left)) {
3559                     visit(node.left);
3560                 }
3561                 if (isBinary(node.right)) {
3562                     visit(node.right);
3563                 }
3564
3565                 if (range) {
3566                     if (node.left.groupRange || node.right.groupRange) {
3567                         start = node.left.groupRange ? node.left.groupRange[0] : node.left.range[0];
3568                         end = node.right.groupRange ? node.right.groupRange[1] : node.right.range[1];
3569                         node.range = [start, end];
3570                     } else if (typeof node.range === 'undefined') {
3571                         start = node.left.range[0];
3572                         end = node.right.range[1];
3573                         node.range = [start, end];
3574                     }
3575                 }
3576                 if (loc) {
3577                     if (node.left.groupLoc || node.right.groupLoc) {
3578                         start = node.left.groupLoc ? node.left.groupLoc.start : node.left.loc.start;
3579                         end = node.right.groupLoc ? node.right.groupLoc.end : node.right.loc.end;
3580                         node.loc = {
3581                             start: start,
3582                             end: end
3583                         };
3584                     } else if (typeof node.loc === 'undefined') {
3585                         node.loc = {
3586                             start: node.left.loc.start,
3587                             end: node.right.loc.end
3588                         };
3589                     }
3590                 }
3591             }
3592
3593             return function () {
3594                 var marker, node;
3595
3596                 skipComment();
3597
3598                 marker = createLocationMarker();
3599                 node = parseFunction.apply(null, arguments);
3600                 marker.end();
3601
3602                 if (range && typeof node.range === 'undefined') {
3603                     marker.apply(node);
3604                 }
3605
3606                 if (loc && typeof node.loc === 'undefined') {
3607                     marker.apply(node);
3608                 }
3609
3610                 if (isBinary(node)) {
3611                     visit(node);
3612                 }
3613
3614                 return node;
3615             };
3616         };
3617     }
3618
3619     function patch() {
3620
3621         var wrapTracking;
3622
3623         if (extra.comments) {
3624             extra.skipComment = skipComment;
3625             skipComment = scanComment;
3626         }
3627
3628         if (extra.raw) {
3629             extra.createLiteral = createLiteral;
3630             createLiteral = createRawLiteral;
3631         }
3632
3633         if (extra.range || extra.loc) {
3634
3635             extra.parseGroupExpression = parseGroupExpression;
3636             extra.parseLeftHandSideExpression = parseLeftHandSideExpression;
3637             extra.parseLeftHandSideExpressionAllowCall = parseLeftHandSideExpressionAllowCall;
3638             parseGroupExpression = trackGroupExpression;
3639             parseLeftHandSideExpression = trackLeftHandSideExpression;
3640             parseLeftHandSideExpressionAllowCall = trackLeftHandSideExpressionAllowCall;
3641
3642             wrapTracking = wrapTrackingFunction(extra.range, extra.loc);
3643
3644             extra.parseAdditiveExpression = parseAdditiveExpression;
3645             extra.parseAssignmentExpression = parseAssignmentExpression;
3646             extra.parseBitwiseANDExpression = parseBitwiseANDExpression;
3647             extra.parseBitwiseORExpression = parseBitwiseORExpression;
3648             extra.parseBitwiseXORExpression = parseBitwiseXORExpression;
3649             extra.parseBlock = parseBlock;
3650             extra.parseFunctionSourceElements = parseFunctionSourceElements;
3651             extra.parseCatchClause = parseCatchClause;
3652             extra.parseComputedMember = parseComputedMember;
3653             extra.parseConditionalExpression = parseConditionalExpression;
3654             extra.parseConstLetDeclaration = parseConstLetDeclaration;
3655             extra.parseEqualityExpression = parseEqualityExpression;
3656             extra.parseExpression = parseExpression;
3657             extra.parseForVariableDeclaration = parseForVariableDeclaration;
3658             extra.parseFunctionDeclaration = parseFunctionDeclaration;
3659             extra.parseFunctionExpression = parseFunctionExpression;
3660             extra.parseLogicalANDExpression = parseLogicalANDExpression;
3661             extra.parseLogicalORExpression = parseLogicalORExpression;
3662             extra.parseMultiplicativeExpression = parseMultiplicativeExpression;
3663             extra.parseNewExpression = parseNewExpression;
3664             extra.parseNonComputedProperty = parseNonComputedProperty;
3665             extra.parseObjectProperty = parseObjectProperty;
3666             extra.parseObjectPropertyKey = parseObjectPropertyKey;
3667             extra.parsePostfixExpression = parsePostfixExpression;
3668             extra.parsePrimaryExpression = parsePrimaryExpression;
3669             extra.parseProgram = parseProgram;
3670             extra.parsePropertyFunction = parsePropertyFunction;
3671             extra.parseRelationalExpression = parseRelationalExpression;
3672             extra.parseStatement = parseStatement;
3673             extra.parseShiftExpression = parseShiftExpression;
3674             extra.parseSwitchCase = parseSwitchCase;
3675             extra.parseUnaryExpression = parseUnaryExpression;
3676             extra.parseVariableDeclaration = parseVariableDeclaration;
3677             extra.parseVariableIdentifier = parseVariableIdentifier;
3678
3679             parseAdditiveExpression = wrapTracking(extra.parseAdditiveExpression);
3680             parseAssignmentExpression = wrapTracking(extra.parseAssignmentExpression);
3681             parseBitwiseANDExpression = wrapTracking(extra.parseBitwiseANDExpression);
3682             parseBitwiseORExpression = wrapTracking(extra.parseBitwiseORExpression);
3683             parseBitwiseXORExpression = wrapTracking(extra.parseBitwiseXORExpression);
3684             parseBlock = wrapTracking(extra.parseBlock);
3685             parseFunctionSourceElements = wrapTracking(extra.parseFunctionSourceElements);
3686             parseCatchClause = wrapTracking(extra.parseCatchClause);
3687             parseComputedMember = wrapTracking(extra.parseComputedMember);
3688             parseConditionalExpression = wrapTracking(extra.parseConditionalExpression);
3689             parseConstLetDeclaration = wrapTracking(extra.parseConstLetDeclaration);
3690             parseEqualityExpression = wrapTracking(extra.parseEqualityExpression);
3691             parseExpression = wrapTracking(extra.parseExpression);
3692             parseForVariableDeclaration = wrapTracking(extra.parseForVariableDeclaration);
3693             parseFunctionDeclaration = wrapTracking(extra.parseFunctionDeclaration);
3694             parseFunctionExpression = wrapTracking(extra.parseFunctionExpression);
3695             parseLeftHandSideExpression = wrapTracking(parseLeftHandSideExpression);
3696             parseLogicalANDExpression = wrapTracking(extra.parseLogicalANDExpression);
3697             parseLogicalORExpression = wrapTracking(extra.parseLogicalORExpression);
3698             parseMultiplicativeExpression = wrapTracking(extra.parseMultiplicativeExpression);
3699             parseNewExpression = wrapTracking(extra.parseNewExpression);
3700             parseNonComputedProperty = wrapTracking(extra.parseNonComputedProperty);
3701             parseObjectProperty = wrapTracking(extra.parseObjectProperty);
3702             parseObjectPropertyKey = wrapTracking(extra.parseObjectPropertyKey);
3703             parsePostfixExpression = wrapTracking(extra.parsePostfixExpression);
3704             parsePrimaryExpression = wrapTracking(extra.parsePrimaryExpression);
3705             parseProgram = wrapTracking(extra.parseProgram);
3706             parsePropertyFunction = wrapTracking(extra.parsePropertyFunction);
3707             parseRelationalExpression = wrapTracking(extra.parseRelationalExpression);
3708             parseStatement = wrapTracking(extra.parseStatement);
3709             parseShiftExpression = wrapTracking(extra.parseShiftExpression);
3710             parseSwitchCase = wrapTracking(extra.parseSwitchCase);
3711             parseUnaryExpression = wrapTracking(extra.parseUnaryExpression);
3712             parseVariableDeclaration = wrapTracking(extra.parseVariableDeclaration);
3713             parseVariableIdentifier = wrapTracking(extra.parseVariableIdentifier);
3714         }
3715
3716         if (typeof extra.tokens !== 'undefined') {
3717             extra.advance = advance;
3718             extra.scanRegExp = scanRegExp;
3719
3720             advance = collectToken;
3721             scanRegExp = collectRegex;
3722         }
3723     }
3724
3725     function unpatch() {
3726         if (typeof extra.skipComment === 'function') {
3727             skipComment = extra.skipComment;
3728         }
3729
3730         if (extra.raw) {
3731             createLiteral = extra.createLiteral;
3732         }
3733
3734         if (extra.range || extra.loc) {
3735             parseAdditiveExpression = extra.parseAdditiveExpression;
3736             parseAssignmentExpression = extra.parseAssignmentExpression;
3737             parseBitwiseANDExpression = extra.parseBitwiseANDExpression;
3738             parseBitwiseORExpression = extra.parseBitwiseORExpression;
3739             parseBitwiseXORExpression = extra.parseBitwiseXORExpression;
3740             parseBlock = extra.parseBlock;
3741             parseFunctionSourceElements = extra.parseFunctionSourceElements;
3742             parseCatchClause = extra.parseCatchClause;
3743             parseComputedMember = extra.parseComputedMember;
3744             parseConditionalExpression = extra.parseConditionalExpression;
3745             parseConstLetDeclaration = extra.parseConstLetDeclaration;
3746             parseEqualityExpression = extra.parseEqualityExpression;
3747             parseExpression = extra.parseExpression;
3748             parseForVariableDeclaration = extra.parseForVariableDeclaration;
3749             parseFunctionDeclaration = extra.parseFunctionDeclaration;
3750             parseFunctionExpression = extra.parseFunctionExpression;
3751             parseGroupExpression = extra.parseGroupExpression;
3752             parseLeftHandSideExpression = extra.parseLeftHandSideExpression;
3753             parseLeftHandSideExpressionAllowCall = extra.parseLeftHandSideExpressionAllowCall;
3754             parseLogicalANDExpression = extra.parseLogicalANDExpression;
3755             parseLogicalORExpression = extra.parseLogicalORExpression;
3756             parseMultiplicativeExpression = extra.parseMultiplicativeExpression;
3757             parseNewExpression = extra.parseNewExpression;
3758             parseNonComputedProperty = extra.parseNonComputedProperty;
3759             parseObjectProperty = extra.parseObjectProperty;
3760             parseObjectPropertyKey = extra.parseObjectPropertyKey;
3761             parsePrimaryExpression = extra.parsePrimaryExpression;
3762             parsePostfixExpression = extra.parsePostfixExpression;
3763             parseProgram = extra.parseProgram;
3764             parsePropertyFunction = extra.parsePropertyFunction;
3765             parseRelationalExpression = extra.parseRelationalExpression;
3766             parseStatement = extra.parseStatement;
3767             parseShiftExpression = extra.parseShiftExpression;
3768             parseSwitchCase = extra.parseSwitchCase;
3769             parseUnaryExpression = extra.parseUnaryExpression;
3770             parseVariableDeclaration = extra.parseVariableDeclaration;
3771             parseVariableIdentifier = extra.parseVariableIdentifier;
3772         }
3773
3774         if (typeof extra.scanRegExp === 'function') {
3775             advance = extra.advance;
3776             scanRegExp = extra.scanRegExp;
3777         }
3778     }
3779
3780     function stringToArray(str) {
3781         var length = str.length,
3782             result = [],
3783             i;
3784         for (i = 0; i < length; ++i) {
3785             result[i] = str.charAt(i);
3786         }
3787         return result;
3788     }
3789
3790     function parse(code, options) {
3791         var program, toString;
3792
3793         toString = String;
3794         if (typeof code !== 'string' && !(code instanceof String)) {
3795             code = toString(code);
3796         }
3797
3798         source = code;
3799         index = 0;
3800         lineNumber = (source.length > 0) ? 1 : 0;
3801         lineStart = 0;
3802         length = source.length;
3803         buffer = null;
3804         state = {
3805             allowIn: true,
3806             labelSet: {},
3807             inFunctionBody: false,
3808             inIteration: false,
3809             inSwitch: false
3810         };
3811
3812         extra = {};
3813         if (typeof options !== 'undefined') {
3814             extra.range = (typeof options.range === 'boolean') && options.range;
3815             extra.loc = (typeof options.loc === 'boolean') && options.loc;
3816             extra.raw = (typeof options.raw === 'boolean') && options.raw;
3817             if (typeof options.tokens === 'boolean' && options.tokens) {
3818                 extra.tokens = [];
3819             }
3820             if (typeof options.comment === 'boolean' && options.comment) {
3821                 extra.comments = [];
3822             }
3823             if (typeof options.tolerant === 'boolean' && options.tolerant) {
3824                 extra.errors = [];
3825             }
3826         }
3827
3828         if (length > 0) {
3829             if (typeof source[0] === 'undefined') {
3830                 // Try first to convert to a string. This is good as fast path
3831                 // for old IE which understands string indexing for string
3832                 // literals only and not for string object.
3833                 if (code instanceof String) {
3834                     source = code.valueOf();
3835                 }
3836
3837                 // Force accessing the characters via an array.
3838                 if (typeof source[0] === 'undefined') {
3839                     source = stringToArray(code);
3840                 }
3841             }
3842         }
3843
3844         patch();
3845         try {
3846             program = parseProgram();
3847             if (typeof extra.comments !== 'undefined') {
3848                 filterCommentLocation();
3849                 program.comments = extra.comments;
3850             }
3851             if (typeof extra.tokens !== 'undefined') {
3852                 filterTokenLocation();
3853                 program.tokens = extra.tokens;
3854             }
3855             if (typeof extra.errors !== 'undefined') {
3856                 program.errors = extra.errors;
3857             }
3858             if (extra.range || extra.loc) {
3859                 program.body = filterGroup(program.body);
3860             }
3861         } catch (e) {
3862             throw e;
3863         } finally {
3864             unpatch();
3865             extra = {};
3866         }
3867
3868         return program;
3869     }
3870
3871     // Sync with package.json.
3872     exports.version = '1.0.2';
3873
3874     exports.parse = parse;
3875
3876     // Deep copy.
3877     exports.Syntax = (function () {
3878         var name, types = {};
3879
3880         if (typeof Object.create === 'function') {
3881             types = Object.create(null);
3882         }
3883
3884         for (name in Syntax) {
3885             if (Syntax.hasOwnProperty(name)) {
3886                 types[name] = Syntax[name];
3887             }
3888         }
3889
3890         if (typeof Object.freeze === 'function') {
3891             Object.freeze(types);
3892         }
3893
3894         return types;
3895     }());
3896
3897 }));
3898 /* vim: set sw=4 ts=4 et tw=80 : */
3899
3900 })(null);
3901
3902 (function(require,module){
3903
3904 var parse = require('esprima').parse;
3905 var objectKeys = Object.keys || function (obj) {
3906     var keys = [];
3907     for (var key in obj) keys.push(key);
3908     return keys;
3909 };
3910 var forEach = function (xs, fn) {
3911     if (xs.forEach) return xs.forEach(fn);
3912     for (var i = 0; i < xs.length; i++) {
3913         fn.call(xs, xs[i], i, xs);
3914     }
3915 };
3916
3917 var isArray = Array.isArray || function (xs) {
3918     return Object.prototype.toString.call(xs) === '[object Array]';
3919 };
3920
3921 module.exports = function (src, opts, fn) {
3922     if (typeof opts === 'function') {
3923         fn = opts;
3924         opts = {};
3925     }
3926     if (typeof src === 'object') {
3927         opts = src;
3928         src = opts.source;
3929         delete opts.source;
3930     }
3931     src = src === undefined ? opts.source : src;
3932     opts.range = true;
3933     if (typeof src !== 'string') src = String(src);
3934
3935     var ast = parse(src, opts);
3936
3937     var result = {
3938         chunks : src.split(''),
3939         toString : function () { return result.chunks.join('') },
3940         inspect : function () { return result.toString() }
3941     };
3942     var index = 0;
3943
3944     (function walk (node, parent) {
3945         insertHelpers(node, parent, result.chunks);
3946
3947         forEach(objectKeys(node), function (key) {
3948             if (key === 'parent') return;
3949
3950             var child = node[key];
3951             if (isArray(child)) {
3952                 forEach(child, function (c) {
3953                     if (c && typeof c.type === 'string') {
3954                         walk(c, node);
3955                     }
3956                 });
3957             }
3958             else if (child && typeof child.type === 'string') {
3959                 insertHelpers(child, node, result.chunks);
3960                 walk(child, node);
3961             }
3962         });
3963         fn(node);
3964     })(ast, undefined);
3965
3966     return result;
3967 };
3968
3969 function insertHelpers (node, parent, chunks) {
3970     if (!node.range) return;
3971
3972     node.parent = parent;
3973
3974     node.source = function () {
3975         return chunks.slice(
3976             node.range[0], node.range[1]
3977         ).join('');
3978     };
3979
3980     if (node.update && typeof node.update === 'object') {
3981         var prev = node.update;
3982         forEach(objectKeys(prev), function (key) {
3983             update[key] = prev[key];
3984         });
3985         node.update = update;
3986     }
3987     else {
3988         node.update = update;
3989     }
3990
3991     function update (s) {
3992         chunks[node.range[0]] = s;
3993         for (var i = node.range[0] + 1; i < node.range[1]; i++) {
3994             chunks[i] = '';
3995         }
3996     };
3997 }
3998
3999 window.falafel = module.exports;})(function(){return {parse: esprima.parse};},{exports: {}});
4000
4001 var inBrowser = typeof window !== 'undefined' && this === window;
4002 var parseAndModify = (inBrowser ? window.falafel : require("falafel"));
4003
4004 (inBrowser ? window : exports).blanket = (function(){
4005     var linesToAddTracking = [
4006         "ExpressionStatement",
4007         "BreakStatement"   ,
4008         "ContinueStatement" ,
4009         "VariableDeclaration",
4010         "ReturnStatement"   ,
4011         "ThrowStatement"   ,
4012         "TryStatement"     ,
4013         "FunctionDeclaration"    ,
4014         "IfStatement"       ,
4015         "WhileStatement"    ,
4016         "DoWhileStatement"   ,
4017         "ForStatement"   ,
4018         "ForInStatement"  ,
4019         "SwitchStatement"  ,
4020         "WithStatement"
4021     ],
4022     linesToAddBrackets = [
4023         "IfStatement"       ,
4024         "WhileStatement"    ,
4025         "DoWhileStatement"     ,
4026         "ForStatement"   ,
4027         "ForInStatement"  ,
4028         "WithStatement"
4029     ],
4030     __blanket,
4031     copynumber = Math.floor(Math.random()*1000),
4032     coverageInfo = {},options = {
4033         reporter: null,
4034         adapter:null,
4035         filter: null,
4036         customVariable: null,
4037         loader: null,
4038         ignoreScriptError: false,
4039         existingRequireJS:false,
4040         autoStart: false,
4041         timeout: 180,
4042         ignoreCors: false,
4043         branchTracking: false,
4044         sourceURL: false,
4045         debug:false,
4046         engineOnly:false,
4047         testReadyCallback:null,
4048         commonJS:false,
4049         instrumentCache:false,
4050         modulePattern: null
4051     };
4052
4053     if (inBrowser && typeof window.blanket !== 'undefined'){
4054         __blanket = window.blanket.noConflict();
4055     }
4056
4057     _blanket = {
4058         noConflict: function(){
4059             if (__blanket){
4060                 return __blanket;
4061             }
4062             return _blanket;
4063         },
4064         _getCopyNumber: function(){
4065             //internal method
4066             //for differentiating between instances
4067             return copynumber;
4068         },
4069         extend: function(obj) {
4070             //borrowed from underscore
4071             _blanket._extend(_blanket,obj);
4072         },
4073         _extend: function(dest,source){
4074           if (source) {
4075             for (var prop in source) {
4076               if ( dest[prop] instanceof Object && typeof dest[prop] !== "function"){
4077                 _blanket._extend(dest[prop],source[prop]);
4078               }else{
4079                   dest[prop] = source[prop];
4080               }
4081             }
4082           }
4083         },
4084         getCovVar: function(){
4085             var opt = _blanket.options("customVariable");
4086             if (opt){
4087                 if (_blanket.options("debug")) {console.log("BLANKET-Using custom tracking variable:",opt);}
4088                 return inBrowser ? "window."+opt : opt;
4089             }
4090             return inBrowser ?   "window._$blanket" : "_$jscoverage";
4091         },
4092         options: function(key,value){
4093             if (typeof key !== "string"){
4094                 _blanket._extend(options,key);
4095             }else if (typeof value === 'undefined'){
4096                 return options[key];
4097             }else{
4098                 options[key]=value;
4099             }
4100         },
4101         instrument: function(config, next){
4102             //check instrumented hash table,
4103             //return instrumented code if available.
4104             var inFile = config.inputFile,
4105                 inFileName = config.inputFileName;
4106             //check instrument cache
4107            if (_blanket.options("instrumentCache") && sessionStorage && sessionStorage.getItem("blanket_instrument_store-"+inFileName)){
4108                 if (_blanket.options("debug")) {console.log("BLANKET-Reading instrumentation from cache: ",inFileName);}
4109                 next(sessionStorage.getItem("blanket_instrument_store-"+inFileName));
4110             }else{
4111                 var sourceArray = _blanket._prepareSource(inFile);
4112                 _blanket._trackingArraySetup=[];
4113                 var instrumented =  parseAndModify(inFile,{loc:true,comment:true}, _blanket._addTracking(inFileName));
4114                 instrumented = _blanket._trackingSetup(inFileName,sourceArray)+instrumented;
4115                 if (_blanket.options("sourceURL")){
4116                     instrumented += "\n//@ sourceURL="+inFileName.replace("http://","");
4117                 }
4118                 if (_blanket.options("debug")) {console.log("BLANKET-Instrumented file: ",inFileName);}
4119                 if (_blanket.options("instrumentCache") && sessionStorage){
4120                     if (_blanket.options("debug")) {console.log("BLANKET-Saving instrumentation to cache: ",inFileName);}
4121                     sessionStorage.setItem("blanket_instrument_store-"+inFileName,instrumented);
4122                 }
4123                 next(instrumented);
4124             }
4125         },
4126         _trackingArraySetup: [],
4127         _branchingArraySetup: [],
4128         _prepareSource: function(source){
4129             return source.replace(/\\/g,"\\\\").replace(/'/g,"\\'").replace(/(\r\n|\n|\r)/gm,"\n").split('\n');
4130         },
4131         _trackingSetup: function(filename,sourceArray){
4132             var branches = _blanket.options("branchTracking");
4133             var sourceString = sourceArray.join("',\n'");
4134             var intro = "";
4135             var covVar = _blanket.getCovVar();
4136
4137             intro += "if (typeof "+covVar+" === 'undefined') "+covVar+" = {};\n";
4138             if (branches){
4139                 intro += "var _$branchFcn=function(f,l,c,r){ ";
4140                 intro += "if (!!r) { ";
4141                 intro += covVar+"[f].branchData[l][c][0] = "+covVar+"[f].branchData[l][c][0] || [];";
4142                 intro += covVar+"[f].branchData[l][c][0].push(r); }";
4143                 intro += "else { ";
4144                 intro += covVar+"[f].branchData[l][c][1] = "+covVar+"[f].branchData[l][c][1] || [];";
4145                 intro += covVar+"[f].branchData[l][c][1].push(r); }";
4146                 intro += "return r;};\n";
4147             }
4148             intro += "if (typeof "+covVar+"['"+filename+"'] === 'undefined'){";
4149
4150             intro += covVar+"['"+filename+"']=[];\n";
4151             if (branches){
4152                 intro += covVar+"['"+filename+"'].branchData=[];\n";
4153             }
4154             intro += covVar+"['"+filename+"'].source=['"+sourceString+"'];\n";
4155             //initialize array values
4156             _blanket._trackingArraySetup.sort(function(a,b){
4157                 return parseInt(a,10) > parseInt(b,10);
4158             }).forEach(function(item){
4159                 intro += covVar+"['"+filename+"']["+item+"]=0;\n";
4160             });
4161             if (branches){
4162                 _blanket._branchingArraySetup.sort(function(a,b){
4163                     return a.line > b.line;
4164                 }).sort(function(a,b){
4165                     return a.column > b.column;
4166                 }).forEach(function(item){
4167                     if (item.file === filename){
4168                         intro += "if (typeof "+ covVar+"['"+filename+"'].branchData["+item.line+"] === 'undefined'){\n";
4169                         intro += covVar+"['"+filename+"'].branchData["+item.line+"]=[];\n";
4170                         intro += "}";
4171                         intro += covVar+"['"+filename+"'].branchData["+item.line+"]["+item.column+"] = [];\n";
4172                         intro += covVar+"['"+filename+"'].branchData["+item.line+"]["+item.column+"].consequent = "+JSON.stringify(item.consequent)+";\n";
4173                         intro += covVar+"['"+filename+"'].branchData["+item.line+"]["+item.column+"].alternate = "+JSON.stringify(item.alternate)+";\n";
4174                     }
4175                 });
4176             }
4177             intro += "}";
4178
4179             return intro;
4180         },
4181         _blockifyIf: function(node){
4182             if (linesToAddBrackets.indexOf(node.type) > -1){
4183                 var bracketsExistObject = node.consequent || node.body;
4184                 var bracketsExistAlt = node.alternate;
4185                 if( bracketsExistAlt && bracketsExistAlt.type !== "BlockStatement") {
4186                     bracketsExistAlt.update("{\n"+bracketsExistAlt.source()+"}\n");
4187                 }
4188                 if( bracketsExistObject && bracketsExistObject.type !== "BlockStatement") {
4189                     bracketsExistObject.update("{\n"+bracketsExistObject.source()+"}\n");
4190                 }
4191             }
4192         },
4193         _trackBranch: function(node,filename){
4194             //recursive on consequent and alternative
4195             var line = node.loc.start.line;
4196             var col = node.loc.start.column;
4197
4198             _blanket._branchingArraySetup.push({
4199                 line: line,
4200                 column: col,
4201                 file:filename,
4202                 consequent: node.consequent.loc,
4203                 alternate: node.alternate.loc
4204             });
4205
4206             var source = node.source();
4207             var updated = "_$branchFcn"+
4208                           "('"+filename+"',"+line+","+col+","+source.slice(0,source.indexOf("?"))+
4209                           ")"+source.slice(source.indexOf("?"));
4210             node.update(updated);
4211         },
4212         _addTracking: function (filename) {
4213             //falafel doesn't take a file name
4214             //so we include the filename in a closure
4215             //and return the function to falafel
4216             var covVar = _blanket.getCovVar();
4217
4218             return function(node){
4219                 _blanket._blockifyIf(node);
4220
4221                 if (linesToAddTracking.indexOf(node.type) > -1 && node.parent.type !== "LabeledStatement") {
4222                     _blanket._checkDefs(node,filename);
4223                     if (node.type === "VariableDeclaration" &&
4224                         (node.parent.type === "ForStatement" || node.parent.type === "ForInStatement")){
4225                         return;
4226                     }
4227                     if (node.loc && node.loc.start){
4228                         node.update(covVar+"['"+filename+"']["+node.loc.start.line+"]++;\n"+node.source());
4229                         _blanket._trackingArraySetup.push(node.loc.start.line);
4230                     }else{
4231                         //I don't think we can handle a node with no location
4232                         throw new Error("The instrumenter encountered a node with no location: "+Object.keys(node));
4233                     }
4234                 }else if (_blanket.options("branchTracking") && node.type === "ConditionalExpression"){
4235                     _blanket._trackBranch(node,filename);
4236                 }
4237             };
4238         },
4239         _checkDefs: function(node,filename){
4240             // Make sure developers don't redefine window. if they do, inform them it is wrong.
4241             if (inBrowser){
4242                 if (node.type === "VariableDeclaration" && node.declarations) {
4243                     node.declarations.forEach(function(declaration) {
4244                         if (declaration.id.name === "window") {
4245                             throw new Error("Instrumentation error, you cannot redefine the 'window' variable in  " + filename + ":" + node.loc.start.line);
4246                         }
4247                     });
4248                 }
4249                 if (node.type === "FunctionDeclaration" && node.params) {
4250                     node.params.forEach(function(param) {
4251                         if (param.name === "window") {
4252                             throw new Error("Instrumentation error, you cannot redefine the 'window' variable in  " + filename + ":" + node.loc.start.line);
4253                         }
4254                     });
4255                 }
4256                 //Make sure developers don't redefine the coverage variable
4257                 if (node.type === "ExpressionStatement" &&
4258                     node.expression && node.expression.left &&
4259                     node.expression.left.object && node.expression.left.property &&
4260                     node.expression.left.object.name +
4261                         "." + node.expression.left.property.name === _blanket.getCovVar()) {
4262                     throw new Error("Instrumentation error, you cannot redefine the coverage variable in  " + filename + ":" + node.loc.start.line);
4263                 }
4264             }else{
4265                 //Make sure developers don't redefine the coverage variable in node
4266                 if (node.type === "ExpressionStatement" &&
4267                     node.expression && node.expression.left &&
4268                     !node.expression.left.object && !node.expression.left.property &&
4269                     node.expression.left.name === _blanket.getCovVar()) {
4270                     throw new Error("Instrumentation error, you cannot redefine the coverage variable in  " + filename + ":" + node.loc.start.line);
4271                 }
4272             }
4273         },
4274         setupCoverage: function(){
4275             coverageInfo.instrumentation = "blanket";
4276             coverageInfo.stats = {
4277                 "suites": 0,
4278                 "tests": 0,
4279                 "passes": 0,
4280                 "pending": 0,
4281                 "failures": 0,
4282                 "start": new Date()
4283             };
4284         },
4285         _checkIfSetup: function(){
4286             if (!coverageInfo.stats){
4287                 throw new Error("You must call blanket.setupCoverage() first.");
4288             }
4289         },
4290         onTestStart: function(){
4291             if (_blanket.options("debug")) {console.log("BLANKET-Test event started");}
4292             this._checkIfSetup();
4293             coverageInfo.stats.tests++;
4294             coverageInfo.stats.pending++;
4295         },
4296         onTestDone: function(total,passed){
4297             this._checkIfSetup();
4298             if(passed === total){
4299                 coverageInfo.stats.passes++;
4300             }else{
4301                 coverageInfo.stats.failures++;
4302             }
4303             coverageInfo.stats.pending--;
4304         },
4305         onModuleStart: function(){
4306             this._checkIfSetup();
4307             coverageInfo.stats.suites++;
4308         },
4309         onTestsDone: function(){
4310             if (_blanket.options("debug")) {console.log("BLANKET-Test event done");}
4311             this._checkIfSetup();
4312             coverageInfo.stats.end = new Date();
4313
4314             if (inBrowser){
4315                 this.report(coverageInfo);
4316             }else{
4317                 if (!_blanket.options("branchTracking")){
4318                     delete (inBrowser ? window : global)[_blanket.getCovVar()].branchFcn;
4319                 }
4320                 this.options("reporter").call(this,coverageInfo);
4321             }
4322         }
4323     };
4324     return _blanket;
4325 })();
4326
4327 (function(_blanket){
4328     var oldOptions = _blanket.options;
4329 _blanket.extend({
4330     outstandingRequireFiles:[],
4331     options: function(key,value){
4332         var newVal={};
4333
4334         if (typeof key !== "string"){
4335             //key is key/value map
4336             oldOptions(key);
4337             newVal = key;
4338         }else if (typeof value === 'undefined'){
4339             //accessor
4340             return oldOptions(key);
4341         }else{
4342             //setter
4343             oldOptions(key,value);
4344             newVal[key] = value;
4345         }
4346
4347         if (newVal.adapter){
4348             _blanket._loadFile(newVal.adapter);
4349         }
4350         if (newVal.loader){
4351             _blanket._loadFile(newVal.loader);
4352         }
4353     },
4354     requiringFile: function(filename,done){
4355         if (typeof filename === "undefined"){
4356             _blanket.outstandingRequireFiles=[];
4357         }else if (typeof done === "undefined"){
4358             _blanket.outstandingRequireFiles.push(filename);
4359         }else{
4360             _blanket.outstandingRequireFiles.splice(_blanket.outstandingRequireFiles.indexOf(filename),1);
4361         }
4362     },
4363     requireFilesLoaded: function(){
4364         return _blanket.outstandingRequireFiles.length === 0;
4365     },
4366     showManualLoader: function(){
4367         if (document.getElementById("blanketLoaderDialog")){
4368             return;
4369         }
4370         //copied from http://blog.avtex.com/2012/01/26/cross-browser-css-only-modal-box/
4371         var loader = "<div class='blanketDialogOverlay'>";
4372             loader += "&nbsp;</div>";
4373             loader += "<div class='blanketDialogVerticalOffset'>";
4374             loader += "<div class='blanketDialogBox'>";
4375             loader += "<b>Error:</b> Blanket.js encountered a cross origin request error while instrumenting the source files.  ";
4376             loader += "<br><br>This is likely caused by the source files being referenced locally (using the file:// protocol). ";
4377             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).";
4378             loader += "<br>";
4379             if (typeof FileReader !== "undefined"){
4380                 loader += "<br>Or, try the experimental loader.  When prompted, simply click on the directory containing all the source files you want covered.";
4381                 loader += "<a href='javascript:document.getElementById(\"fileInput\").click();'>Start Loader</a>";
4382                 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'/>";
4383             }
4384             loader += "<br><span style='float:right;cursor:pointer;'  onclick=document.getElementById('blanketLoaderDialog').style.display='none';>Close</span>";
4385             loader += "<div style='clear:both'></div>";
4386             loader += "</div></div>";
4387
4388         var css = ".blanketDialogWrapper {";
4389             css += "display:block;";
4390             css += "position:fixed;";
4391             css += "z-index:40001; }";
4392
4393             css += ".blanketDialogOverlay {";
4394             css += "position:fixed;";
4395             css += "width:100%;";
4396             css += "height:100%;";
4397             css += "background-color:black;";
4398             css += "opacity:.5; ";
4399             css += "-ms-filter:'progid:DXImageTransform.Microsoft.Alpha(Opacity=50)'; ";
4400             css += "filter:alpha(opacity=50); ";
4401             css += "z-index:40001; }";
4402
4403             css += ".blanketDialogVerticalOffset { ";
4404             css += "position:fixed;";
4405             css += "top:30%;";
4406             css += "width:100%;";
4407             css += "z-index:40002; }";
4408
4409             css += ".blanketDialogBox { ";
4410             css += "width:405px; ";
4411             css += "position:relative;";
4412             css += "margin:0 auto;";
4413             css += "background-color:white;";
4414             css += "padding:10px;";
4415             css += "border:1px solid black; }";
4416
4417         var dom = document.createElement("style");
4418         dom.innerHTML = css;
4419         document.head.appendChild(dom);
4420
4421         var div = document.createElement("div");
4422         div.id = "blanketLoaderDialog";
4423         div.className = "blanketDialogWrapper";
4424         div.innerHTML = loader;
4425         document.body.insertBefore(div,document.body.firstChild);
4426
4427     },
4428     manualFileLoader: function(files){
4429         var toArray =Array.prototype.slice;
4430         files = toArray.call(files).filter(function(item){
4431             return item.type !== "";
4432         });
4433         var sessionLength = files.length-1;
4434         var sessionIndx=0;
4435         var sessionArray = {};
4436         if (sessionStorage["blanketSessionLoader"]){
4437             sessionArray = JSON.parse(sessionStorage["blanketSessionLoader"]);
4438         }
4439
4440
4441         var fileLoader = function(event){
4442             var fileContent = event.currentTarget.result;
4443             var file = files[sessionIndx];
4444             var filename = file.webkitRelativePath && file.webkitRelativePath !== '' ? file.webkitRelativePath : file.name;
4445             sessionArray[filename] = fileContent;
4446             sessionIndx++;
4447             if (sessionIndx === sessionLength){
4448                 sessionStorage.setItem("blanketSessionLoader", JSON.stringify(sessionArray));
4449                 document.location.reload();
4450             }else{
4451                 readFile(files[sessionIndx]);
4452             }
4453         };
4454         function readFile(file){
4455             var reader = new FileReader();
4456             reader.onload = fileLoader;
4457             reader.readAsText(file);
4458         }
4459         readFile(files[sessionIndx]);
4460     },
4461     _loadFile: function(path){
4462         if (typeof path !== "undefined"){
4463             var request = new XMLHttpRequest();
4464             request.open('GET', path, false);
4465             request.send();
4466             _blanket._addScript(request.responseText);
4467         }
4468     },
4469     _addScript: function(data){
4470         var script = document.createElement("script");
4471         script.type = "text/javascript";
4472         script.text = data;
4473         (document.body || document.getElementsByTagName('head')[0]).appendChild(script);
4474     },
4475     hasAdapter: function(callback){
4476         return _blanket.options("adapter") !== null;
4477     },
4478     report: function(coverage_data){
4479         if (!document.getElementById("blanketLoaderDialog")){
4480             //all found, clear it
4481             _blanket.blanketSession = null;
4482         }
4483         coverage_data.files = window._$blanket;
4484         var require = blanket.options("commonJS") ? blanket._commonjs.require : window.require;
4485
4486         // Check if we have any covered files that requires reporting
4487         // otherwise just exit gracefully.
4488         if (!coverage_data.files || !Object.keys(coverage_data.files).length) {
4489             if (_blanket.options("debug")) {console.log("BLANKET-Reporting No files were instrumented.");}
4490             return;
4491         }
4492
4493         if (typeof coverage_data.files.branchFcn !== "undefined"){
4494             delete coverage_data.files.branchFcn;
4495         }
4496         if (typeof _blanket.options("reporter") === "string"){
4497             _blanket._loadFile(_blanket.options("reporter"));
4498             _blanket.customReporter(coverage_data,_blanket.options("reporter_options"));
4499         }else if (typeof _blanket.options("reporter") === "function"){
4500             _blanket.options("reporter")(coverage_data);
4501         }else if (typeof _blanket.defaultReporter === 'function'){
4502             _blanket.defaultReporter(coverage_data);
4503         }else{
4504             throw new Error("no reporter defined.");
4505         }
4506     },
4507     _bindStartTestRunner: function(bindEvent,startEvent){
4508         if (bindEvent){
4509             bindEvent(startEvent);
4510         }else{
4511             window.addEventListener("load",startEvent,false);
4512         }
4513     },
4514     _loadSourceFiles: function(callback){
4515         var require = blanket.options("commonJS") ? blanket._commonjs.require : window.require;
4516         function copy(o){
4517           var _copy = Object.create( Object.getPrototypeOf(o) );
4518           var propNames = Object.getOwnPropertyNames(o);
4519
4520           propNames.forEach(function(name){
4521             var desc = Object.getOwnPropertyDescriptor(o, name);
4522             Object.defineProperty(_copy, name, desc);
4523           });
4524
4525           return _copy;
4526         }
4527         if (_blanket.options("debug")) {console.log("BLANKET-Collecting page scripts");}
4528         var scripts = _blanket.utils.collectPageScripts();
4529         //_blanket.options("filter",scripts);
4530         if (scripts.length === 0){
4531             callback();
4532         }else{
4533
4534             //check session state
4535             if (sessionStorage["blanketSessionLoader"]){
4536                 _blanket.blanketSession = JSON.parse(sessionStorage["blanketSessionLoader"]);
4537             }
4538
4539             scripts.forEach(function(file,indx){
4540                 _blanket.utils.cache[file+".js"]={
4541                     loaded:false
4542                 };
4543             });
4544
4545             var currScript=-1;
4546             _blanket.utils.loadAll(function(test){
4547                 if (test){
4548                   return typeof scripts[currScript+1] !== 'undefined';
4549                 }
4550                 currScript++;
4551                 if (currScript >= scripts.length){
4552                   return null;
4553                 }
4554                 return scripts[currScript]+".js";
4555             },callback);
4556         }
4557     },
4558     beforeStartTestRunner: function(opts){
4559         opts = opts || {};
4560         opts.checkRequirejs = typeof opts.checkRequirejs === "undefined" ? true : opts.checkRequirejs;
4561         opts.callback = opts.callback || function() {  };
4562         opts.coverage = typeof opts.coverage === "undefined" ? true : opts.coverage;
4563         if (opts.coverage) {
4564             _blanket._bindStartTestRunner(opts.bindEvent,
4565             function(){
4566                 _blanket._loadSourceFiles(function() {
4567
4568                     var allLoaded = function(){
4569                         return opts.condition ? opts.condition() : _blanket.requireFilesLoaded();
4570                     };
4571                     var check = function() {
4572                         if (allLoaded()) {
4573                             if (_blanket.options("debug")) {console.log("BLANKET-All files loaded, init start test runner callback.");}
4574                             var cb = _blanket.options("testReadyCallback");
4575
4576                             if (cb){
4577                                 if (typeof cb === "function"){
4578                                     cb(opts.callback);
4579                                 }else if (typeof cb === "string"){
4580                                     _blanket._addScript(cb);
4581                                     opts.callback();
4582                                 }
4583                             }else{
4584                                 opts.callback();
4585                             }
4586                         } else {
4587                             setTimeout(check, 13);
4588                         }
4589                     };
4590                     check();
4591                 });
4592             });
4593         }else{
4594             opts.callback();
4595         }
4596     },
4597     utils: {
4598         qualifyURL: function (url) {
4599             //http://stackoverflow.com/questions/470832/getting-an-absolute-url-from-a-relative-one-ie6-issue
4600             var a = document.createElement('a');
4601             a.href = url;
4602             return a.href;
4603         }
4604     }
4605 });
4606
4607 })(blanket);
4608
4609 blanket.defaultReporter = function(coverage){
4610     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;}",
4611         successRate = 60,
4612         head = document.head,
4613         fileNumber = 0,
4614         body = document.body,
4615         headerContent,
4616         hasBranchTracking = Object.keys(coverage.files).some(function(elem){
4617           return typeof coverage.files[elem].branchData !== 'undefined';
4618         }),
4619         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>",
4620         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>";
4621         grandTotalTemplate = "<div class='blanket grand-total {{statusclass}}'><div class='bl-cl'>{{rowTitle}}</div><div class='bl-cl rs'>{{percentage}} %</div><div class='bl-cl rs'>{{numberCovered}}/{{totalSmts}}</div>"+( hasBranchTracking ? "<div class='bl-cl rs'>{{passedBranches}}/{{totalBranches}}</div>" : "" ) + "<div style='clear:both;'></div></div>";
4622
4623     function blanket_toggleSource(id) {
4624         var element = document.getElementById(id);
4625         if(element.style.display === 'block') {
4626             element.style.display = 'none';
4627         } else {
4628             element.style.display = 'block';
4629         }
4630     }
4631
4632
4633     var script = document.createElement("script");
4634     script.type = "text/javascript";
4635     script.text = blanket_toggleSource.toString().replace('function ' + blanket_toggleSource.name, 'function blanket_toggleSource');
4636     body.appendChild(script);
4637
4638     var percentage = function(number, total) {
4639         return (Math.round(((number/total) * 100)*100)/100);
4640     };
4641
4642     var appendTag = function (type, el, str) {
4643         var dom = document.createElement(type);
4644         dom.innerHTML = str;
4645         el.appendChild(dom);
4646     };
4647
4648     function escapeInvalidXmlChars(str) {
4649         return str.replace(/\&/g, "&amp;")
4650             .replace(/</g, "&lt;")
4651             .replace(/\>/g, "&gt;")
4652             .replace(/\"/g, "&quot;")
4653             .replace(/\'/g, "&apos;");
4654     }
4655
4656     function isBranchFollowed(data,bool){
4657         var mode = bool ? 0 : 1;
4658         if (typeof data === 'undefined' ||
4659             typeof data === null ||
4660             typeof data[mode] === 'undefined'){
4661             return false;
4662         }
4663         return data[mode].length > 0;
4664     }
4665
4666     var branchStack = [];
4667
4668     function branchReport(colsIndex,src,cols,offset,lineNum){
4669       var newsrc="";
4670        var postfix="";
4671       if (branchStack.length > 0){
4672         newsrc += "<span class='" + (isBranchFollowed(branchStack[0][1],branchStack[0][1].consequent === branchStack[0][0]) ? 'branchOkay' : 'branchWarning') + "'>";
4673         if (branchStack[0][0].end.line === lineNum){
4674           newsrc += escapeInvalidXmlChars(src.slice(0,branchStack[0][0].end.column)) + "</span>";
4675           src = src.slice(branchStack[0][0].end.column);
4676           branchStack.shift();
4677           if (branchStack.length > 0){
4678             newsrc += "<span class='" + (isBranchFollowed(branchStack[0][1],false) ? 'branchOkay' : 'branchWarning') + "'>";
4679             if (branchStack[0][0].end.line === lineNum){
4680               newsrc += escapeInvalidXmlChars(src.slice(0,branchStack[0][0].end.column)) + "</span>";
4681               src = src.slice(branchStack[0][0].end.column);
4682               branchStack.shift();
4683               if (!cols){
4684                 return {src: newsrc + escapeInvalidXmlChars(src) ,cols:cols};
4685               }
4686             }
4687             else if (!cols){
4688               return {src: newsrc + escapeInvalidXmlChars(src) + "</span>",cols:cols};
4689             }
4690             else{
4691               postfix = "</span>";
4692             }
4693           }else if (!cols){
4694             return {src: newsrc + escapeInvalidXmlChars(src) ,cols:cols};
4695           }
4696         }else if(!cols){
4697           return {src: newsrc + escapeInvalidXmlChars(src) + "</span>",cols:cols};
4698         }else{
4699           postfix = "</span>";
4700         }
4701       }
4702       var thisline = cols[colsIndex];
4703       //consequent
4704
4705       var cons = thisline.consequent;
4706       if (cons.start.line > lineNum){
4707         branchStack.unshift([thisline.alternate,thisline]);
4708         branchStack.unshift([cons,thisline]);
4709         src = escapeInvalidXmlChars(src);
4710       }else{
4711         var style = "<span class='" + (isBranchFollowed(thisline,true) ? 'branchOkay' : 'branchWarning') + "'>";
4712         newsrc += escapeInvalidXmlChars(src.slice(0,cons.start.column-offset)) + style;
4713
4714         if (cols.length > colsIndex+1 &&
4715           cols[colsIndex+1].consequent.start.line === lineNum &&
4716           cols[colsIndex+1].consequent.start.column-offset < cols[colsIndex].consequent.end.column-offset)
4717         {
4718           var res = branchReport(colsIndex+1,src.slice(cons.start.column-offset,cons.end.column-offset),cols,cons.start.column-offset,lineNum);
4719           newsrc += res.src;
4720           cols = res.cols;
4721           cols[colsIndex+1] = cols[colsIndex+2];
4722           cols.length--;
4723         }else{
4724           newsrc += escapeInvalidXmlChars(src.slice(cons.start.column-offset,cons.end.column-offset));
4725         }
4726         newsrc += "</span>";
4727
4728         var alt = thisline.alternate;
4729         if (alt.start.line > lineNum){
4730           newsrc += escapeInvalidXmlChars(src.slice(cons.end.column-offset));
4731           branchStack.unshift([alt,thisline]);
4732         }else{
4733           newsrc += escapeInvalidXmlChars(src.slice(cons.end.column-offset,alt.start.column-offset));
4734           style = "<span class='" + (isBranchFollowed(thisline,false) ? 'branchOkay' : 'branchWarning') + "'>";
4735           newsrc +=  style;
4736           if (cols.length > colsIndex+1 &&
4737             cols[colsIndex+1].consequent.start.line === lineNum &&
4738             cols[colsIndex+1].consequent.start.column-offset < cols[colsIndex].alternate.end.column-offset)
4739           {
4740             var res2 = branchReport(colsIndex+1,src.slice(alt.start.column-offset,alt.end.column-offset),cols,alt.start.column-offset,lineNum);
4741             newsrc += res2.src;
4742             cols = res2.cols;
4743             cols[colsIndex+1] = cols[colsIndex+2];
4744             cols.length--;
4745           }else{
4746             newsrc += escapeInvalidXmlChars(src.slice(alt.start.column-offset,alt.end.column-offset));
4747           }
4748           newsrc += "</span>";
4749           newsrc += escapeInvalidXmlChars(src.slice(alt.end.column-offset));
4750           src = newsrc;
4751         }
4752       }
4753       return {src:src+postfix, cols:cols};
4754     }
4755
4756     var isUndefined =  function(item){
4757             return typeof item !== 'undefined';
4758       };
4759
4760     var files = coverage.files;
4761     var totals = {
4762       totalSmts: 0,
4763       numberOfFilesCovered: 0,
4764       passedBranches: 0,
4765       totalBranches: 0,
4766       moduleTotalStatements : {},
4767       moduleTotalCoveredStatements : {},
4768       moduleTotalBranches : {},
4769       moduleTotalCoveredBranches : {}
4770     };
4771
4772     // check if a data-cover-modulepattern was provided for per-module coverage reporting
4773     var modulePattern = _blanket.options("modulePattern");
4774     var modulePatternRegex = ( modulePattern ? new RegExp(modulePattern) : null );
4775
4776     for(var file in files)
4777     {
4778         fileNumber++;
4779
4780         var statsForFile = files[file],
4781             totalSmts = 0,
4782             numberOfFilesCovered = 0,
4783             code = [],
4784             i;
4785
4786
4787         var end = [];
4788         for(i = 0; i < statsForFile.source.length; i +=1){
4789             var src = statsForFile.source[i];
4790
4791             if (branchStack.length > 0 ||
4792                 typeof statsForFile.branchData !== 'undefined')
4793             {
4794                 if (typeof statsForFile.branchData[i+1] !== 'undefined')
4795                 {
4796                   var cols = statsForFile.branchData[i+1].filter(isUndefined);
4797                   var colsIndex=0;
4798
4799
4800                   src = branchReport(colsIndex,src,cols,0,i+1).src;
4801
4802                 }else if (branchStack.length){
4803                   src = branchReport(0,src,null,0,i+1).src;
4804                 }else{
4805                   src = escapeInvalidXmlChars(src);
4806                 }
4807               }else{
4808                 src = escapeInvalidXmlChars(src);
4809               }
4810               var lineClass="";
4811               if(statsForFile[i+1]) {
4812                 numberOfFilesCovered += 1;
4813                 totalSmts += 1;
4814                 lineClass = 'hit';
4815               }else{
4816                 if(statsForFile[i+1] === 0){
4817                     totalSmts++;
4818                     lineClass = 'miss';
4819                 }
4820               }
4821               code[i + 1] = "<div class='"+lineClass+"'><span class=''>"+(i + 1)+"</span>"+src+"</div>";
4822         }
4823         totals.totalSmts += totalSmts;
4824         totals.numberOfFilesCovered += numberOfFilesCovered;
4825         var totalBranches=0;
4826         var passedBranches=0;
4827         if (typeof statsForFile.branchData !== 'undefined'){
4828           for(var j=0;j<statsForFile.branchData.length;j++){
4829             if (typeof statsForFile.branchData[j] !== 'undefined'){
4830               for(var k=0;k<statsForFile.branchData[j].length;k++){
4831                 if (typeof statsForFile.branchData[j][k] !== 'undefined'){
4832                   totalBranches++;
4833                   if (typeof statsForFile.branchData[j][k][0] !== 'undefined' &&
4834                     statsForFile.branchData[j][k][0].length > 0 &&
4835                     typeof statsForFile.branchData[j][k][1] !== 'undefined' &&
4836                     statsForFile.branchData[j][k][1].length > 0){
4837                     passedBranches++;
4838                   }
4839                 }
4840               }
4841             }
4842           }
4843         }
4844         totals.passedBranches += passedBranches;
4845         totals.totalBranches += totalBranches;
4846
4847         // if "data-cover-modulepattern" was provided,
4848         // track totals per module name as well as globally
4849         if (modulePatternRegex) {
4850             var moduleName = file.match(modulePatternRegex)[1];
4851
4852             if(!totals.moduleTotalStatements.hasOwnProperty(moduleName)) {
4853                 totals.moduleTotalStatements[moduleName] = 0;
4854                 totals.moduleTotalCoveredStatements[moduleName] = 0;
4855             }
4856
4857             totals.moduleTotalStatements[moduleName] += totalSmts;
4858             totals.moduleTotalCoveredStatements[moduleName] += numberOfFilesCovered;
4859
4860             if(!totals.moduleTotalBranches.hasOwnProperty(moduleName)) {
4861                 totals.moduleTotalBranches[moduleName] = 0;
4862                 totals.moduleTotalCoveredBranches[moduleName] = 0;
4863             }
4864
4865             totals.moduleTotalBranches[moduleName] += totalBranches;
4866             totals.moduleTotalCoveredBranches[moduleName] += passedBranches;
4867         }
4868
4869         var result = percentage(numberOfFilesCovered, totalSmts);
4870
4871         var output = fileTemplate.replace("{{file}}", file)
4872                                  .replace("{{percentage}}",result)
4873                                  .replace("{{numberCovered}}", numberOfFilesCovered)
4874                                  .replace(/\{\{fileNumber\}\}/g, fileNumber)
4875                                  .replace("{{totalSmts}}", totalSmts)
4876                                  .replace("{{totalBranches}}", totalBranches)
4877                                  .replace("{{passedBranches}}", passedBranches)
4878                                  .replace("{{source}}", code.join(" "));
4879         if(result < successRate)
4880         {
4881             output = output.replace("{{statusclass}}", "bl-error");
4882         } else {
4883             output = output.replace("{{statusclass}}", "bl-success");
4884         }
4885         bodyContent += output;
4886     }
4887
4888     // create temporary function for use by the global totals reporter,
4889     // as well as the per-module totals reporter
4890     var createAggregateTotal = function(numSt, numCov, numBranch, numCovBr, moduleName) {
4891
4892         var totalPercent = percentage(numCov, numSt);
4893         var statusClass = totalPercent < successRate ? "bl-error" : "bl-success";
4894         var rowTitle = ( moduleName ? "Total for module: " + moduleName : "Global total" );
4895         var totalsOutput = grandTotalTemplate.replace("{{rowTitle}}", rowTitle)
4896             .replace("{{percentage}}", totalPercent)
4897             .replace("{{numberCovered}}", numCov)
4898             .replace("{{totalSmts}}", numSt)
4899             .replace("{{passedBranches}}", numCovBr)
4900             .replace("{{totalBranches}}", numBranch)
4901             .replace("{{statusclass}}", statusClass);
4902
4903         bodyContent += totalsOutput;
4904     };
4905
4906     // if "data-cover-modulepattern" was provided,
4907     // output the per-module totals alongside the global totals
4908     if (modulePatternRegex) {
4909         for (var thisModuleName in totals.moduleTotalStatements) {
4910             if (totals.moduleTotalStatements.hasOwnProperty(thisModuleName)) {
4911
4912                 var moduleTotalSt = totals.moduleTotalStatements[thisModuleName];
4913                 var moduleTotalCovSt = totals.moduleTotalCoveredStatements[thisModuleName];
4914
4915                 var moduleTotalBr = totals.moduleTotalBranches[thisModuleName];
4916                 var moduleTotalCovBr = totals.moduleTotalCoveredBranches[thisModuleName];
4917
4918                 createAggregateTotal(moduleTotalSt, moduleTotalCovSt, moduleTotalBr, moduleTotalCovBr, thisModuleName);
4919             }
4920         }
4921     }
4922
4923     createAggregateTotal(totals.totalSmts, totals.numberOfFilesCovered, totals.totalBranches, totals.passedBranches, null);
4924     bodyContent += "</div>"; //closing main
4925
4926
4927     appendTag('style', head, cssSytle);
4928     //appendStyle(body, headerContent);
4929     if (document.getElementById("blanket-main")){
4930         document.getElementById("blanket-main").innerHTML=
4931             bodyContent.slice(23,-6);
4932     }else{
4933         appendTag('div', body, bodyContent);
4934     }
4935     //appendHtml(body, '</div>');
4936 };
4937
4938 (function(){
4939     var newOptions={};
4940     //http://stackoverflow.com/a/2954896
4941     var toArray =Array.prototype.slice;
4942     var scripts = toArray.call(document.scripts);
4943     toArray.call(scripts[scripts.length - 1].attributes)
4944                     .forEach(function(es){
4945                         if(es.nodeName === "data-cover-only"){
4946                             newOptions.filter = es.nodeValue;
4947                         }
4948                         if(es.nodeName === "data-cover-never"){
4949                             newOptions.antifilter = es.nodeValue;
4950                         }
4951                         if(es.nodeName === "data-cover-reporter"){
4952                             newOptions.reporter = es.nodeValue;
4953                         }
4954                         if (es.nodeName === "data-cover-adapter"){
4955                             newOptions.adapter = es.nodeValue;
4956                         }
4957                         if (es.nodeName === "data-cover-loader"){
4958                             newOptions.loader = es.nodeValue;
4959                         }
4960                         if (es.nodeName === "data-cover-timeout"){
4961                             newOptions.timeout = es.nodeValue;
4962                         }
4963                         if (es.nodeName === "data-cover-modulepattern") {
4964                             newOptions.modulePattern = es.nodeValue;
4965                         }
4966                         if (es.nodeName === "data-cover-reporter-options"){
4967                             try{
4968                                 newOptions.reporter_options = JSON.parse(es.nodeValue);
4969                             }catch(e){
4970                                 if (blanket.options("debug")){
4971                                     throw new Error("Invalid reporter options.  Must be a valid stringified JSON object.");
4972                                 }
4973                             }
4974                         }
4975                         if (es.nodeName === "data-cover-testReadyCallback"){
4976                             newOptions.testReadyCallback = es.nodeValue;
4977                         }
4978                         if (es.nodeName === "data-cover-customVariable"){
4979                             newOptions.customVariable = es.nodeValue;
4980                         }
4981                         if (es.nodeName === "data-cover-flags"){
4982                             var flags = " "+es.nodeValue+" ";
4983                             if (flags.indexOf(" ignoreError ") > -1){
4984                                 newOptions.ignoreScriptError = true;
4985                             }
4986                             if (flags.indexOf(" autoStart ") > -1){
4987                                 newOptions.autoStart = true;
4988                             }
4989                             if (flags.indexOf(" ignoreCors ") > -1){
4990                                 newOptions.ignoreCors = true;
4991                             }
4992                             if (flags.indexOf(" branchTracking ") > -1){
4993                                 newOptions.branchTracking = true;
4994                             }
4995                             if (flags.indexOf(" sourceURL ") > -1){
4996                                 newOptions.sourceURL = true;
4997                             }
4998                             if (flags.indexOf(" debug ") > -1){
4999                                 newOptions.debug = true;
5000                             }
5001                             if (flags.indexOf(" engineOnly ") > -1){
5002                                 newOptions.engineOnly = true;
5003                             }
5004                             if (flags.indexOf(" commonJS ") > -1){
5005                                 newOptions.commonJS = true;
5006                             }
5007                              if (flags.indexOf(" instrumentCache ") > -1){
5008                                 newOptions.instrumentCache = true;
5009                             }
5010                         }
5011                     });
5012     blanket.options(newOptions);
5013
5014     if (typeof requirejs !== 'undefined'){
5015         blanket.options("existingRequireJS",true);
5016     }
5017     /* setup requirejs loader, if needed */
5018
5019     if (blanket.options("commonJS")){
5020         blanket._commonjs = {};
5021     }
5022 })();
5023 (function(_blanket){
5024 _blanket.extend({
5025     utils: {
5026         normalizeBackslashes: function(str) {
5027             return str.replace(/\\/g, '/');
5028         },
5029         matchPatternAttribute: function(filename,pattern){
5030             if (typeof pattern === 'string'){
5031                 if (pattern.indexOf("[") === 0){
5032                     //treat as array
5033                     var pattenArr = pattern.slice(1,pattern.length-1).split(",");
5034                     return pattenArr.some(function(elem){
5035                         return _blanket.utils.matchPatternAttribute(filename,_blanket.utils.normalizeBackslashes(elem.slice(1,-1)));
5036                         //return filename.indexOf(_blanket.utils.normalizeBackslashes(elem.slice(1,-1))) > -1;
5037                     });
5038                 }else if ( pattern.indexOf("//") === 0){
5039                     var ex = pattern.slice(2,pattern.lastIndexOf('/'));
5040                     var mods = pattern.slice(pattern.lastIndexOf('/')+1);
5041                     var regex = new RegExp(ex,mods);
5042                     return regex.test(filename);
5043                 }else if (pattern.indexOf("#") === 0){
5044                     return window[pattern.slice(1)].call(window,filename);
5045                 }else{
5046                     return filename.indexOf(_blanket.utils.normalizeBackslashes(pattern)) > -1;
5047                 }
5048             }else if ( pattern instanceof Array ){
5049                 return pattern.some(function(elem){
5050                     return _blanket.utils.matchPatternAttribute(filename,elem);
5051                 });
5052             }else if (pattern instanceof RegExp){
5053                 return pattern.test(filename);
5054             }else if (typeof pattern === "function"){
5055                 return pattern.call(window,filename);
5056             }
5057         },
5058         blanketEval: function(data){
5059             _blanket._addScript(data);
5060         },
5061         collectPageScripts: function(){
5062             var toArray = Array.prototype.slice;
5063             var scripts = toArray.call(document.scripts);
5064             var selectedScripts=[],scriptNames=[];
5065             var filter = _blanket.options("filter");
5066             if(filter != null){
5067                 //global filter in place, data-cover-only
5068                 var antimatch = _blanket.options("antifilter");
5069                 selectedScripts = toArray.call(document.scripts)
5070                                 .filter(function(s){
5071                                     return toArray.call(s.attributes).filter(function(sn){
5072                                         return sn.nodeName === "src" && _blanket.utils.matchPatternAttribute(sn.nodeValue,filter) &&
5073                                             (typeof antimatch === "undefined" || !_blanket.utils.matchPatternAttribute(sn.nodeValue,antimatch));
5074                                     }).length === 1;
5075                                 });
5076             }else{
5077                 selectedScripts = toArray.call(document.querySelectorAll("script[data-cover]"));
5078             }
5079             scriptNames = selectedScripts.map(function(s){
5080                                     return _blanket.utils.qualifyURL(
5081                                         toArray.call(s.attributes).filter(
5082                                             function(sn){
5083                                                 return sn.nodeName === "src";
5084                                             })[0].nodeValue).replace(".js","");
5085                                     });
5086             if (!filter){
5087                 _blanket.options("filter","['"+scriptNames.join("','")+"']");
5088             }
5089             return scriptNames;
5090         },
5091         loadAll: function(nextScript,cb,preprocessor){
5092             /**
5093              * load dependencies
5094              * @param {nextScript} factory for priority level
5095              * @param {cb} the done callback
5096              */
5097             var currScript=nextScript();
5098             var isLoaded = _blanket.utils.scriptIsLoaded(
5099                                 currScript,
5100                                 _blanket.utils.ifOrdered,
5101                                 nextScript,
5102                                 cb
5103                             );
5104
5105             if (!(_blanket.utils.cache[currScript] && _blanket.utils.cache[currScript].loaded)){
5106                 var attach = function(){
5107                     if (_blanket.options("debug")) {console.log("BLANKET-Mark script:"+currScript+", as loaded and move to next script.");}
5108                     isLoaded();
5109                 };
5110                 var whenDone = function(result){
5111                     if (_blanket.options("debug")) {console.log("BLANKET-File loading finished");}
5112                     if (typeof result !== 'undefined'){
5113                         if (_blanket.options("debug")) {console.log("BLANKET-Add file to DOM.");}
5114                         _blanket._addScript(result);
5115                     }
5116                     attach();
5117                 };
5118
5119                 _blanket.utils.attachScript(
5120                     {
5121                         url: currScript
5122                     },
5123                     function (content){
5124                         _blanket.utils.processFile(
5125                             content,
5126                             currScript,
5127                             whenDone,
5128                             whenDone
5129                         );
5130                     }
5131                 );
5132             }else{
5133                 isLoaded();
5134             }
5135         },
5136         attachScript: function(options,cb){
5137            var timeout = _blanket.options("timeout") || 3000;
5138            setTimeout(function(){
5139                 if (!_blanket.utils.cache[options.url].loaded){
5140                     throw new Error("error loading source script");
5141                 }
5142            },timeout);
5143            _blanket.utils.getFile(
5144                 options.url,
5145                 cb,
5146                 function(){ throw new Error("error loading source script");}
5147             );
5148         },
5149         ifOrdered: function(nextScript,cb){
5150             /**
5151              * ordered loading callback
5152              * @param {nextScript} factory for priority level
5153              * @param {cb} the done callback
5154              */
5155             var currScript = nextScript(true);
5156             if (currScript){
5157               _blanket.utils.loadAll(nextScript,cb);
5158             }else{
5159               cb(new Error("Error in loading chain."));
5160             }
5161         },
5162         scriptIsLoaded: function(url,orderedCb,nextScript,cb){
5163             /**
5164            * returns a callback that checks a loading list to see if a script is loaded.
5165            * @param {orderedCb} callback if ordered loading is being done
5166            * @param {nextScript} factory for next priority level
5167            * @param {cb} the done callback
5168            */
5169            if (_blanket.options("debug")) {console.log("BLANKET-Returning function");}
5170             return function(){
5171                 if (_blanket.options("debug")) {console.log("BLANKET-Marking file as loaded: "+url);}
5172
5173                 _blanket.utils.cache[url].loaded=true;
5174
5175                 if (_blanket.utils.allLoaded()){
5176                     if (_blanket.options("debug")) {console.log("BLANKET-All files loaded");}
5177                     cb();
5178                 }else if (orderedCb){
5179                     //if it's ordered we need to
5180                     //traverse down to the next
5181                     //priority level
5182                     if (_blanket.options("debug")) {console.log("BLANKET-Load next file.");}
5183                     orderedCb(nextScript,cb);
5184                 }
5185             };
5186         },
5187         cache: {},
5188         allLoaded: function (){
5189             /**
5190              * check if depdencies are loaded in cache
5191              */
5192             var cached = Object.keys(_blanket.utils.cache);
5193             for (var i=0;i<cached.length;i++){
5194                 if (!_blanket.utils.cache[cached[i]].loaded){
5195                     return false;
5196                 }
5197             }
5198             return true;
5199         },
5200         processFile: function (content,url,cb,oldCb) {
5201             var match = _blanket.options("filter");
5202             //we check the never matches first
5203             var antimatch = _blanket.options("antifilter");
5204             if (typeof antimatch !== "undefined" &&
5205                     _blanket.utils.matchPatternAttribute(url.replace(/\.js$/,""),antimatch)
5206                 ){
5207                 oldCb(content);
5208                 if (_blanket.options("debug")) {console.log("BLANKET-File will never be instrumented:"+url);}
5209                 _blanket.requiringFile(url,true);
5210             }else if (_blanket.utils.matchPatternAttribute(url.replace(/\.js$/,""),match)){
5211                 if (_blanket.options("debug")) {console.log("BLANKET-Attempting instrument of:"+url);}
5212                 _blanket.instrument({
5213                     inputFile: content,
5214                     inputFileName: url
5215                 },function(instrumented){
5216                     try{
5217                         if (_blanket.options("debug")) {console.log("BLANKET-instrument of:"+url+" was successfull.");}
5218                         _blanket.utils.blanketEval(instrumented);
5219                         cb();
5220                         _blanket.requiringFile(url,true);
5221                     }
5222                     catch(err){
5223                         if (_blanket.options("ignoreScriptError")){
5224                             //we can continue like normal if
5225                             //we're ignoring script errors,
5226                             //but otherwise we don't want
5227                             //to completeLoad or the error might be
5228                             //missed.
5229                             if (_blanket.options("debug")) { console.log("BLANKET-There was an error loading the file:"+url); }
5230                             cb(content);
5231                             _blanket.requiringFile(url,true);
5232                         }else{
5233                             throw new Error("Error parsing instrumented code: "+err);
5234                         }
5235                     }
5236                 });
5237             }else{
5238                 if (_blanket.options("debug")) { console.log("BLANKET-Loading (without instrumenting) the file:"+url);}
5239                 oldCb(content);
5240                 _blanket.requiringFile(url,true);
5241             }
5242
5243         },
5244         createXhr: function(){
5245             var xhr, i, progId;
5246             if (typeof XMLHttpRequest !== "undefined") {
5247                 return new XMLHttpRequest();
5248             } else if (typeof ActiveXObject !== "undefined") {
5249                 for (i = 0; i < 3; i += 1) {
5250                     progId = progIds[i];
5251                     try {
5252                         xhr = new ActiveXObject(progId);
5253                     } catch (e) {}
5254
5255                     if (xhr) {
5256                         progIds = [progId];  // so faster next time
5257                         break;
5258                     }
5259                 }
5260             }
5261
5262             return xhr;
5263         },
5264         getFile: function(url, callback, errback, onXhr){
5265             var foundInSession = false;
5266             if (_blanket.blanketSession){
5267                 var files = Object.keys(_blanket.blanketSession);
5268                 for (var i=0; i<files.length;i++ ){
5269                     var key = files[i];
5270                     if (url.indexOf(key) > -1){
5271                         callback(_blanket.blanketSession[key]);
5272                         foundInSession=true;
5273                         return;
5274                     }
5275                 }
5276             }
5277             if (!foundInSession){
5278                 var xhr = _blanket.utils.createXhr();
5279                 xhr.open('GET', url, true);
5280
5281                 //Allow overrides specified in config
5282                 if (onXhr) {
5283                     onXhr(xhr, url);
5284                 }
5285
5286                 xhr.onreadystatechange = function (evt) {
5287                     var status, err;
5288
5289                     //Do not explicitly handle errors, those should be
5290                     //visible via console output in the browser.
5291                     if (xhr.readyState === 4) {
5292                         status = xhr.status;
5293                         if ((status > 399 && status < 600) /*||
5294                             (status === 0 &&
5295                                 navigator.userAgent.toLowerCase().indexOf('firefox') > -1)
5296                            */ ) {
5297                             //An http 4xx or 5xx error. Signal an error.
5298                             err = new Error(url + ' HTTP status: ' + status);
5299                             err.xhr = xhr;
5300                             errback(err);
5301                         } else {
5302                             callback(xhr.responseText);
5303                         }
5304                     }
5305                 };
5306                 try{
5307                     xhr.send(null);
5308                 }catch(e){
5309                     if (e.code && (e.code === 101 || e.code === 1012) && _blanket.options("ignoreCors") === false){
5310                         //running locally and getting error from browser
5311                         _blanket.showManualLoader();
5312                     } else {
5313                         throw e;
5314                     }
5315                 }
5316             }
5317         }
5318     }
5319 });
5320
5321 (function(){
5322     var require = blanket.options("commonJS") ? blanket._commonjs.require : window.require;
5323     var requirejs = blanket.options("commonJS") ? blanket._commonjs.requirejs : window.requirejs;
5324     if (!_blanket.options("engineOnly") && _blanket.options("existingRequireJS")){
5325
5326         _blanket.utils.oldloader = requirejs.load;
5327
5328         requirejs.load = function (context, moduleName, url) {
5329             _blanket.requiringFile(url);
5330             _blanket.utils.getFile(url,
5331                 function(content){
5332                     _blanket.utils.processFile(
5333                         content,
5334                         url,
5335                         function newLoader(){
5336                             context.completeLoad(moduleName);
5337                         },
5338                         function oldLoader(){
5339                             _blanket.utils.oldloader(context, moduleName, url);
5340                         }
5341                     );
5342                 }, function (err) {
5343                 _blanket.requiringFile();
5344                 throw err;
5345             });
5346         };
5347     }
5348 })();
5349
5350 })(blanket);