/*! blanket - v1.1.5 */ if (typeof QUnit !== 'undefined'){ QUnit.config.autostart = false; } (function(define){ /* Copyright (C) 2012 Ariya Hidayat Copyright (C) 2012 Mathias Bynens Copyright (C) 2012 Joost-Wim Boekesteijn Copyright (C) 2012 Kris Kowal Copyright (C) 2012 Yusuke Suzuki Copyright (C) 2012 Arpad Borsos Copyright (C) 2011 Ariya Hidayat Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /*jslint bitwise:true plusplus:true */ /*global esprima:true, define:true, exports:true, window: true, throwError: true, createLiteral: true, generateStatement: true, parseAssignmentExpression: true, parseBlock: true, parseExpression: true, parseFunctionDeclaration: true, parseFunctionExpression: true, parseFunctionSourceElements: true, parseVariableIdentifier: true, parseLeftHandSideExpression: true, parseStatement: true, parseSourceElement: true */ (function (root, factory) { 'use strict'; // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js, // Rhino, and plain browser loading. if (typeof define === 'function' && define.amd) { define(['exports'], factory); } else if (typeof exports !== 'undefined') { factory(exports); } else { factory((root.esprima = {})); } }(this, function (exports) { 'use strict'; var Token, TokenName, Syntax, PropertyKind, Messages, Regex, source, strict, index, lineNumber, lineStart, length, buffer, state, extra; Token = { BooleanLiteral: 1, EOF: 2, Identifier: 3, Keyword: 4, NullLiteral: 5, NumericLiteral: 6, Punctuator: 7, StringLiteral: 8 }; TokenName = {}; TokenName[Token.BooleanLiteral] = 'Boolean'; TokenName[Token.EOF] = ''; TokenName[Token.Identifier] = 'Identifier'; TokenName[Token.Keyword] = 'Keyword'; TokenName[Token.NullLiteral] = 'Null'; TokenName[Token.NumericLiteral] = 'Numeric'; TokenName[Token.Punctuator] = 'Punctuator'; TokenName[Token.StringLiteral] = 'String'; Syntax = { AssignmentExpression: 'AssignmentExpression', ArrayExpression: 'ArrayExpression', BlockStatement: 'BlockStatement', BinaryExpression: 'BinaryExpression', BreakStatement: 'BreakStatement', CallExpression: 'CallExpression', CatchClause: 'CatchClause', ConditionalExpression: 'ConditionalExpression', ContinueStatement: 'ContinueStatement', DoWhileStatement: 'DoWhileStatement', DebuggerStatement: 'DebuggerStatement', EmptyStatement: 'EmptyStatement', ExpressionStatement: 'ExpressionStatement', ForStatement: 'ForStatement', ForInStatement: 'ForInStatement', FunctionDeclaration: 'FunctionDeclaration', FunctionExpression: 'FunctionExpression', Identifier: 'Identifier', IfStatement: 'IfStatement', Literal: 'Literal', LabeledStatement: 'LabeledStatement', LogicalExpression: 'LogicalExpression', MemberExpression: 'MemberExpression', NewExpression: 'NewExpression', ObjectExpression: 'ObjectExpression', Program: 'Program', Property: 'Property', ReturnStatement: 'ReturnStatement', SequenceExpression: 'SequenceExpression', SwitchStatement: 'SwitchStatement', SwitchCase: 'SwitchCase', ThisExpression: 'ThisExpression', ThrowStatement: 'ThrowStatement', TryStatement: 'TryStatement', UnaryExpression: 'UnaryExpression', UpdateExpression: 'UpdateExpression', VariableDeclaration: 'VariableDeclaration', VariableDeclarator: 'VariableDeclarator', WhileStatement: 'WhileStatement', WithStatement: 'WithStatement' }; PropertyKind = { Data: 1, Get: 2, Set: 4 }; // Error messages should be identical to V8. Messages = { UnexpectedToken: 'Unexpected token %0', UnexpectedNumber: 'Unexpected number', UnexpectedString: 'Unexpected string', UnexpectedIdentifier: 'Unexpected identifier', UnexpectedReserved: 'Unexpected reserved word', UnexpectedEOS: 'Unexpected end of input', NewlineAfterThrow: 'Illegal newline after throw', InvalidRegExp: 'Invalid regular expression', UnterminatedRegExp: 'Invalid regular expression: missing /', InvalidLHSInAssignment: 'Invalid left-hand side in assignment', InvalidLHSInForIn: 'Invalid left-hand side in for-in', MultipleDefaultsInSwitch: 'More than one default clause in switch statement', NoCatchOrFinally: 'Missing catch or finally after try', UnknownLabel: 'Undefined label \'%0\'', Redeclaration: '%0 \'%1\' has already been declared', IllegalContinue: 'Illegal continue statement', IllegalBreak: 'Illegal break statement', IllegalReturn: 'Illegal return statement', StrictModeWith: 'Strict mode code may not include a with statement', StrictCatchVariable: 'Catch variable may not be eval or arguments in strict mode', StrictVarName: 'Variable name may not be eval or arguments in strict mode', StrictParamName: 'Parameter name eval or arguments is not allowed in strict mode', StrictParamDupe: 'Strict mode function may not have duplicate parameter names', StrictFunctionName: 'Function name may not be eval or arguments in strict mode', StrictOctalLiteral: 'Octal literals are not allowed in strict mode.', StrictDelete: 'Delete of an unqualified identifier in strict mode.', StrictDuplicateProperty: 'Duplicate data property in object literal not allowed in strict mode', AccessorDataProperty: 'Object literal may not have data and accessor property with the same name', AccessorGetSet: 'Object literal may not have multiple get/set accessors with the same name', StrictLHSAssignment: 'Assignment to eval or arguments is not allowed in strict mode', StrictLHSPostfix: 'Postfix increment/decrement may not have eval or arguments operand in strict mode', StrictLHSPrefix: 'Prefix increment/decrement may not have eval or arguments operand in strict mode', StrictReservedWord: 'Use of future reserved word in strict mode' }; // See also tools/generate-unicode-regex.py. Regex = { 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]'), 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]') }; // Ensure the condition is true, otherwise throw an error. // This is only to have a better contract semantic, i.e. another safety net // to catch a logic error. The condition shall be fulfilled in normal case. // Do NOT use this to enforce a certain condition on any user input. function assert(condition, message) { if (!condition) { throw new Error('ASSERT: ' + message); } } function sliceSource(from, to) { return source.slice(from, to); } if (typeof 'esprima'[0] === 'undefined') { sliceSource = function sliceArraySource(from, to) { return source.slice(from, to).join(''); }; } function isDecimalDigit(ch) { return '0123456789'.indexOf(ch) >= 0; } function isHexDigit(ch) { return '0123456789abcdefABCDEF'.indexOf(ch) >= 0; } function isOctalDigit(ch) { return '01234567'.indexOf(ch) >= 0; } // 7.2 White Space function isWhiteSpace(ch) { return (ch === ' ') || (ch === '\u0009') || (ch === '\u000B') || (ch === '\u000C') || (ch === '\u00A0') || (ch.charCodeAt(0) >= 0x1680 && '\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\uFEFF'.indexOf(ch) >= 0); } // 7.3 Line Terminators function isLineTerminator(ch) { return (ch === '\n' || ch === '\r' || ch === '\u2028' || ch === '\u2029'); } // 7.6 Identifier Names and Identifiers function isIdentifierStart(ch) { return (ch === '$') || (ch === '_') || (ch === '\\') || (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ((ch.charCodeAt(0) >= 0x80) && Regex.NonAsciiIdentifierStart.test(ch)); } function isIdentifierPart(ch) { return (ch === '$') || (ch === '_') || (ch === '\\') || (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ((ch >= '0') && (ch <= '9')) || ((ch.charCodeAt(0) >= 0x80) && Regex.NonAsciiIdentifierPart.test(ch)); } // 7.6.1.2 Future Reserved Words function isFutureReservedWord(id) { switch (id) { // Future reserved words. case 'class': case 'enum': case 'export': case 'extends': case 'import': case 'super': return true; } return false; } function isStrictModeReservedWord(id) { switch (id) { // Strict Mode reserved words. case 'implements': case 'interface': case 'package': case 'private': case 'protected': case 'public': case 'static': case 'yield': case 'let': return true; } return false; } function isRestrictedWord(id) { return id === 'eval' || id === 'arguments'; } // 7.6.1.1 Keywords function isKeyword(id) { var keyword = false; switch (id.length) { case 2: keyword = (id === 'if') || (id === 'in') || (id === 'do'); break; case 3: keyword = (id === 'var') || (id === 'for') || (id === 'new') || (id === 'try'); break; case 4: keyword = (id === 'this') || (id === 'else') || (id === 'case') || (id === 'void') || (id === 'with'); break; case 5: keyword = (id === 'while') || (id === 'break') || (id === 'catch') || (id === 'throw'); break; case 6: keyword = (id === 'return') || (id === 'typeof') || (id === 'delete') || (id === 'switch'); break; case 7: keyword = (id === 'default') || (id === 'finally'); break; case 8: keyword = (id === 'function') || (id === 'continue') || (id === 'debugger'); break; case 10: keyword = (id === 'instanceof'); break; } if (keyword) { return true; } switch (id) { // Future reserved words. // 'const' is specialized as Keyword in V8. case 'const': return true; // For compatiblity to SpiderMonkey and ES.next case 'yield': case 'let': return true; } if (strict && isStrictModeReservedWord(id)) { return true; } return isFutureReservedWord(id); } // 7.4 Comments function skipComment() { var ch, blockComment, lineComment; blockComment = false; lineComment = false; while (index < length) { ch = source[index]; if (lineComment) { ch = source[index++]; if (isLineTerminator(ch)) { lineComment = false; if (ch === '\r' && source[index] === '\n') { ++index; } ++lineNumber; lineStart = index; } } else if (blockComment) { if (isLineTerminator(ch)) { if (ch === '\r' && source[index + 1] === '\n') { ++index; } ++lineNumber; ++index; lineStart = index; if (index >= length) { throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); } } else { ch = source[index++]; if (index >= length) { throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); } if (ch === '*') { ch = source[index]; if (ch === '/') { ++index; blockComment = false; } } } } else if (ch === '/') { ch = source[index + 1]; if (ch === '/') { index += 2; lineComment = true; } else if (ch === '*') { index += 2; blockComment = true; if (index >= length) { throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); } } else { break; } } else if (isWhiteSpace(ch)) { ++index; } else if (isLineTerminator(ch)) { ++index; if (ch === '\r' && source[index] === '\n') { ++index; } ++lineNumber; lineStart = index; } else { break; } } } function scanHexEscape(prefix) { var i, len, ch, code = 0; len = (prefix === 'u') ? 4 : 2; for (i = 0; i < len; ++i) { if (index < length && isHexDigit(source[index])) { ch = source[index++]; code = code * 16 + '0123456789abcdef'.indexOf(ch.toLowerCase()); } else { return ''; } } return String.fromCharCode(code); } function scanIdentifier() { var ch, start, id, restore; ch = source[index]; if (!isIdentifierStart(ch)) { return; } start = index; if (ch === '\\') { ++index; if (source[index] !== 'u') { return; } ++index; restore = index; ch = scanHexEscape('u'); if (ch) { if (ch === '\\' || !isIdentifierStart(ch)) { return; } id = ch; } else { index = restore; id = 'u'; } } else { id = source[index++]; } while (index < length) { ch = source[index]; if (!isIdentifierPart(ch)) { break; } if (ch === '\\') { ++index; if (source[index] !== 'u') { return; } ++index; restore = index; ch = scanHexEscape('u'); if (ch) { if (ch === '\\' || !isIdentifierPart(ch)) { return; } id += ch; } else { index = restore; id += 'u'; } } else { id += source[index++]; } } // There is no keyword or literal with only one character. // Thus, it must be an identifier. if (id.length === 1) { return { type: Token.Identifier, value: id, lineNumber: lineNumber, lineStart: lineStart, range: [start, index] }; } if (isKeyword(id)) { return { type: Token.Keyword, value: id, lineNumber: lineNumber, lineStart: lineStart, range: [start, index] }; } // 7.8.1 Null Literals if (id === 'null') { return { type: Token.NullLiteral, value: id, lineNumber: lineNumber, lineStart: lineStart, range: [start, index] }; } // 7.8.2 Boolean Literals if (id === 'true' || id === 'false') { return { type: Token.BooleanLiteral, value: id, lineNumber: lineNumber, lineStart: lineStart, range: [start, index] }; } return { type: Token.Identifier, value: id, lineNumber: lineNumber, lineStart: lineStart, range: [start, index] }; } // 7.7 Punctuators function scanPunctuator() { var start = index, ch1 = source[index], ch2, ch3, ch4; // Check for most common single-character punctuators. if (ch1 === ';' || ch1 === '{' || ch1 === '}') { ++index; return { type: Token.Punctuator, value: ch1, lineNumber: lineNumber, lineStart: lineStart, range: [start, index] }; } if (ch1 === ',' || ch1 === '(' || ch1 === ')') { ++index; return { type: Token.Punctuator, value: ch1, lineNumber: lineNumber, lineStart: lineStart, range: [start, index] }; } // Dot (.) can also start a floating-point number, hence the need // to check the next character. ch2 = source[index + 1]; if (ch1 === '.' && !isDecimalDigit(ch2)) { return { type: Token.Punctuator, value: source[index++], lineNumber: lineNumber, lineStart: lineStart, range: [start, index] }; } // Peek more characters. ch3 = source[index + 2]; ch4 = source[index + 3]; // 4-character punctuator: >>>= if (ch1 === '>' && ch2 === '>' && ch3 === '>') { if (ch4 === '=') { index += 4; return { type: Token.Punctuator, value: '>>>=', lineNumber: lineNumber, lineStart: lineStart, range: [start, index] }; } } // 3-character punctuators: === !== >>> <<= >>= if (ch1 === '=' && ch2 === '=' && ch3 === '=') { index += 3; return { type: Token.Punctuator, value: '===', lineNumber: lineNumber, lineStart: lineStart, range: [start, index] }; } if (ch1 === '!' && ch2 === '=' && ch3 === '=') { index += 3; return { type: Token.Punctuator, value: '!==', lineNumber: lineNumber, lineStart: lineStart, range: [start, index] }; } if (ch1 === '>' && ch2 === '>' && ch3 === '>') { index += 3; return { type: Token.Punctuator, value: '>>>', lineNumber: lineNumber, lineStart: lineStart, range: [start, index] }; } if (ch1 === '<' && ch2 === '<' && ch3 === '=') { index += 3; return { type: Token.Punctuator, value: '<<=', lineNumber: lineNumber, lineStart: lineStart, range: [start, index] }; } if (ch1 === '>' && ch2 === '>' && ch3 === '=') { index += 3; return { type: Token.Punctuator, value: '>>=', lineNumber: lineNumber, lineStart: lineStart, range: [start, index] }; } // 2-character punctuators: <= >= == != ++ -- << >> && || // += -= *= %= &= |= ^= /= if (ch2 === '=') { if ('<>=!+-*%&|^/'.indexOf(ch1) >= 0) { index += 2; return { type: Token.Punctuator, value: ch1 + ch2, lineNumber: lineNumber, lineStart: lineStart, range: [start, index] }; } } if (ch1 === ch2 && ('+-<>&|'.indexOf(ch1) >= 0)) { if ('+-<>&|'.indexOf(ch2) >= 0) { index += 2; return { type: Token.Punctuator, value: ch1 + ch2, lineNumber: lineNumber, lineStart: lineStart, range: [start, index] }; } } // The remaining 1-character punctuators. if ('[]<>+-*%&|^!~?:=/'.indexOf(ch1) >= 0) { return { type: Token.Punctuator, value: source[index++], lineNumber: lineNumber, lineStart: lineStart, range: [start, index] }; } } // 7.8.3 Numeric Literals function scanNumericLiteral() { var number, start, ch; ch = source[index]; assert(isDecimalDigit(ch) || (ch === '.'), 'Numeric literal must start with a decimal digit or a decimal point'); start = index; number = ''; if (ch !== '.') { number = source[index++]; ch = source[index]; // Hex number starts with '0x'. // Octal number starts with '0'. if (number === '0') { if (ch === 'x' || ch === 'X') { number += source[index++]; while (index < length) { ch = source[index]; if (!isHexDigit(ch)) { break; } number += source[index++]; } if (number.length <= 2) { // only 0x throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); } if (index < length) { ch = source[index]; if (isIdentifierStart(ch)) { throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); } } return { type: Token.NumericLiteral, value: parseInt(number, 16), lineNumber: lineNumber, lineStart: lineStart, range: [start, index] }; } else if (isOctalDigit(ch)) { number += source[index++]; while (index < length) { ch = source[index]; if (!isOctalDigit(ch)) { break; } number += source[index++]; } if (index < length) { ch = source[index]; if (isIdentifierStart(ch) || isDecimalDigit(ch)) { throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); } } return { type: Token.NumericLiteral, value: parseInt(number, 8), octal: true, lineNumber: lineNumber, lineStart: lineStart, range: [start, index] }; } // decimal number starts with '0' such as '09' is illegal. if (isDecimalDigit(ch)) { throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); } } while (index < length) { ch = source[index]; if (!isDecimalDigit(ch)) { break; } number += source[index++]; } } if (ch === '.') { number += source[index++]; while (index < length) { ch = source[index]; if (!isDecimalDigit(ch)) { break; } number += source[index++]; } } if (ch === 'e' || ch === 'E') { number += source[index++]; ch = source[index]; if (ch === '+' || ch === '-') { number += source[index++]; } ch = source[index]; if (isDecimalDigit(ch)) { number += source[index++]; while (index < length) { ch = source[index]; if (!isDecimalDigit(ch)) { break; } number += source[index++]; } } else { ch = 'character ' + ch; if (index >= length) { ch = ''; } throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); } } if (index < length) { ch = source[index]; if (isIdentifierStart(ch)) { throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); } } return { type: Token.NumericLiteral, value: parseFloat(number), lineNumber: lineNumber, lineStart: lineStart, range: [start, index] }; } // 7.8.4 String Literals function scanStringLiteral() { var str = '', quote, start, ch, code, unescaped, restore, octal = false; quote = source[index]; assert((quote === '\'' || quote === '"'), 'String literal must starts with a quote'); start = index; ++index; while (index < length) { ch = source[index++]; if (ch === quote) { quote = ''; break; } else if (ch === '\\') { ch = source[index++]; if (!isLineTerminator(ch)) { switch (ch) { case 'n': str += '\n'; break; case 'r': str += '\r'; break; case 't': str += '\t'; break; case 'u': case 'x': restore = index; unescaped = scanHexEscape(ch); if (unescaped) { str += unescaped; } else { index = restore; str += ch; } break; case 'b': str += '\b'; break; case 'f': str += '\f'; break; case 'v': str += '\v'; break; default: if (isOctalDigit(ch)) { code = '01234567'.indexOf(ch); // \0 is not octal escape sequence if (code !== 0) { octal = true; } if (index < length && isOctalDigit(source[index])) { octal = true; code = code * 8 + '01234567'.indexOf(source[index++]); // 3 digits are only allowed when string starts // with 0, 1, 2, 3 if ('0123'.indexOf(ch) >= 0 && index < length && isOctalDigit(source[index])) { code = code * 8 + '01234567'.indexOf(source[index++]); } } str += String.fromCharCode(code); } else { str += ch; } break; } } else { ++lineNumber; if (ch === '\r' && source[index] === '\n') { ++index; } } } else if (isLineTerminator(ch)) { break; } else { str += ch; } } if (quote !== '') { throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); } return { type: Token.StringLiteral, value: str, octal: octal, lineNumber: lineNumber, lineStart: lineStart, range: [start, index] }; } function scanRegExp() { var str, ch, start, pattern, flags, value, classMarker = false, restore, terminated = false; buffer = null; skipComment(); start = index; ch = source[index]; assert(ch === '/', 'Regular expression literal must start with a slash'); str = source[index++]; while (index < length) { ch = source[index++]; str += ch; if (classMarker) { if (ch === ']') { classMarker = false; } } else { if (ch === '\\') { ch = source[index++]; // ECMA-262 7.8.5 if (isLineTerminator(ch)) { throwError({}, Messages.UnterminatedRegExp); } str += ch; } else if (ch === '/') { terminated = true; break; } else if (ch === '[') { classMarker = true; } else if (isLineTerminator(ch)) { throwError({}, Messages.UnterminatedRegExp); } } } if (!terminated) { throwError({}, Messages.UnterminatedRegExp); } // Exclude leading and trailing slash. pattern = str.substr(1, str.length - 2); flags = ''; while (index < length) { ch = source[index]; if (!isIdentifierPart(ch)) { break; } ++index; if (ch === '\\' && index < length) { ch = source[index]; if (ch === 'u') { ++index; restore = index; ch = scanHexEscape('u'); if (ch) { flags += ch; str += '\\u'; for (; restore < index; ++restore) { str += source[restore]; } } else { index = restore; flags += 'u'; str += '\\u'; } } else { str += '\\'; } } else { flags += ch; str += ch; } } try { value = new RegExp(pattern, flags); } catch (e) { throwError({}, Messages.InvalidRegExp); } return { literal: str, value: value, range: [start, index] }; } function isIdentifierName(token) { return token.type === Token.Identifier || token.type === Token.Keyword || token.type === Token.BooleanLiteral || token.type === Token.NullLiteral; } function advance() { var ch, token; skipComment(); if (index >= length) { return { type: Token.EOF, lineNumber: lineNumber, lineStart: lineStart, range: [index, index] }; } token = scanPunctuator(); if (typeof token !== 'undefined') { return token; } ch = source[index]; if (ch === '\'' || ch === '"') { return scanStringLiteral(); } if (ch === '.' || isDecimalDigit(ch)) { return scanNumericLiteral(); } token = scanIdentifier(); if (typeof token !== 'undefined') { return token; } throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); } function lex() { var token; if (buffer) { index = buffer.range[1]; lineNumber = buffer.lineNumber; lineStart = buffer.lineStart; token = buffer; buffer = null; return token; } buffer = null; return advance(); } function lookahead() { var pos, line, start; if (buffer !== null) { return buffer; } pos = index; line = lineNumber; start = lineStart; buffer = advance(); index = pos; lineNumber = line; lineStart = start; return buffer; } // Return true if there is a line terminator before the next token. function peekLineTerminator() { var pos, line, start, found; pos = index; line = lineNumber; start = lineStart; skipComment(); found = lineNumber !== line; index = pos; lineNumber = line; lineStart = start; return found; } // Throw an exception function throwError(token, messageFormat) { var error, args = Array.prototype.slice.call(arguments, 2), msg = messageFormat.replace( /%(\d)/g, function (whole, index) { return args[index] || ''; } ); if (typeof token.lineNumber === 'number') { error = new Error('Line ' + token.lineNumber + ': ' + msg); error.index = token.range[0]; error.lineNumber = token.lineNumber; error.column = token.range[0] - lineStart + 1; } else { error = new Error('Line ' + lineNumber + ': ' + msg); error.index = index; error.lineNumber = lineNumber; error.column = index - lineStart + 1; } throw error; } function throwErrorTolerant() { try { throwError.apply(null, arguments); } catch (e) { if (extra.errors) { extra.errors.push(e); } else { throw e; } } } // Throw an exception because of the token. function throwUnexpected(token) { if (token.type === Token.EOF) { throwError(token, Messages.UnexpectedEOS); } if (token.type === Token.NumericLiteral) { throwError(token, Messages.UnexpectedNumber); } if (token.type === Token.StringLiteral) { throwError(token, Messages.UnexpectedString); } if (token.type === Token.Identifier) { throwError(token, Messages.UnexpectedIdentifier); } if (token.type === Token.Keyword) { if (isFutureReservedWord(token.value)) { throwError(token, Messages.UnexpectedReserved); } else if (strict && isStrictModeReservedWord(token.value)) { throwErrorTolerant(token, Messages.StrictReservedWord); return; } throwError(token, Messages.UnexpectedToken, token.value); } // BooleanLiteral, NullLiteral, or Punctuator. throwError(token, Messages.UnexpectedToken, token.value); } // Expect the next token to match the specified punctuator. // If not, an exception will be thrown. function expect(value) { var token = lex(); if (token.type !== Token.Punctuator || token.value !== value) { throwUnexpected(token); } } // Expect the next token to match the specified keyword. // If not, an exception will be thrown. function expectKeyword(keyword) { var token = lex(); if (token.type !== Token.Keyword || token.value !== keyword) { throwUnexpected(token); } } // Return true if the next token matches the specified punctuator. function match(value) { var token = lookahead(); return token.type === Token.Punctuator && token.value === value; } // Return true if the next token matches the specified keyword function matchKeyword(keyword) { var token = lookahead(); return token.type === Token.Keyword && token.value === keyword; } // Return true if the next token is an assignment operator function matchAssign() { var token = lookahead(), op = token.value; if (token.type !== Token.Punctuator) { return false; } return op === '=' || op === '*=' || op === '/=' || op === '%=' || op === '+=' || op === '-=' || op === '<<=' || op === '>>=' || op === '>>>=' || op === '&=' || op === '^=' || op === '|='; } function consumeSemicolon() { var token, line; // Catch the very common case first. if (source[index] === ';') { lex(); return; } line = lineNumber; skipComment(); if (lineNumber !== line) { return; } if (match(';')) { lex(); return; } token = lookahead(); if (token.type !== Token.EOF && !match('}')) { throwUnexpected(token); } } // Return true if provided expression is LeftHandSideExpression function isLeftHandSide(expr) { return expr.type === Syntax.Identifier || expr.type === Syntax.MemberExpression; } // 11.1.4 Array Initialiser function parseArrayInitialiser() { var elements = []; expect('['); while (!match(']')) { if (match(',')) { lex(); elements.push(null); } else { elements.push(parseAssignmentExpression()); if (!match(']')) { expect(','); } } } expect(']'); return { type: Syntax.ArrayExpression, elements: elements }; } // 11.1.5 Object Initialiser function parsePropertyFunction(param, first) { var previousStrict, body; previousStrict = strict; body = parseFunctionSourceElements(); if (first && strict && isRestrictedWord(param[0].name)) { throwErrorTolerant(first, Messages.StrictParamName); } strict = previousStrict; return { type: Syntax.FunctionExpression, id: null, params: param, defaults: [], body: body, rest: null, generator: false, expression: false }; } function parseObjectPropertyKey() { var token = lex(); // Note: This function is called only from parseObjectProperty(), where // EOF and Punctuator tokens are already filtered out. if (token.type === Token.StringLiteral || token.type === Token.NumericLiteral) { if (strict && token.octal) { throwErrorTolerant(token, Messages.StrictOctalLiteral); } return createLiteral(token); } return { type: Syntax.Identifier, name: token.value }; } function parseObjectProperty() { var token, key, id, param; token = lookahead(); if (token.type === Token.Identifier) { id = parseObjectPropertyKey(); // Property Assignment: Getter and Setter. if (token.value === 'get' && !match(':')) { key = parseObjectPropertyKey(); expect('('); expect(')'); return { type: Syntax.Property, key: key, value: parsePropertyFunction([]), kind: 'get' }; } else if (token.value === 'set' && !match(':')) { key = parseObjectPropertyKey(); expect('('); token = lookahead(); if (token.type !== Token.Identifier) { throwUnexpected(lex()); } param = [ parseVariableIdentifier() ]; expect(')'); return { type: Syntax.Property, key: key, value: parsePropertyFunction(param, token), kind: 'set' }; } else { expect(':'); return { type: Syntax.Property, key: id, value: parseAssignmentExpression(), kind: 'init' }; } } else if (token.type === Token.EOF || token.type === Token.Punctuator) { throwUnexpected(token); } else { key = parseObjectPropertyKey(); expect(':'); return { type: Syntax.Property, key: key, value: parseAssignmentExpression(), kind: 'init' }; } } function parseObjectInitialiser() { var properties = [], property, name, kind, map = {}, toString = String; expect('{'); while (!match('}')) { property = parseObjectProperty(); if (property.key.type === Syntax.Identifier) { name = property.key.name; } else { name = toString(property.key.value); } kind = (property.kind === 'init') ? PropertyKind.Data : (property.kind === 'get') ? PropertyKind.Get : PropertyKind.Set; if (Object.prototype.hasOwnProperty.call(map, name)) { if (map[name] === PropertyKind.Data) { if (strict && kind === PropertyKind.Data) { throwErrorTolerant({}, Messages.StrictDuplicateProperty); } else if (kind !== PropertyKind.Data) { throwErrorTolerant({}, Messages.AccessorDataProperty); } } else { if (kind === PropertyKind.Data) { throwErrorTolerant({}, Messages.AccessorDataProperty); } else if (map[name] & kind) { throwErrorTolerant({}, Messages.AccessorGetSet); } } map[name] |= kind; } else { map[name] = kind; } properties.push(property); if (!match('}')) { expect(','); } } expect('}'); return { type: Syntax.ObjectExpression, properties: properties }; } // 11.1.6 The Grouping Operator function parseGroupExpression() { var expr; expect('('); expr = parseExpression(); expect(')'); return expr; } // 11.1 Primary Expressions function parsePrimaryExpression() { var token = lookahead(), type = token.type; if (type === Token.Identifier) { return { type: Syntax.Identifier, name: lex().value }; } if (type === Token.StringLiteral || type === Token.NumericLiteral) { if (strict && token.octal) { throwErrorTolerant(token, Messages.StrictOctalLiteral); } return createLiteral(lex()); } if (type === Token.Keyword) { if (matchKeyword('this')) { lex(); return { type: Syntax.ThisExpression }; } if (matchKeyword('function')) { return parseFunctionExpression(); } } if (type === Token.BooleanLiteral) { lex(); token.value = (token.value === 'true'); return createLiteral(token); } if (type === Token.NullLiteral) { lex(); token.value = null; return createLiteral(token); } if (match('[')) { return parseArrayInitialiser(); } if (match('{')) { return parseObjectInitialiser(); } if (match('(')) { return parseGroupExpression(); } if (match('/') || match('/=')) { return createLiteral(scanRegExp()); } return throwUnexpected(lex()); } // 11.2 Left-Hand-Side Expressions function parseArguments() { var args = []; expect('('); if (!match(')')) { while (index < length) { args.push(parseAssignmentExpression()); if (match(')')) { break; } expect(','); } } expect(')'); return args; } function parseNonComputedProperty() { var token = lex(); if (!isIdentifierName(token)) { throwUnexpected(token); } return { type: Syntax.Identifier, name: token.value }; } function parseNonComputedMember() { expect('.'); return parseNonComputedProperty(); } function parseComputedMember() { var expr; expect('['); expr = parseExpression(); expect(']'); return expr; } function parseNewExpression() { var expr; expectKeyword('new'); expr = { type: Syntax.NewExpression, callee: parseLeftHandSideExpression(), 'arguments': [] }; if (match('(')) { expr['arguments'] = parseArguments(); } return expr; } function parseLeftHandSideExpressionAllowCall() { var expr; expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression(); while (match('.') || match('[') || match('(')) { if (match('(')) { expr = { type: Syntax.CallExpression, callee: expr, 'arguments': parseArguments() }; } else if (match('[')) { expr = { type: Syntax.MemberExpression, computed: true, object: expr, property: parseComputedMember() }; } else { expr = { type: Syntax.MemberExpression, computed: false, object: expr, property: parseNonComputedMember() }; } } return expr; } function parseLeftHandSideExpression() { var expr; expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression(); while (match('.') || match('[')) { if (match('[')) { expr = { type: Syntax.MemberExpression, computed: true, object: expr, property: parseComputedMember() }; } else { expr = { type: Syntax.MemberExpression, computed: false, object: expr, property: parseNonComputedMember() }; } } return expr; } // 11.3 Postfix Expressions function parsePostfixExpression() { var expr = parseLeftHandSideExpressionAllowCall(), token; token = lookahead(); if (token.type !== Token.Punctuator) { return expr; } if ((match('++') || match('--')) && !peekLineTerminator()) { // 11.3.1, 11.3.2 if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) { throwErrorTolerant({}, Messages.StrictLHSPostfix); } if (!isLeftHandSide(expr)) { throwError({}, Messages.InvalidLHSInAssignment); } expr = { type: Syntax.UpdateExpression, operator: lex().value, argument: expr, prefix: false }; } return expr; } // 11.4 Unary Operators function parseUnaryExpression() { var token, expr; token = lookahead(); if (token.type !== Token.Punctuator && token.type !== Token.Keyword) { return parsePostfixExpression(); } if (match('++') || match('--')) { token = lex(); expr = parseUnaryExpression(); // 11.4.4, 11.4.5 if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) { throwErrorTolerant({}, Messages.StrictLHSPrefix); } if (!isLeftHandSide(expr)) { throwError({}, Messages.InvalidLHSInAssignment); } expr = { type: Syntax.UpdateExpression, operator: token.value, argument: expr, prefix: true }; return expr; } if (match('+') || match('-') || match('~') || match('!')) { expr = { type: Syntax.UnaryExpression, operator: lex().value, argument: parseUnaryExpression() }; return expr; } if (matchKeyword('delete') || matchKeyword('void') || matchKeyword('typeof')) { expr = { type: Syntax.UnaryExpression, operator: lex().value, argument: parseUnaryExpression() }; if (strict && expr.operator === 'delete' && expr.argument.type === Syntax.Identifier) { throwErrorTolerant({}, Messages.StrictDelete); } return expr; } return parsePostfixExpression(); } // 11.5 Multiplicative Operators function parseMultiplicativeExpression() { var expr = parseUnaryExpression(); while (match('*') || match('/') || match('%')) { expr = { type: Syntax.BinaryExpression, operator: lex().value, left: expr, right: parseUnaryExpression() }; } return expr; } // 11.6 Additive Operators function parseAdditiveExpression() { var expr = parseMultiplicativeExpression(); while (match('+') || match('-')) { expr = { type: Syntax.BinaryExpression, operator: lex().value, left: expr, right: parseMultiplicativeExpression() }; } return expr; } // 11.7 Bitwise Shift Operators function parseShiftExpression() { var expr = parseAdditiveExpression(); while (match('<<') || match('>>') || match('>>>')) { expr = { type: Syntax.BinaryExpression, operator: lex().value, left: expr, right: parseAdditiveExpression() }; } return expr; } // 11.8 Relational Operators function parseRelationalExpression() { var expr, previousAllowIn; previousAllowIn = state.allowIn; state.allowIn = true; expr = parseShiftExpression(); while (match('<') || match('>') || match('<=') || match('>=') || (previousAllowIn && matchKeyword('in')) || matchKeyword('instanceof')) { expr = { type: Syntax.BinaryExpression, operator: lex().value, left: expr, right: parseShiftExpression() }; } state.allowIn = previousAllowIn; return expr; } // 11.9 Equality Operators function parseEqualityExpression() { var expr = parseRelationalExpression(); while (match('==') || match('!=') || match('===') || match('!==')) { expr = { type: Syntax.BinaryExpression, operator: lex().value, left: expr, right: parseRelationalExpression() }; } return expr; } // 11.10 Binary Bitwise Operators function parseBitwiseANDExpression() { var expr = parseEqualityExpression(); while (match('&')) { lex(); expr = { type: Syntax.BinaryExpression, operator: '&', left: expr, right: parseEqualityExpression() }; } return expr; } function parseBitwiseXORExpression() { var expr = parseBitwiseANDExpression(); while (match('^')) { lex(); expr = { type: Syntax.BinaryExpression, operator: '^', left: expr, right: parseBitwiseANDExpression() }; } return expr; } function parseBitwiseORExpression() { var expr = parseBitwiseXORExpression(); while (match('|')) { lex(); expr = { type: Syntax.BinaryExpression, operator: '|', left: expr, right: parseBitwiseXORExpression() }; } return expr; } // 11.11 Binary Logical Operators function parseLogicalANDExpression() { var expr = parseBitwiseORExpression(); while (match('&&')) { lex(); expr = { type: Syntax.LogicalExpression, operator: '&&', left: expr, right: parseBitwiseORExpression() }; } return expr; } function parseLogicalORExpression() { var expr = parseLogicalANDExpression(); while (match('||')) { lex(); expr = { type: Syntax.LogicalExpression, operator: '||', left: expr, right: parseLogicalANDExpression() }; } return expr; } // 11.12 Conditional Operator function parseConditionalExpression() { var expr, previousAllowIn, consequent; expr = parseLogicalORExpression(); if (match('?')) { lex(); previousAllowIn = state.allowIn; state.allowIn = true; consequent = parseAssignmentExpression(); state.allowIn = previousAllowIn; expect(':'); expr = { type: Syntax.ConditionalExpression, test: expr, consequent: consequent, alternate: parseAssignmentExpression() }; } return expr; } // 11.13 Assignment Operators function parseAssignmentExpression() { var token, expr; token = lookahead(); expr = parseConditionalExpression(); if (matchAssign()) { // LeftHandSideExpression if (!isLeftHandSide(expr)) { throwError({}, Messages.InvalidLHSInAssignment); } // 11.13.1 if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) { throwErrorTolerant(token, Messages.StrictLHSAssignment); } expr = { type: Syntax.AssignmentExpression, operator: lex().value, left: expr, right: parseAssignmentExpression() }; } return expr; } // 11.14 Comma Operator function parseExpression() { var expr = parseAssignmentExpression(); if (match(',')) { expr = { type: Syntax.SequenceExpression, expressions: [ expr ] }; while (index < length) { if (!match(',')) { break; } lex(); expr.expressions.push(parseAssignmentExpression()); } } return expr; } // 12.1 Block function parseStatementList() { var list = [], statement; while (index < length) { if (match('}')) { break; } statement = parseSourceElement(); if (typeof statement === 'undefined') { break; } list.push(statement); } return list; } function parseBlock() { var block; expect('{'); block = parseStatementList(); expect('}'); return { type: Syntax.BlockStatement, body: block }; } // 12.2 Variable Statement function parseVariableIdentifier() { var token = lex(); if (token.type !== Token.Identifier) { throwUnexpected(token); } return { type: Syntax.Identifier, name: token.value }; } function parseVariableDeclaration(kind) { var id = parseVariableIdentifier(), init = null; // 12.2.1 if (strict && isRestrictedWord(id.name)) { throwErrorTolerant({}, Messages.StrictVarName); } if (kind === 'const') { expect('='); init = parseAssignmentExpression(); } else if (match('=')) { lex(); init = parseAssignmentExpression(); } return { type: Syntax.VariableDeclarator, id: id, init: init }; } function parseVariableDeclarationList(kind) { var list = []; while (index < length) { list.push(parseVariableDeclaration(kind)); if (!match(',')) { break; } lex(); } return list; } function parseVariableStatement() { var declarations; expectKeyword('var'); declarations = parseVariableDeclarationList(); consumeSemicolon(); return { type: Syntax.VariableDeclaration, declarations: declarations, kind: 'var' }; } // kind may be `const` or `let` // Both are experimental and not in the specification yet. // see http://wiki.ecmascript.org/doku.php?id=harmony:const // and http://wiki.ecmascript.org/doku.php?id=harmony:let function parseConstLetDeclaration(kind) { var declarations; expectKeyword(kind); declarations = parseVariableDeclarationList(kind); consumeSemicolon(); return { type: Syntax.VariableDeclaration, declarations: declarations, kind: kind }; } // 12.3 Empty Statement function parseEmptyStatement() { expect(';'); return { type: Syntax.EmptyStatement }; } // 12.4 Expression Statement function parseExpressionStatement() { var expr = parseExpression(); consumeSemicolon(); return { type: Syntax.ExpressionStatement, expression: expr }; } // 12.5 If statement function parseIfStatement() { var test, consequent, alternate; expectKeyword('if'); expect('('); test = parseExpression(); expect(')'); consequent = parseStatement(); if (matchKeyword('else')) { lex(); alternate = parseStatement(); } else { alternate = null; } return { type: Syntax.IfStatement, test: test, consequent: consequent, alternate: alternate }; } // 12.6 Iteration Statements function parseDoWhileStatement() { var body, test, oldInIteration; expectKeyword('do'); oldInIteration = state.inIteration; state.inIteration = true; body = parseStatement(); state.inIteration = oldInIteration; expectKeyword('while'); expect('('); test = parseExpression(); expect(')'); if (match(';')) { lex(); } return { type: Syntax.DoWhileStatement, body: body, test: test }; } function parseWhileStatement() { var test, body, oldInIteration; expectKeyword('while'); expect('('); test = parseExpression(); expect(')'); oldInIteration = state.inIteration; state.inIteration = true; body = parseStatement(); state.inIteration = oldInIteration; return { type: Syntax.WhileStatement, test: test, body: body }; } function parseForVariableDeclaration() { var token = lex(); return { type: Syntax.VariableDeclaration, declarations: parseVariableDeclarationList(), kind: token.value }; } function parseForStatement() { var init, test, update, left, right, body, oldInIteration; init = test = update = null; expectKeyword('for'); expect('('); if (match(';')) { lex(); } else { if (matchKeyword('var') || matchKeyword('let')) { state.allowIn = false; init = parseForVariableDeclaration(); state.allowIn = true; if (init.declarations.length === 1 && matchKeyword('in')) { lex(); left = init; right = parseExpression(); init = null; } } else { state.allowIn = false; init = parseExpression(); state.allowIn = true; if (matchKeyword('in')) { // LeftHandSideExpression if (!isLeftHandSide(init)) { throwError({}, Messages.InvalidLHSInForIn); } lex(); left = init; right = parseExpression(); init = null; } } if (typeof left === 'undefined') { expect(';'); } } if (typeof left === 'undefined') { if (!match(';')) { test = parseExpression(); } expect(';'); if (!match(')')) { update = parseExpression(); } } expect(')'); oldInIteration = state.inIteration; state.inIteration = true; body = parseStatement(); state.inIteration = oldInIteration; if (typeof left === 'undefined') { return { type: Syntax.ForStatement, init: init, test: test, update: update, body: body }; } return { type: Syntax.ForInStatement, left: left, right: right, body: body, each: false }; } // 12.7 The continue statement function parseContinueStatement() { var token, label = null; expectKeyword('continue'); // Optimize the most common form: 'continue;'. if (source[index] === ';') { lex(); if (!state.inIteration) { throwError({}, Messages.IllegalContinue); } return { type: Syntax.ContinueStatement, label: null }; } if (peekLineTerminator()) { if (!state.inIteration) { throwError({}, Messages.IllegalContinue); } return { type: Syntax.ContinueStatement, label: null }; } token = lookahead(); if (token.type === Token.Identifier) { label = parseVariableIdentifier(); if (!Object.prototype.hasOwnProperty.call(state.labelSet, label.name)) { throwError({}, Messages.UnknownLabel, label.name); } } consumeSemicolon(); if (label === null && !state.inIteration) { throwError({}, Messages.IllegalContinue); } return { type: Syntax.ContinueStatement, label: label }; } // 12.8 The break statement function parseBreakStatement() { var token, label = null; expectKeyword('break'); // Optimize the most common form: 'break;'. if (source[index] === ';') { lex(); if (!(state.inIteration || state.inSwitch)) { throwError({}, Messages.IllegalBreak); } return { type: Syntax.BreakStatement, label: null }; } if (peekLineTerminator()) { if (!(state.inIteration || state.inSwitch)) { throwError({}, Messages.IllegalBreak); } return { type: Syntax.BreakStatement, label: null }; } token = lookahead(); if (token.type === Token.Identifier) { label = parseVariableIdentifier(); if (!Object.prototype.hasOwnProperty.call(state.labelSet, label.name)) { throwError({}, Messages.UnknownLabel, label.name); } } consumeSemicolon(); if (label === null && !(state.inIteration || state.inSwitch)) { throwError({}, Messages.IllegalBreak); } return { type: Syntax.BreakStatement, label: label }; } // 12.9 The return statement function parseReturnStatement() { var token, argument = null; expectKeyword('return'); if (!state.inFunctionBody) { throwErrorTolerant({}, Messages.IllegalReturn); } // 'return' followed by a space and an identifier is very common. if (source[index] === ' ') { if (isIdentifierStart(source[index + 1])) { argument = parseExpression(); consumeSemicolon(); return { type: Syntax.ReturnStatement, argument: argument }; } } if (peekLineTerminator()) { return { type: Syntax.ReturnStatement, argument: null }; } if (!match(';')) { token = lookahead(); if (!match('}') && token.type !== Token.EOF) { argument = parseExpression(); } } consumeSemicolon(); return { type: Syntax.ReturnStatement, argument: argument }; } // 12.10 The with statement function parseWithStatement() { var object, body; if (strict) { throwErrorTolerant({}, Messages.StrictModeWith); } expectKeyword('with'); expect('('); object = parseExpression(); expect(')'); body = parseStatement(); return { type: Syntax.WithStatement, object: object, body: body }; } // 12.10 The swith statement function parseSwitchCase() { var test, consequent = [], statement; if (matchKeyword('default')) { lex(); test = null; } else { expectKeyword('case'); test = parseExpression(); } expect(':'); while (index < length) { if (match('}') || matchKeyword('default') || matchKeyword('case')) { break; } statement = parseStatement(); if (typeof statement === 'undefined') { break; } consequent.push(statement); } return { type: Syntax.SwitchCase, test: test, consequent: consequent }; } function parseSwitchStatement() { var discriminant, cases, clause, oldInSwitch, defaultFound; expectKeyword('switch'); expect('('); discriminant = parseExpression(); expect(')'); expect('{'); if (match('}')) { lex(); return { type: Syntax.SwitchStatement, discriminant: discriminant }; } cases = []; oldInSwitch = state.inSwitch; state.inSwitch = true; defaultFound = false; while (index < length) { if (match('}')) { break; } clause = parseSwitchCase(); if (clause.test === null) { if (defaultFound) { throwError({}, Messages.MultipleDefaultsInSwitch); } defaultFound = true; } cases.push(clause); } state.inSwitch = oldInSwitch; expect('}'); return { type: Syntax.SwitchStatement, discriminant: discriminant, cases: cases }; } // 12.13 The throw statement function parseThrowStatement() { var argument; expectKeyword('throw'); if (peekLineTerminator()) { throwError({}, Messages.NewlineAfterThrow); } argument = parseExpression(); consumeSemicolon(); return { type: Syntax.ThrowStatement, argument: argument }; } // 12.14 The try statement function parseCatchClause() { var param; expectKeyword('catch'); expect('('); if (!match(')')) { param = parseExpression(); // 12.14.1 if (strict && param.type === Syntax.Identifier && isRestrictedWord(param.name)) { throwErrorTolerant({}, Messages.StrictCatchVariable); } } expect(')'); return { type: Syntax.CatchClause, param: param, body: parseBlock() }; } function parseTryStatement() { var block, handlers = [], finalizer = null; expectKeyword('try'); block = parseBlock(); if (matchKeyword('catch')) { handlers.push(parseCatchClause()); } if (matchKeyword('finally')) { lex(); finalizer = parseBlock(); } if (handlers.length === 0 && !finalizer) { throwError({}, Messages.NoCatchOrFinally); } return { type: Syntax.TryStatement, block: block, guardedHandlers: [], handlers: handlers, finalizer: finalizer }; } // 12.15 The debugger statement function parseDebuggerStatement() { expectKeyword('debugger'); consumeSemicolon(); return { type: Syntax.DebuggerStatement }; } // 12 Statements function parseStatement() { var token = lookahead(), expr, labeledBody; if (token.type === Token.EOF) { throwUnexpected(token); } if (token.type === Token.Punctuator) { switch (token.value) { case ';': return parseEmptyStatement(); case '{': return parseBlock(); case '(': return parseExpressionStatement(); default: break; } } if (token.type === Token.Keyword) { switch (token.value) { case 'break': return parseBreakStatement(); case 'continue': return parseContinueStatement(); case 'debugger': return parseDebuggerStatement(); case 'do': return parseDoWhileStatement(); case 'for': return parseForStatement(); case 'function': return parseFunctionDeclaration(); case 'if': return parseIfStatement(); case 'return': return parseReturnStatement(); case 'switch': return parseSwitchStatement(); case 'throw': return parseThrowStatement(); case 'try': return parseTryStatement(); case 'var': return parseVariableStatement(); case 'while': return parseWhileStatement(); case 'with': return parseWithStatement(); default: break; } } expr = parseExpression(); // 12.12 Labelled Statements if ((expr.type === Syntax.Identifier) && match(':')) { lex(); if (Object.prototype.hasOwnProperty.call(state.labelSet, expr.name)) { throwError({}, Messages.Redeclaration, 'Label', expr.name); } state.labelSet[expr.name] = true; labeledBody = parseStatement(); delete state.labelSet[expr.name]; return { type: Syntax.LabeledStatement, label: expr, body: labeledBody }; } consumeSemicolon(); return { type: Syntax.ExpressionStatement, expression: expr }; } // 13 Function Definition function parseFunctionSourceElements() { var sourceElement, sourceElements = [], token, directive, firstRestricted, oldLabelSet, oldInIteration, oldInSwitch, oldInFunctionBody; expect('{'); while (index < length) { token = lookahead(); if (token.type !== Token.StringLiteral) { break; } sourceElement = parseSourceElement(); sourceElements.push(sourceElement); if (sourceElement.expression.type !== Syntax.Literal) { // this is not directive break; } directive = sliceSource(token.range[0] + 1, token.range[1] - 1); if (directive === 'use strict') { strict = true; if (firstRestricted) { throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral); } } else { if (!firstRestricted && token.octal) { firstRestricted = token; } } } oldLabelSet = state.labelSet; oldInIteration = state.inIteration; oldInSwitch = state.inSwitch; oldInFunctionBody = state.inFunctionBody; state.labelSet = {}; state.inIteration = false; state.inSwitch = false; state.inFunctionBody = true; while (index < length) { if (match('}')) { break; } sourceElement = parseSourceElement(); if (typeof sourceElement === 'undefined') { break; } sourceElements.push(sourceElement); } expect('}'); state.labelSet = oldLabelSet; state.inIteration = oldInIteration; state.inSwitch = oldInSwitch; state.inFunctionBody = oldInFunctionBody; return { type: Syntax.BlockStatement, body: sourceElements }; } function parseFunctionDeclaration() { var id, param, params = [], body, token, stricted, firstRestricted, message, previousStrict, paramSet; expectKeyword('function'); token = lookahead(); id = parseVariableIdentifier(); if (strict) { if (isRestrictedWord(token.value)) { throwErrorTolerant(token, Messages.StrictFunctionName); } } else { if (isRestrictedWord(token.value)) { firstRestricted = token; message = Messages.StrictFunctionName; } else if (isStrictModeReservedWord(token.value)) { firstRestricted = token; message = Messages.StrictReservedWord; } } expect('('); if (!match(')')) { paramSet = {}; while (index < length) { token = lookahead(); param = parseVariableIdentifier(); if (strict) { if (isRestrictedWord(token.value)) { stricted = token; message = Messages.StrictParamName; } if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) { stricted = token; message = Messages.StrictParamDupe; } } else if (!firstRestricted) { if (isRestrictedWord(token.value)) { firstRestricted = token; message = Messages.StrictParamName; } else if (isStrictModeReservedWord(token.value)) { firstRestricted = token; message = Messages.StrictReservedWord; } else if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) { firstRestricted = token; message = Messages.StrictParamDupe; } } params.push(param); paramSet[param.name] = true; if (match(')')) { break; } expect(','); } } expect(')'); previousStrict = strict; body = parseFunctionSourceElements(); if (strict && firstRestricted) { throwError(firstRestricted, message); } if (strict && stricted) { throwErrorTolerant(stricted, message); } strict = previousStrict; return { type: Syntax.FunctionDeclaration, id: id, params: params, defaults: [], body: body, rest: null, generator: false, expression: false }; } function parseFunctionExpression() { var token, id = null, stricted, firstRestricted, message, param, params = [], body, previousStrict, paramSet; expectKeyword('function'); if (!match('(')) { token = lookahead(); id = parseVariableIdentifier(); if (strict) { if (isRestrictedWord(token.value)) { throwErrorTolerant(token, Messages.StrictFunctionName); } } else { if (isRestrictedWord(token.value)) { firstRestricted = token; message = Messages.StrictFunctionName; } else if (isStrictModeReservedWord(token.value)) { firstRestricted = token; message = Messages.StrictReservedWord; } } } expect('('); if (!match(')')) { paramSet = {}; while (index < length) { token = lookahead(); param = parseVariableIdentifier(); if (strict) { if (isRestrictedWord(token.value)) { stricted = token; message = Messages.StrictParamName; } if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) { stricted = token; message = Messages.StrictParamDupe; } } else if (!firstRestricted) { if (isRestrictedWord(token.value)) { firstRestricted = token; message = Messages.StrictParamName; } else if (isStrictModeReservedWord(token.value)) { firstRestricted = token; message = Messages.StrictReservedWord; } else if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) { firstRestricted = token; message = Messages.StrictParamDupe; } } params.push(param); paramSet[param.name] = true; if (match(')')) { break; } expect(','); } } expect(')'); previousStrict = strict; body = parseFunctionSourceElements(); if (strict && firstRestricted) { throwError(firstRestricted, message); } if (strict && stricted) { throwErrorTolerant(stricted, message); } strict = previousStrict; return { type: Syntax.FunctionExpression, id: id, params: params, defaults: [], body: body, rest: null, generator: false, expression: false }; } // 14 Program function parseSourceElement() { var token = lookahead(); if (token.type === Token.Keyword) { switch (token.value) { case 'const': case 'let': return parseConstLetDeclaration(token.value); case 'function': return parseFunctionDeclaration(); default: return parseStatement(); } } if (token.type !== Token.EOF) { return parseStatement(); } } function parseSourceElements() { var sourceElement, sourceElements = [], token, directive, firstRestricted; while (index < length) { token = lookahead(); if (token.type !== Token.StringLiteral) { break; } sourceElement = parseSourceElement(); sourceElements.push(sourceElement); if (sourceElement.expression.type !== Syntax.Literal) { // this is not directive break; } directive = sliceSource(token.range[0] + 1, token.range[1] - 1); if (directive === 'use strict') { strict = true; if (firstRestricted) { throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral); } } else { if (!firstRestricted && token.octal) { firstRestricted = token; } } } while (index < length) { sourceElement = parseSourceElement(); if (typeof sourceElement === 'undefined') { break; } sourceElements.push(sourceElement); } return sourceElements; } function parseProgram() { var program; strict = false; program = { type: Syntax.Program, body: parseSourceElements() }; return program; } // The following functions are needed only when the option to preserve // the comments is active. function addComment(type, value, start, end, loc) { assert(typeof start === 'number', 'Comment must have valid position'); // Because the way the actual token is scanned, often the comments // (if any) are skipped twice during the lexical analysis. // Thus, we need to skip adding a comment if the comment array already // handled it. if (extra.comments.length > 0) { if (extra.comments[extra.comments.length - 1].range[1] > start) { return; } } extra.comments.push({ type: type, value: value, range: [start, end], loc: loc }); } function scanComment() { var comment, ch, loc, start, blockComment, lineComment; comment = ''; blockComment = false; lineComment = false; while (index < length) { ch = source[index]; if (lineComment) { ch = source[index++]; if (isLineTerminator(ch)) { loc.end = { line: lineNumber, column: index - lineStart - 1 }; lineComment = false; addComment('Line', comment, start, index - 1, loc); if (ch === '\r' && source[index] === '\n') { ++index; } ++lineNumber; lineStart = index; comment = ''; } else if (index >= length) { lineComment = false; comment += ch; loc.end = { line: lineNumber, column: length - lineStart }; addComment('Line', comment, start, length, loc); } else { comment += ch; } } else if (blockComment) { if (isLineTerminator(ch)) { if (ch === '\r' && source[index + 1] === '\n') { ++index; comment += '\r\n'; } else { comment += ch; } ++lineNumber; ++index; lineStart = index; if (index >= length) { throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); } } else { ch = source[index++]; if (index >= length) { throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); } comment += ch; if (ch === '*') { ch = source[index]; if (ch === '/') { comment = comment.substr(0, comment.length - 1); blockComment = false; ++index; loc.end = { line: lineNumber, column: index - lineStart }; addComment('Block', comment, start, index, loc); comment = ''; } } } } else if (ch === '/') { ch = source[index + 1]; if (ch === '/') { loc = { start: { line: lineNumber, column: index - lineStart } }; start = index; index += 2; lineComment = true; if (index >= length) { loc.end = { line: lineNumber, column: index - lineStart }; lineComment = false; addComment('Line', comment, start, index, loc); } } else if (ch === '*') { start = index; index += 2; blockComment = true; loc = { start: { line: lineNumber, column: index - lineStart - 2 } }; if (index >= length) { throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); } } else { break; } } else if (isWhiteSpace(ch)) { ++index; } else if (isLineTerminator(ch)) { ++index; if (ch === '\r' && source[index] === '\n') { ++index; } ++lineNumber; lineStart = index; } else { break; } } } function filterCommentLocation() { var i, entry, comment, comments = []; for (i = 0; i < extra.comments.length; ++i) { entry = extra.comments[i]; comment = { type: entry.type, value: entry.value }; if (extra.range) { comment.range = entry.range; } if (extra.loc) { comment.loc = entry.loc; } comments.push(comment); } extra.comments = comments; } function collectToken() { var start, loc, token, range, value; skipComment(); start = index; loc = { start: { line: lineNumber, column: index - lineStart } }; token = extra.advance(); loc.end = { line: lineNumber, column: index - lineStart }; if (token.type !== Token.EOF) { range = [token.range[0], token.range[1]]; value = sliceSource(token.range[0], token.range[1]); extra.tokens.push({ type: TokenName[token.type], value: value, range: range, loc: loc }); } return token; } function collectRegex() { var pos, loc, regex, token; skipComment(); pos = index; loc = { start: { line: lineNumber, column: index - lineStart } }; regex = extra.scanRegExp(); loc.end = { line: lineNumber, column: index - lineStart }; // Pop the previous token, which is likely '/' or '/=' if (extra.tokens.length > 0) { token = extra.tokens[extra.tokens.length - 1]; if (token.range[0] === pos && token.type === 'Punctuator') { if (token.value === '/' || token.value === '/=') { extra.tokens.pop(); } } } extra.tokens.push({ type: 'RegularExpression', value: regex.literal, range: [pos, index], loc: loc }); return regex; } function filterTokenLocation() { var i, entry, token, tokens = []; for (i = 0; i < extra.tokens.length; ++i) { entry = extra.tokens[i]; token = { type: entry.type, value: entry.value }; if (extra.range) { token.range = entry.range; } if (extra.loc) { token.loc = entry.loc; } tokens.push(token); } extra.tokens = tokens; } function createLiteral(token) { return { type: Syntax.Literal, value: token.value }; } function createRawLiteral(token) { return { type: Syntax.Literal, value: token.value, raw: sliceSource(token.range[0], token.range[1]) }; } function createLocationMarker() { var marker = {}; marker.range = [index, index]; marker.loc = { start: { line: lineNumber, column: index - lineStart }, end: { line: lineNumber, column: index - lineStart } }; marker.end = function () { this.range[1] = index; this.loc.end.line = lineNumber; this.loc.end.column = index - lineStart; }; marker.applyGroup = function (node) { if (extra.range) { node.groupRange = [this.range[0], this.range[1]]; } if (extra.loc) { node.groupLoc = { start: { line: this.loc.start.line, column: this.loc.start.column }, end: { line: this.loc.end.line, column: this.loc.end.column } }; } }; marker.apply = function (node) { if (extra.range) { node.range = [this.range[0], this.range[1]]; } if (extra.loc) { node.loc = { start: { line: this.loc.start.line, column: this.loc.start.column }, end: { line: this.loc.end.line, column: this.loc.end.column } }; } }; return marker; } function trackGroupExpression() { var marker, expr; skipComment(); marker = createLocationMarker(); expect('('); expr = parseExpression(); expect(')'); marker.end(); marker.applyGroup(expr); return expr; } function trackLeftHandSideExpression() { var marker, expr; skipComment(); marker = createLocationMarker(); expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression(); while (match('.') || match('[')) { if (match('[')) { expr = { type: Syntax.MemberExpression, computed: true, object: expr, property: parseComputedMember() }; marker.end(); marker.apply(expr); } else { expr = { type: Syntax.MemberExpression, computed: false, object: expr, property: parseNonComputedMember() }; marker.end(); marker.apply(expr); } } return expr; } function trackLeftHandSideExpressionAllowCall() { var marker, expr; skipComment(); marker = createLocationMarker(); expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression(); while (match('.') || match('[') || match('(')) { if (match('(')) { expr = { type: Syntax.CallExpression, callee: expr, 'arguments': parseArguments() }; marker.end(); marker.apply(expr); } else if (match('[')) { expr = { type: Syntax.MemberExpression, computed: true, object: expr, property: parseComputedMember() }; marker.end(); marker.apply(expr); } else { expr = { type: Syntax.MemberExpression, computed: false, object: expr, property: parseNonComputedMember() }; marker.end(); marker.apply(expr); } } return expr; } function filterGroup(node) { var n, i, entry; n = (Object.prototype.toString.apply(node) === '[object Array]') ? [] : {}; for (i in node) { if (node.hasOwnProperty(i) && i !== 'groupRange' && i !== 'groupLoc') { entry = node[i]; if (entry === null || typeof entry !== 'object' || entry instanceof RegExp) { n[i] = entry; } else { n[i] = filterGroup(entry); } } } return n; } function wrapTrackingFunction(range, loc) { return function (parseFunction) { function isBinary(node) { return node.type === Syntax.LogicalExpression || node.type === Syntax.BinaryExpression; } function visit(node) { var start, end; if (isBinary(node.left)) { visit(node.left); } if (isBinary(node.right)) { visit(node.right); } if (range) { if (node.left.groupRange || node.right.groupRange) { start = node.left.groupRange ? node.left.groupRange[0] : node.left.range[0]; end = node.right.groupRange ? node.right.groupRange[1] : node.right.range[1]; node.range = [start, end]; } else if (typeof node.range === 'undefined') { start = node.left.range[0]; end = node.right.range[1]; node.range = [start, end]; } } if (loc) { if (node.left.groupLoc || node.right.groupLoc) { start = node.left.groupLoc ? node.left.groupLoc.start : node.left.loc.start; end = node.right.groupLoc ? node.right.groupLoc.end : node.right.loc.end; node.loc = { start: start, end: end }; } else if (typeof node.loc === 'undefined') { node.loc = { start: node.left.loc.start, end: node.right.loc.end }; } } } return function () { var marker, node; skipComment(); marker = createLocationMarker(); node = parseFunction.apply(null, arguments); marker.end(); if (range && typeof node.range === 'undefined') { marker.apply(node); } if (loc && typeof node.loc === 'undefined') { marker.apply(node); } if (isBinary(node)) { visit(node); } return node; }; }; } function patch() { var wrapTracking; if (extra.comments) { extra.skipComment = skipComment; skipComment = scanComment; } if (extra.raw) { extra.createLiteral = createLiteral; createLiteral = createRawLiteral; } if (extra.range || extra.loc) { extra.parseGroupExpression = parseGroupExpression; extra.parseLeftHandSideExpression = parseLeftHandSideExpression; extra.parseLeftHandSideExpressionAllowCall = parseLeftHandSideExpressionAllowCall; parseGroupExpression = trackGroupExpression; parseLeftHandSideExpression = trackLeftHandSideExpression; parseLeftHandSideExpressionAllowCall = trackLeftHandSideExpressionAllowCall; wrapTracking = wrapTrackingFunction(extra.range, extra.loc); extra.parseAdditiveExpression = parseAdditiveExpression; extra.parseAssignmentExpression = parseAssignmentExpression; extra.parseBitwiseANDExpression = parseBitwiseANDExpression; extra.parseBitwiseORExpression = parseBitwiseORExpression; extra.parseBitwiseXORExpression = parseBitwiseXORExpression; extra.parseBlock = parseBlock; extra.parseFunctionSourceElements = parseFunctionSourceElements; extra.parseCatchClause = parseCatchClause; extra.parseComputedMember = parseComputedMember; extra.parseConditionalExpression = parseConditionalExpression; extra.parseConstLetDeclaration = parseConstLetDeclaration; extra.parseEqualityExpression = parseEqualityExpression; extra.parseExpression = parseExpression; extra.parseForVariableDeclaration = parseForVariableDeclaration; extra.parseFunctionDeclaration = parseFunctionDeclaration; extra.parseFunctionExpression = parseFunctionExpression; extra.parseLogicalANDExpression = parseLogicalANDExpression; extra.parseLogicalORExpression = parseLogicalORExpression; extra.parseMultiplicativeExpression = parseMultiplicativeExpression; extra.parseNewExpression = parseNewExpression; extra.parseNonComputedProperty = parseNonComputedProperty; extra.parseObjectProperty = parseObjectProperty; extra.parseObjectPropertyKey = parseObjectPropertyKey; extra.parsePostfixExpression = parsePostfixExpression; extra.parsePrimaryExpression = parsePrimaryExpression; extra.parseProgram = parseProgram; extra.parsePropertyFunction = parsePropertyFunction; extra.parseRelationalExpression = parseRelationalExpression; extra.parseStatement = parseStatement; extra.parseShiftExpression = parseShiftExpression; extra.parseSwitchCase = parseSwitchCase; extra.parseUnaryExpression = parseUnaryExpression; extra.parseVariableDeclaration = parseVariableDeclaration; extra.parseVariableIdentifier = parseVariableIdentifier; parseAdditiveExpression = wrapTracking(extra.parseAdditiveExpression); parseAssignmentExpression = wrapTracking(extra.parseAssignmentExpression); parseBitwiseANDExpression = wrapTracking(extra.parseBitwiseANDExpression); parseBitwiseORExpression = wrapTracking(extra.parseBitwiseORExpression); parseBitwiseXORExpression = wrapTracking(extra.parseBitwiseXORExpression); parseBlock = wrapTracking(extra.parseBlock); parseFunctionSourceElements = wrapTracking(extra.parseFunctionSourceElements); parseCatchClause = wrapTracking(extra.parseCatchClause); parseComputedMember = wrapTracking(extra.parseComputedMember); parseConditionalExpression = wrapTracking(extra.parseConditionalExpression); parseConstLetDeclaration = wrapTracking(extra.parseConstLetDeclaration); parseEqualityExpression = wrapTracking(extra.parseEqualityExpression); parseExpression = wrapTracking(extra.parseExpression); parseForVariableDeclaration = wrapTracking(extra.parseForVariableDeclaration); parseFunctionDeclaration = wrapTracking(extra.parseFunctionDeclaration); parseFunctionExpression = wrapTracking(extra.parseFunctionExpression); parseLeftHandSideExpression = wrapTracking(parseLeftHandSideExpression); parseLogicalANDExpression = wrapTracking(extra.parseLogicalANDExpression); parseLogicalORExpression = wrapTracking(extra.parseLogicalORExpression); parseMultiplicativeExpression = wrapTracking(extra.parseMultiplicativeExpression); parseNewExpression = wrapTracking(extra.parseNewExpression); parseNonComputedProperty = wrapTracking(extra.parseNonComputedProperty); parseObjectProperty = wrapTracking(extra.parseObjectProperty); parseObjectPropertyKey = wrapTracking(extra.parseObjectPropertyKey); parsePostfixExpression = wrapTracking(extra.parsePostfixExpression); parsePrimaryExpression = wrapTracking(extra.parsePrimaryExpression); parseProgram = wrapTracking(extra.parseProgram); parsePropertyFunction = wrapTracking(extra.parsePropertyFunction); parseRelationalExpression = wrapTracking(extra.parseRelationalExpression); parseStatement = wrapTracking(extra.parseStatement); parseShiftExpression = wrapTracking(extra.parseShiftExpression); parseSwitchCase = wrapTracking(extra.parseSwitchCase); parseUnaryExpression = wrapTracking(extra.parseUnaryExpression); parseVariableDeclaration = wrapTracking(extra.parseVariableDeclaration); parseVariableIdentifier = wrapTracking(extra.parseVariableIdentifier); } if (typeof extra.tokens !== 'undefined') { extra.advance = advance; extra.scanRegExp = scanRegExp; advance = collectToken; scanRegExp = collectRegex; } } function unpatch() { if (typeof extra.skipComment === 'function') { skipComment = extra.skipComment; } if (extra.raw) { createLiteral = extra.createLiteral; } if (extra.range || extra.loc) { parseAdditiveExpression = extra.parseAdditiveExpression; parseAssignmentExpression = extra.parseAssignmentExpression; parseBitwiseANDExpression = extra.parseBitwiseANDExpression; parseBitwiseORExpression = extra.parseBitwiseORExpression; parseBitwiseXORExpression = extra.parseBitwiseXORExpression; parseBlock = extra.parseBlock; parseFunctionSourceElements = extra.parseFunctionSourceElements; parseCatchClause = extra.parseCatchClause; parseComputedMember = extra.parseComputedMember; parseConditionalExpression = extra.parseConditionalExpression; parseConstLetDeclaration = extra.parseConstLetDeclaration; parseEqualityExpression = extra.parseEqualityExpression; parseExpression = extra.parseExpression; parseForVariableDeclaration = extra.parseForVariableDeclaration; parseFunctionDeclaration = extra.parseFunctionDeclaration; parseFunctionExpression = extra.parseFunctionExpression; parseGroupExpression = extra.parseGroupExpression; parseLeftHandSideExpression = extra.parseLeftHandSideExpression; parseLeftHandSideExpressionAllowCall = extra.parseLeftHandSideExpressionAllowCall; parseLogicalANDExpression = extra.parseLogicalANDExpression; parseLogicalORExpression = extra.parseLogicalORExpression; parseMultiplicativeExpression = extra.parseMultiplicativeExpression; parseNewExpression = extra.parseNewExpression; parseNonComputedProperty = extra.parseNonComputedProperty; parseObjectProperty = extra.parseObjectProperty; parseObjectPropertyKey = extra.parseObjectPropertyKey; parsePrimaryExpression = extra.parsePrimaryExpression; parsePostfixExpression = extra.parsePostfixExpression; parseProgram = extra.parseProgram; parsePropertyFunction = extra.parsePropertyFunction; parseRelationalExpression = extra.parseRelationalExpression; parseStatement = extra.parseStatement; parseShiftExpression = extra.parseShiftExpression; parseSwitchCase = extra.parseSwitchCase; parseUnaryExpression = extra.parseUnaryExpression; parseVariableDeclaration = extra.parseVariableDeclaration; parseVariableIdentifier = extra.parseVariableIdentifier; } if (typeof extra.scanRegExp === 'function') { advance = extra.advance; scanRegExp = extra.scanRegExp; } } function stringToArray(str) { var length = str.length, result = [], i; for (i = 0; i < length; ++i) { result[i] = str.charAt(i); } return result; } function parse(code, options) { var program, toString; toString = String; if (typeof code !== 'string' && !(code instanceof String)) { code = toString(code); } source = code; index = 0; lineNumber = (source.length > 0) ? 1 : 0; lineStart = 0; length = source.length; buffer = null; state = { allowIn: true, labelSet: {}, inFunctionBody: false, inIteration: false, inSwitch: false }; extra = {}; if (typeof options !== 'undefined') { extra.range = (typeof options.range === 'boolean') && options.range; extra.loc = (typeof options.loc === 'boolean') && options.loc; extra.raw = (typeof options.raw === 'boolean') && options.raw; if (typeof options.tokens === 'boolean' && options.tokens) { extra.tokens = []; } if (typeof options.comment === 'boolean' && options.comment) { extra.comments = []; } if (typeof options.tolerant === 'boolean' && options.tolerant) { extra.errors = []; } } if (length > 0) { if (typeof source[0] === 'undefined') { // Try first to convert to a string. This is good as fast path // for old IE which understands string indexing for string // literals only and not for string object. if (code instanceof String) { source = code.valueOf(); } // Force accessing the characters via an array. if (typeof source[0] === 'undefined') { source = stringToArray(code); } } } patch(); try { program = parseProgram(); if (typeof extra.comments !== 'undefined') { filterCommentLocation(); program.comments = extra.comments; } if (typeof extra.tokens !== 'undefined') { filterTokenLocation(); program.tokens = extra.tokens; } if (typeof extra.errors !== 'undefined') { program.errors = extra.errors; } if (extra.range || extra.loc) { program.body = filterGroup(program.body); } } catch (e) { throw e; } finally { unpatch(); extra = {}; } return program; } // Sync with package.json. exports.version = '1.0.2'; exports.parse = parse; // Deep copy. exports.Syntax = (function () { var name, types = {}; if (typeof Object.create === 'function') { types = Object.create(null); } for (name in Syntax) { if (Syntax.hasOwnProperty(name)) { types[name] = Syntax[name]; } } if (typeof Object.freeze === 'function') { Object.freeze(types); } return types; }()); })); /* vim: set sw=4 ts=4 et tw=80 : */ })(null); (function(require,module){ var parse = require('esprima').parse; var objectKeys = Object.keys || function (obj) { var keys = []; for (var key in obj) keys.push(key); return keys; }; var forEach = function (xs, fn) { if (xs.forEach) return xs.forEach(fn); for (var i = 0; i < xs.length; i++) { fn.call(xs, xs[i], i, xs); } }; var isArray = Array.isArray || function (xs) { return Object.prototype.toString.call(xs) === '[object Array]'; }; module.exports = function (src, opts, fn) { if (typeof opts === 'function') { fn = opts; opts = {}; } if (typeof src === 'object') { opts = src; src = opts.source; delete opts.source; } src = src === undefined ? opts.source : src; opts.range = true; if (typeof src !== 'string') src = String(src); var ast = parse(src, opts); var result = { chunks : src.split(''), toString : function () { return result.chunks.join('') }, inspect : function () { return result.toString() } }; var index = 0; (function walk (node, parent) { insertHelpers(node, parent, result.chunks); forEach(objectKeys(node), function (key) { if (key === 'parent') return; var child = node[key]; if (isArray(child)) { forEach(child, function (c) { if (c && typeof c.type === 'string') { walk(c, node); } }); } else if (child && typeof child.type === 'string') { insertHelpers(child, node, result.chunks); walk(child, node); } }); fn(node); })(ast, undefined); return result; }; function insertHelpers (node, parent, chunks) { if (!node.range) return; node.parent = parent; node.source = function () { return chunks.slice( node.range[0], node.range[1] ).join(''); }; if (node.update && typeof node.update === 'object') { var prev = node.update; forEach(objectKeys(prev), function (key) { update[key] = prev[key]; }); node.update = update; } else { node.update = update; } function update (s) { chunks[node.range[0]] = s; for (var i = node.range[0] + 1; i < node.range[1]; i++) { chunks[i] = ''; } }; } window.falafel = module.exports;})(function(){return {parse: esprima.parse};},{exports: {}}); var inBrowser = typeof window !== 'undefined' && this === window; var parseAndModify = (inBrowser ? window.falafel : require("falafel")); (inBrowser ? window : exports).blanket = (function(){ var linesToAddTracking = [ "ExpressionStatement", "BreakStatement" , "ContinueStatement" , "VariableDeclaration", "ReturnStatement" , "ThrowStatement" , "TryStatement" , "FunctionDeclaration" , "IfStatement" , "WhileStatement" , "DoWhileStatement" , "ForStatement" , "ForInStatement" , "SwitchStatement" , "WithStatement" ], linesToAddBrackets = [ "IfStatement" , "WhileStatement" , "DoWhileStatement" , "ForStatement" , "ForInStatement" , "WithStatement" ], __blanket, copynumber = Math.floor(Math.random()*1000), coverageInfo = {},options = { reporter: null, adapter:null, filter: null, customVariable: null, loader: null, ignoreScriptError: false, existingRequireJS:false, autoStart: false, timeout: 180, ignoreCors: false, branchTracking: false, sourceURL: false, debug:false, engineOnly:false, testReadyCallback:null, commonJS:false, instrumentCache:false, modulePattern: null }; if (inBrowser && typeof window.blanket !== 'undefined'){ __blanket = window.blanket.noConflict(); } _blanket = { noConflict: function(){ if (__blanket){ return __blanket; } return _blanket; }, _getCopyNumber: function(){ //internal method //for differentiating between instances return copynumber; }, extend: function(obj) { //borrowed from underscore _blanket._extend(_blanket,obj); }, _extend: function(dest,source){ if (source) { for (var prop in source) { if ( dest[prop] instanceof Object && typeof dest[prop] !== "function"){ _blanket._extend(dest[prop],source[prop]); }else{ dest[prop] = source[prop]; } } } }, getCovVar: function(){ var opt = _blanket.options("customVariable"); if (opt){ if (_blanket.options("debug")) {console.log("BLANKET-Using custom tracking variable:",opt);} return inBrowser ? "window."+opt : opt; } return inBrowser ? "window._$blanket" : "_$jscoverage"; }, options: function(key,value){ if (typeof key !== "string"){ _blanket._extend(options,key); }else if (typeof value === 'undefined'){ return options[key]; }else{ options[key]=value; } }, instrument: function(config, next){ //check instrumented hash table, //return instrumented code if available. var inFile = config.inputFile, inFileName = config.inputFileName; //check instrument cache if (_blanket.options("instrumentCache") && sessionStorage && sessionStorage.getItem("blanket_instrument_store-"+inFileName)){ if (_blanket.options("debug")) {console.log("BLANKET-Reading instrumentation from cache: ",inFileName);} next(sessionStorage.getItem("blanket_instrument_store-"+inFileName)); }else{ var sourceArray = _blanket._prepareSource(inFile); _blanket._trackingArraySetup=[]; var instrumented = parseAndModify(inFile,{loc:true,comment:true}, _blanket._addTracking(inFileName)); instrumented = _blanket._trackingSetup(inFileName,sourceArray)+instrumented; if (_blanket.options("sourceURL")){ instrumented += "\n//@ sourceURL="+inFileName.replace("http://",""); } if (_blanket.options("debug")) {console.log("BLANKET-Instrumented file: ",inFileName);} if (_blanket.options("instrumentCache") && sessionStorage){ if (_blanket.options("debug")) {console.log("BLANKET-Saving instrumentation to cache: ",inFileName);} sessionStorage.setItem("blanket_instrument_store-"+inFileName,instrumented); } next(instrumented); } }, _trackingArraySetup: [], _branchingArraySetup: [], _prepareSource: function(source){ return source.replace(/\\/g,"\\\\").replace(/'/g,"\\'").replace(/(\r\n|\n|\r)/gm,"\n").split('\n'); }, _trackingSetup: function(filename,sourceArray){ var branches = _blanket.options("branchTracking"); var sourceString = sourceArray.join("',\n'"); var intro = ""; var covVar = _blanket.getCovVar(); intro += "if (typeof "+covVar+" === 'undefined') "+covVar+" = {};\n"; if (branches){ intro += "var _$branchFcn=function(f,l,c,r){ "; intro += "if (!!r) { "; intro += covVar+"[f].branchData[l][c][0] = "+covVar+"[f].branchData[l][c][0] || [];"; intro += covVar+"[f].branchData[l][c][0].push(r); }"; intro += "else { "; intro += covVar+"[f].branchData[l][c][1] = "+covVar+"[f].branchData[l][c][1] || [];"; intro += covVar+"[f].branchData[l][c][1].push(r); }"; intro += "return r;};\n"; } intro += "if (typeof "+covVar+"['"+filename+"'] === 'undefined'){"; intro += covVar+"['"+filename+"']=[];\n"; if (branches){ intro += covVar+"['"+filename+"'].branchData=[];\n"; } intro += covVar+"['"+filename+"'].source=['"+sourceString+"'];\n"; //initialize array values _blanket._trackingArraySetup.sort(function(a,b){ return parseInt(a,10) > parseInt(b,10); }).forEach(function(item){ intro += covVar+"['"+filename+"']["+item+"]=0;\n"; }); if (branches){ _blanket._branchingArraySetup.sort(function(a,b){ return a.line > b.line; }).sort(function(a,b){ return a.column > b.column; }).forEach(function(item){ if (item.file === filename){ intro += "if (typeof "+ covVar+"['"+filename+"'].branchData["+item.line+"] === 'undefined'){\n"; intro += covVar+"['"+filename+"'].branchData["+item.line+"]=[];\n"; intro += "}"; intro += covVar+"['"+filename+"'].branchData["+item.line+"]["+item.column+"] = [];\n"; intro += covVar+"['"+filename+"'].branchData["+item.line+"]["+item.column+"].consequent = "+JSON.stringify(item.consequent)+";\n"; intro += covVar+"['"+filename+"'].branchData["+item.line+"]["+item.column+"].alternate = "+JSON.stringify(item.alternate)+";\n"; } }); } intro += "}"; return intro; }, _blockifyIf: function(node){ if (linesToAddBrackets.indexOf(node.type) > -1){ var bracketsExistObject = node.consequent || node.body; var bracketsExistAlt = node.alternate; if( bracketsExistAlt && bracketsExistAlt.type !== "BlockStatement") { bracketsExistAlt.update("{\n"+bracketsExistAlt.source()+"}\n"); } if( bracketsExistObject && bracketsExistObject.type !== "BlockStatement") { bracketsExistObject.update("{\n"+bracketsExistObject.source()+"}\n"); } } }, _trackBranch: function(node,filename){ //recursive on consequent and alternative var line = node.loc.start.line; var col = node.loc.start.column; _blanket._branchingArraySetup.push({ line: line, column: col, file:filename, consequent: node.consequent.loc, alternate: node.alternate.loc }); var source = node.source(); var updated = "_$branchFcn"+ "('"+filename+"',"+line+","+col+","+source.slice(0,source.indexOf("?"))+ ")"+source.slice(source.indexOf("?")); node.update(updated); }, _addTracking: function (filename) { //falafel doesn't take a file name //so we include the filename in a closure //and return the function to falafel var covVar = _blanket.getCovVar(); return function(node){ _blanket._blockifyIf(node); if (linesToAddTracking.indexOf(node.type) > -1 && node.parent.type !== "LabeledStatement") { _blanket._checkDefs(node,filename); if (node.type === "VariableDeclaration" && (node.parent.type === "ForStatement" || node.parent.type === "ForInStatement")){ return; } if (node.loc && node.loc.start){ node.update(covVar+"['"+filename+"']["+node.loc.start.line+"]++;\n"+node.source()); _blanket._trackingArraySetup.push(node.loc.start.line); }else{ //I don't think we can handle a node with no location throw new Error("The instrumenter encountered a node with no location: "+Object.keys(node)); } }else if (_blanket.options("branchTracking") && node.type === "ConditionalExpression"){ _blanket._trackBranch(node,filename); } }; }, _checkDefs: function(node,filename){ // Make sure developers don't redefine window. if they do, inform them it is wrong. if (inBrowser){ if (node.type === "VariableDeclaration" && node.declarations) { node.declarations.forEach(function(declaration) { if (declaration.id.name === "window") { throw new Error("Instrumentation error, you cannot redefine the 'window' variable in " + filename + ":" + node.loc.start.line); } }); } if (node.type === "FunctionDeclaration" && node.params) { node.params.forEach(function(param) { if (param.name === "window") { throw new Error("Instrumentation error, you cannot redefine the 'window' variable in " + filename + ":" + node.loc.start.line); } }); } //Make sure developers don't redefine the coverage variable if (node.type === "ExpressionStatement" && node.expression && node.expression.left && node.expression.left.object && node.expression.left.property && node.expression.left.object.name + "." + node.expression.left.property.name === _blanket.getCovVar()) { throw new Error("Instrumentation error, you cannot redefine the coverage variable in " + filename + ":" + node.loc.start.line); } }else{ //Make sure developers don't redefine the coverage variable in node if (node.type === "ExpressionStatement" && node.expression && node.expression.left && !node.expression.left.object && !node.expression.left.property && node.expression.left.name === _blanket.getCovVar()) { throw new Error("Instrumentation error, you cannot redefine the coverage variable in " + filename + ":" + node.loc.start.line); } } }, setupCoverage: function(){ coverageInfo.instrumentation = "blanket"; coverageInfo.stats = { "suites": 0, "tests": 0, "passes": 0, "pending": 0, "failures": 0, "start": new Date() }; }, _checkIfSetup: function(){ if (!coverageInfo.stats){ throw new Error("You must call blanket.setupCoverage() first."); } }, onTestStart: function(){ if (_blanket.options("debug")) {console.log("BLANKET-Test event started");} this._checkIfSetup(); coverageInfo.stats.tests++; coverageInfo.stats.pending++; }, onTestDone: function(total,passed){ this._checkIfSetup(); if(passed === total){ coverageInfo.stats.passes++; }else{ coverageInfo.stats.failures++; } coverageInfo.stats.pending--; }, onModuleStart: function(){ this._checkIfSetup(); coverageInfo.stats.suites++; }, onTestsDone: function(){ if (_blanket.options("debug")) {console.log("BLANKET-Test event done");} this._checkIfSetup(); coverageInfo.stats.end = new Date(); if (inBrowser){ this.report(coverageInfo); }else{ if (!_blanket.options("branchTracking")){ delete (inBrowser ? window : global)[_blanket.getCovVar()].branchFcn; } this.options("reporter").call(this,coverageInfo); } } }; return _blanket; })(); (function(_blanket){ var oldOptions = _blanket.options; _blanket.extend({ outstandingRequireFiles:[], options: function(key,value){ var newVal={}; if (typeof key !== "string"){ //key is key/value map oldOptions(key); newVal = key; }else if (typeof value === 'undefined'){ //accessor return oldOptions(key); }else{ //setter oldOptions(key,value); newVal[key] = value; } if (newVal.adapter){ _blanket._loadFile(newVal.adapter); } if (newVal.loader){ _blanket._loadFile(newVal.loader); } }, requiringFile: function(filename,done){ if (typeof filename === "undefined"){ _blanket.outstandingRequireFiles=[]; }else if (typeof done === "undefined"){ _blanket.outstandingRequireFiles.push(filename); }else{ _blanket.outstandingRequireFiles.splice(_blanket.outstandingRequireFiles.indexOf(filename),1); } }, requireFilesLoaded: function(){ return _blanket.outstandingRequireFiles.length === 0; }, showManualLoader: function(){ if (document.getElementById("blanketLoaderDialog")){ return; } //copied from http://blog.avtex.com/2012/01/26/cross-browser-css-only-modal-box/ var loader = "
"; loader += " 
"; loader += "
"; loader += "
"; loader += "Error: Blanket.js encountered a cross origin request error while instrumenting the source files. "; loader += "

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

Some solutions include starting Chrome with special flags, running a server locally, or using a browser without these CORS restrictions (Safari)."; loader += "
"; if (typeof FileReader !== "undefined"){ loader += "
Or, try the experimental loader. When prompted, simply click on the directory containing all the source files you want covered."; loader += "Start Loader"; loader += ""; } loader += "
Close"; loader += "
"; loader += "
"; var css = ".blanketDialogWrapper {"; css += "display:block;"; css += "position:fixed;"; css += "z-index:40001; }"; css += ".blanketDialogOverlay {"; css += "position:fixed;"; css += "width:100%;"; css += "height:100%;"; css += "background-color:black;"; css += "opacity:.5; "; css += "-ms-filter:'progid:DXImageTransform.Microsoft.Alpha(Opacity=50)'; "; css += "filter:alpha(opacity=50); "; css += "z-index:40001; }"; css += ".blanketDialogVerticalOffset { "; css += "position:fixed;"; css += "top:30%;"; css += "width:100%;"; css += "z-index:40002; }"; css += ".blanketDialogBox { "; css += "width:405px; "; css += "position:relative;"; css += "margin:0 auto;"; css += "background-color:white;"; css += "padding:10px;"; css += "border:1px solid black; }"; var dom = document.createElement("style"); dom.innerHTML = css; document.head.appendChild(dom); var div = document.createElement("div"); div.id = "blanketLoaderDialog"; div.className = "blanketDialogWrapper"; div.innerHTML = loader; document.body.insertBefore(div,document.body.firstChild); }, manualFileLoader: function(files){ var toArray =Array.prototype.slice; files = toArray.call(files).filter(function(item){ return item.type !== ""; }); var sessionLength = files.length-1; var sessionIndx=0; var sessionArray = {}; if (sessionStorage["blanketSessionLoader"]){ sessionArray = JSON.parse(sessionStorage["blanketSessionLoader"]); } var fileLoader = function(event){ var fileContent = event.currentTarget.result; var file = files[sessionIndx]; var filename = file.webkitRelativePath && file.webkitRelativePath !== '' ? file.webkitRelativePath : file.name; sessionArray[filename] = fileContent; sessionIndx++; if (sessionIndx === sessionLength){ sessionStorage.setItem("blanketSessionLoader", JSON.stringify(sessionArray)); document.location.reload(); }else{ readFile(files[sessionIndx]); } }; function readFile(file){ var reader = new FileReader(); reader.onload = fileLoader; reader.readAsText(file); } readFile(files[sessionIndx]); }, _loadFile: function(path){ if (typeof path !== "undefined"){ var request = new XMLHttpRequest(); request.open('GET', path, false); request.send(); _blanket._addScript(request.responseText); } }, _addScript: function(data){ var script = document.createElement("script"); script.type = "text/javascript"; script.text = data; (document.body || document.getElementsByTagName('head')[0]).appendChild(script); }, hasAdapter: function(callback){ return _blanket.options("adapter") !== null; }, report: function(coverage_data){ if (!document.getElementById("blanketLoaderDialog")){ //all found, clear it _blanket.blanketSession = null; } coverage_data.files = window._$blanket; var require = blanket.options("commonJS") ? blanket._commonjs.require : window.require; // Check if we have any covered files that requires reporting // otherwise just exit gracefully. if (!coverage_data.files || !Object.keys(coverage_data.files).length) { if (_blanket.options("debug")) {console.log("BLANKET-Reporting No files were instrumented.");} return; } if (typeof coverage_data.files.branchFcn !== "undefined"){ delete coverage_data.files.branchFcn; } if (typeof _blanket.options("reporter") === "string"){ _blanket._loadFile(_blanket.options("reporter")); _blanket.customReporter(coverage_data,_blanket.options("reporter_options")); }else if (typeof _blanket.options("reporter") === "function"){ _blanket.options("reporter")(coverage_data); }else if (typeof _blanket.defaultReporter === 'function'){ _blanket.defaultReporter(coverage_data); }else{ throw new Error("no reporter defined."); } }, _bindStartTestRunner: function(bindEvent,startEvent){ if (bindEvent){ bindEvent(startEvent); }else{ window.addEventListener("load",startEvent,false); } }, _loadSourceFiles: function(callback){ var require = blanket.options("commonJS") ? blanket._commonjs.require : window.require; function copy(o){ var _copy = Object.create( Object.getPrototypeOf(o) ); var propNames = Object.getOwnPropertyNames(o); propNames.forEach(function(name){ var desc = Object.getOwnPropertyDescriptor(o, name); Object.defineProperty(_copy, name, desc); }); return _copy; } if (_blanket.options("debug")) {console.log("BLANKET-Collecting page scripts");} var scripts = _blanket.utils.collectPageScripts(); //_blanket.options("filter",scripts); if (scripts.length === 0){ callback(); }else{ //check session state if (sessionStorage["blanketSessionLoader"]){ _blanket.blanketSession = JSON.parse(sessionStorage["blanketSessionLoader"]); } scripts.forEach(function(file,indx){ _blanket.utils.cache[file+".js"]={ loaded:false }; }); var currScript=-1; _blanket.utils.loadAll(function(test){ if (test){ return typeof scripts[currScript+1] !== 'undefined'; } currScript++; if (currScript >= scripts.length){ return null; } return scripts[currScript]+".js"; },callback); } }, beforeStartTestRunner: function(opts){ opts = opts || {}; opts.checkRequirejs = typeof opts.checkRequirejs === "undefined" ? true : opts.checkRequirejs; opts.callback = opts.callback || function() { }; opts.coverage = typeof opts.coverage === "undefined" ? true : opts.coverage; if (opts.coverage) { _blanket._bindStartTestRunner(opts.bindEvent, function(){ _blanket._loadSourceFiles(function() { var allLoaded = function(){ return opts.condition ? opts.condition() : _blanket.requireFilesLoaded(); }; var check = function() { if (allLoaded()) { if (_blanket.options("debug")) {console.log("BLANKET-All files loaded, init start test runner callback.");} var cb = _blanket.options("testReadyCallback"); if (cb){ if (typeof cb === "function"){ cb(opts.callback); }else if (typeof cb === "string"){ _blanket._addScript(cb); opts.callback(); } }else{ opts.callback(); } } else { setTimeout(check, 13); } }; check(); }); }); }else{ opts.callback(); } }, utils: { qualifyURL: function (url) { //http://stackoverflow.com/questions/470832/getting-an-absolute-url-from-a-relative-one-ie6-issue var a = document.createElement('a'); a.href = url; return a.href; } } }); })(blanket); blanket.defaultReporter = function(coverage){ 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;}", successRate = 60, head = document.head, fileNumber = 0, body = document.body, headerContent, hasBranchTracking = Object.keys(coverage.files).some(function(elem){ return typeof coverage.files[elem].branchData !== 'undefined'; }), bodyContent = "
results
Coverage (%)
Covered/Total Smts.
"+(hasBranchTracking ? "
Covered/Total Branches
":"")+"
", fileTemplate = "
{{fileNumber}}.{{file}}
{{percentage}} %
{{numberCovered}}/{{totalSmts}}
"+( hasBranchTracking ? "
{{passedBranches}}/{{totalBranches}}
" : "" )+"
"; grandTotalTemplate = "
{{rowTitle}}
{{percentage}} %
{{numberCovered}}/{{totalSmts}}
"+( hasBranchTracking ? "
{{passedBranches}}/{{totalBranches}}
" : "" ) + "
"; function blanket_toggleSource(id) { var element = document.getElementById(id); if(element.style.display === 'block') { element.style.display = 'none'; } else { element.style.display = 'block'; } } var script = document.createElement("script"); script.type = "text/javascript"; script.text = blanket_toggleSource.toString().replace('function ' + blanket_toggleSource.name, 'function blanket_toggleSource'); body.appendChild(script); var percentage = function(number, total) { return (Math.round(((number/total) * 100)*100)/100); }; var appendTag = function (type, el, str) { var dom = document.createElement(type); dom.innerHTML = str; el.appendChild(dom); }; function escapeInvalidXmlChars(str) { return str.replace(/\&/g, "&") .replace(//g, ">") .replace(/\"/g, """) .replace(/\'/g, "'"); } function isBranchFollowed(data,bool){ var mode = bool ? 0 : 1; if (typeof data === 'undefined' || typeof data === null || typeof data[mode] === 'undefined'){ return false; } return data[mode].length > 0; } var branchStack = []; function branchReport(colsIndex,src,cols,offset,lineNum){ var newsrc=""; var postfix=""; if (branchStack.length > 0){ newsrc += ""; if (branchStack[0][0].end.line === lineNum){ newsrc += escapeInvalidXmlChars(src.slice(0,branchStack[0][0].end.column)) + ""; src = src.slice(branchStack[0][0].end.column); branchStack.shift(); if (branchStack.length > 0){ newsrc += ""; if (branchStack[0][0].end.line === lineNum){ newsrc += escapeInvalidXmlChars(src.slice(0,branchStack[0][0].end.column)) + ""; src = src.slice(branchStack[0][0].end.column); branchStack.shift(); if (!cols){ return {src: newsrc + escapeInvalidXmlChars(src) ,cols:cols}; } } else if (!cols){ return {src: newsrc + escapeInvalidXmlChars(src) + "",cols:cols}; } else{ postfix = ""; } }else if (!cols){ return {src: newsrc + escapeInvalidXmlChars(src) ,cols:cols}; } }else if(!cols){ return {src: newsrc + escapeInvalidXmlChars(src) + "",cols:cols}; }else{ postfix = ""; } } var thisline = cols[colsIndex]; //consequent var cons = thisline.consequent; if (cons.start.line > lineNum){ branchStack.unshift([thisline.alternate,thisline]); branchStack.unshift([cons,thisline]); src = escapeInvalidXmlChars(src); }else{ var style = ""; newsrc += escapeInvalidXmlChars(src.slice(0,cons.start.column-offset)) + style; if (cols.length > colsIndex+1 && cols[colsIndex+1].consequent.start.line === lineNum && cols[colsIndex+1].consequent.start.column-offset < cols[colsIndex].consequent.end.column-offset) { var res = branchReport(colsIndex+1,src.slice(cons.start.column-offset,cons.end.column-offset),cols,cons.start.column-offset,lineNum); newsrc += res.src; cols = res.cols; cols[colsIndex+1] = cols[colsIndex+2]; cols.length--; }else{ newsrc += escapeInvalidXmlChars(src.slice(cons.start.column-offset,cons.end.column-offset)); } newsrc += ""; var alt = thisline.alternate; if (alt.start.line > lineNum){ newsrc += escapeInvalidXmlChars(src.slice(cons.end.column-offset)); branchStack.unshift([alt,thisline]); }else{ newsrc += escapeInvalidXmlChars(src.slice(cons.end.column-offset,alt.start.column-offset)); style = ""; newsrc += style; if (cols.length > colsIndex+1 && cols[colsIndex+1].consequent.start.line === lineNum && cols[colsIndex+1].consequent.start.column-offset < cols[colsIndex].alternate.end.column-offset) { var res2 = branchReport(colsIndex+1,src.slice(alt.start.column-offset,alt.end.column-offset),cols,alt.start.column-offset,lineNum); newsrc += res2.src; cols = res2.cols; cols[colsIndex+1] = cols[colsIndex+2]; cols.length--; }else{ newsrc += escapeInvalidXmlChars(src.slice(alt.start.column-offset,alt.end.column-offset)); } newsrc += ""; newsrc += escapeInvalidXmlChars(src.slice(alt.end.column-offset)); src = newsrc; } } return {src:src+postfix, cols:cols}; } var isUndefined = function(item){ return typeof item !== 'undefined'; }; var files = coverage.files; var totals = { totalSmts: 0, numberOfFilesCovered: 0, passedBranches: 0, totalBranches: 0, moduleTotalStatements : {}, moduleTotalCoveredStatements : {}, moduleTotalBranches : {}, moduleTotalCoveredBranches : {} }; // check if a data-cover-modulepattern was provided for per-module coverage reporting var modulePattern = _blanket.options("modulePattern"); var modulePatternRegex = ( modulePattern ? new RegExp(modulePattern) : null ); for(var file in files) { fileNumber++; var statsForFile = files[file], totalSmts = 0, numberOfFilesCovered = 0, code = [], i; var end = []; for(i = 0; i < statsForFile.source.length; i +=1){ var src = statsForFile.source[i]; if (branchStack.length > 0 || typeof statsForFile.branchData !== 'undefined') { if (typeof statsForFile.branchData[i+1] !== 'undefined') { var cols = statsForFile.branchData[i+1].filter(isUndefined); var colsIndex=0; src = branchReport(colsIndex,src,cols,0,i+1).src; }else if (branchStack.length){ src = branchReport(0,src,null,0,i+1).src; }else{ src = escapeInvalidXmlChars(src); } }else{ src = escapeInvalidXmlChars(src); } var lineClass=""; if(statsForFile[i+1]) { numberOfFilesCovered += 1; totalSmts += 1; lineClass = 'hit'; }else{ if(statsForFile[i+1] === 0){ totalSmts++; lineClass = 'miss'; } } code[i + 1] = "
"+(i + 1)+""+src+"
"; } totals.totalSmts += totalSmts; totals.numberOfFilesCovered += numberOfFilesCovered; var totalBranches=0; var passedBranches=0; if (typeof statsForFile.branchData !== 'undefined'){ for(var j=0;j 0 && typeof statsForFile.branchData[j][k][1] !== 'undefined' && statsForFile.branchData[j][k][1].length > 0){ passedBranches++; } } } } } } totals.passedBranches += passedBranches; totals.totalBranches += totalBranches; // if "data-cover-modulepattern" was provided, // track totals per module name as well as globally if (modulePatternRegex) { var moduleName = file.match(modulePatternRegex)[1]; if(!totals.moduleTotalStatements.hasOwnProperty(moduleName)) { totals.moduleTotalStatements[moduleName] = 0; totals.moduleTotalCoveredStatements[moduleName] = 0; } totals.moduleTotalStatements[moduleName] += totalSmts; totals.moduleTotalCoveredStatements[moduleName] += numberOfFilesCovered; if(!totals.moduleTotalBranches.hasOwnProperty(moduleName)) { totals.moduleTotalBranches[moduleName] = 0; totals.moduleTotalCoveredBranches[moduleName] = 0; } totals.moduleTotalBranches[moduleName] += totalBranches; totals.moduleTotalCoveredBranches[moduleName] += passedBranches; } var result = percentage(numberOfFilesCovered, totalSmts); var output = fileTemplate.replace("{{file}}", file) .replace("{{percentage}}",result) .replace("{{numberCovered}}", numberOfFilesCovered) .replace(/\{\{fileNumber\}\}/g, fileNumber) .replace("{{totalSmts}}", totalSmts) .replace("{{totalBranches}}", totalBranches) .replace("{{passedBranches}}", passedBranches) .replace("{{source}}", code.join(" ")); if(result < successRate) { output = output.replace("{{statusclass}}", "bl-error"); } else { output = output.replace("{{statusclass}}", "bl-success"); } bodyContent += output; } // create temporary function for use by the global totals reporter, // as well as the per-module totals reporter var createAggregateTotal = function(numSt, numCov, numBranch, numCovBr, moduleName) { var totalPercent = percentage(numCov, numSt); var statusClass = totalPercent < successRate ? "bl-error" : "bl-success"; var rowTitle = ( moduleName ? "Total for module: " + moduleName : "Global total" ); var totalsOutput = grandTotalTemplate.replace("{{rowTitle}}", rowTitle) .replace("{{percentage}}", totalPercent) .replace("{{numberCovered}}", numCov) .replace("{{totalSmts}}", numSt) .replace("{{passedBranches}}", numCovBr) .replace("{{totalBranches}}", numBranch) .replace("{{statusclass}}", statusClass); bodyContent += totalsOutput; }; // if "data-cover-modulepattern" was provided, // output the per-module totals alongside the global totals if (modulePatternRegex) { for (var thisModuleName in totals.moduleTotalStatements) { if (totals.moduleTotalStatements.hasOwnProperty(thisModuleName)) { var moduleTotalSt = totals.moduleTotalStatements[thisModuleName]; var moduleTotalCovSt = totals.moduleTotalCoveredStatements[thisModuleName]; var moduleTotalBr = totals.moduleTotalBranches[thisModuleName]; var moduleTotalCovBr = totals.moduleTotalCoveredBranches[thisModuleName]; createAggregateTotal(moduleTotalSt, moduleTotalCovSt, moduleTotalBr, moduleTotalCovBr, thisModuleName); } } } createAggregateTotal(totals.totalSmts, totals.numberOfFilesCovered, totals.totalBranches, totals.passedBranches, null); bodyContent += "
"; //closing main appendTag('style', head, cssSytle); //appendStyle(body, headerContent); if (document.getElementById("blanket-main")){ document.getElementById("blanket-main").innerHTML= bodyContent.slice(23,-6); }else{ appendTag('div', body, bodyContent); } //appendHtml(body, ''); }; (function(){ var newOptions={}; //http://stackoverflow.com/a/2954896 var toArray =Array.prototype.slice; var scripts = toArray.call(document.scripts); toArray.call(scripts[scripts.length - 1].attributes) .forEach(function(es){ if(es.nodeName === "data-cover-only"){ newOptions.filter = es.nodeValue; } if(es.nodeName === "data-cover-never"){ newOptions.antifilter = es.nodeValue; } if(es.nodeName === "data-cover-reporter"){ newOptions.reporter = es.nodeValue; } if (es.nodeName === "data-cover-adapter"){ newOptions.adapter = es.nodeValue; } if (es.nodeName === "data-cover-loader"){ newOptions.loader = es.nodeValue; } if (es.nodeName === "data-cover-timeout"){ newOptions.timeout = es.nodeValue; } if (es.nodeName === "data-cover-modulepattern") { newOptions.modulePattern = es.nodeValue; } if (es.nodeName === "data-cover-reporter-options"){ try{ newOptions.reporter_options = JSON.parse(es.nodeValue); }catch(e){ if (blanket.options("debug")){ throw new Error("Invalid reporter options. Must be a valid stringified JSON object."); } } } if (es.nodeName === "data-cover-testReadyCallback"){ newOptions.testReadyCallback = es.nodeValue; } if (es.nodeName === "data-cover-customVariable"){ newOptions.customVariable = es.nodeValue; } if (es.nodeName === "data-cover-flags"){ var flags = " "+es.nodeValue+" "; if (flags.indexOf(" ignoreError ") > -1){ newOptions.ignoreScriptError = true; } if (flags.indexOf(" autoStart ") > -1){ newOptions.autoStart = true; } if (flags.indexOf(" ignoreCors ") > -1){ newOptions.ignoreCors = true; } if (flags.indexOf(" branchTracking ") > -1){ newOptions.branchTracking = true; } if (flags.indexOf(" sourceURL ") > -1){ newOptions.sourceURL = true; } if (flags.indexOf(" debug ") > -1){ newOptions.debug = true; } if (flags.indexOf(" engineOnly ") > -1){ newOptions.engineOnly = true; } if (flags.indexOf(" commonJS ") > -1){ newOptions.commonJS = true; } if (flags.indexOf(" instrumentCache ") > -1){ newOptions.instrumentCache = true; } } }); blanket.options(newOptions); if (typeof requirejs !== 'undefined'){ blanket.options("existingRequireJS",true); } /* setup requirejs loader, if needed */ if (blanket.options("commonJS")){ blanket._commonjs = {}; } })(); (function(_blanket){ _blanket.extend({ utils: { normalizeBackslashes: function(str) { return str.replace(/\\/g, '/'); }, matchPatternAttribute: function(filename,pattern){ if (typeof pattern === 'string'){ if (pattern.indexOf("[") === 0){ //treat as array var pattenArr = pattern.slice(1,pattern.length-1).split(","); return pattenArr.some(function(elem){ return _blanket.utils.matchPatternAttribute(filename,_blanket.utils.normalizeBackslashes(elem.slice(1,-1))); //return filename.indexOf(_blanket.utils.normalizeBackslashes(elem.slice(1,-1))) > -1; }); }else if ( pattern.indexOf("//") === 0){ var ex = pattern.slice(2,pattern.lastIndexOf('/')); var mods = pattern.slice(pattern.lastIndexOf('/')+1); var regex = new RegExp(ex,mods); return regex.test(filename); }else if (pattern.indexOf("#") === 0){ return window[pattern.slice(1)].call(window,filename); }else{ return filename.indexOf(_blanket.utils.normalizeBackslashes(pattern)) > -1; } }else if ( pattern instanceof Array ){ return pattern.some(function(elem){ return _blanket.utils.matchPatternAttribute(filename,elem); }); }else if (pattern instanceof RegExp){ return pattern.test(filename); }else if (typeof pattern === "function"){ return pattern.call(window,filename); } }, blanketEval: function(data){ _blanket._addScript(data); }, collectPageScripts: function(){ var toArray = Array.prototype.slice; var scripts = toArray.call(document.scripts); var selectedScripts=[],scriptNames=[]; var filter = _blanket.options("filter"); if(filter != null){ //global filter in place, data-cover-only var antimatch = _blanket.options("antifilter"); selectedScripts = toArray.call(document.scripts) .filter(function(s){ return toArray.call(s.attributes).filter(function(sn){ return sn.nodeName === "src" && _blanket.utils.matchPatternAttribute(sn.nodeValue,filter) && (typeof antimatch === "undefined" || !_blanket.utils.matchPatternAttribute(sn.nodeValue,antimatch)); }).length === 1; }); }else{ selectedScripts = toArray.call(document.querySelectorAll("script[data-cover]")); } scriptNames = selectedScripts.map(function(s){ return _blanket.utils.qualifyURL( toArray.call(s.attributes).filter( function(sn){ return sn.nodeName === "src"; })[0].nodeValue).replace(".js",""); }); if (!filter){ _blanket.options("filter","['"+scriptNames.join("','")+"']"); } return scriptNames; }, loadAll: function(nextScript,cb,preprocessor){ /** * load dependencies * @param {nextScript} factory for priority level * @param {cb} the done callback */ var currScript=nextScript(); var isLoaded = _blanket.utils.scriptIsLoaded( currScript, _blanket.utils.ifOrdered, nextScript, cb ); if (!(_blanket.utils.cache[currScript] && _blanket.utils.cache[currScript].loaded)){ var attach = function(){ if (_blanket.options("debug")) {console.log("BLANKET-Mark script:"+currScript+", as loaded and move to next script.");} isLoaded(); }; var whenDone = function(result){ if (_blanket.options("debug")) {console.log("BLANKET-File loading finished");} if (typeof result !== 'undefined'){ if (_blanket.options("debug")) {console.log("BLANKET-Add file to DOM.");} _blanket._addScript(result); } attach(); }; _blanket.utils.attachScript( { url: currScript }, function (content){ _blanket.utils.processFile( content, currScript, whenDone, whenDone ); } ); }else{ isLoaded(); } }, attachScript: function(options,cb){ var timeout = _blanket.options("timeout") || 3000; setTimeout(function(){ if (!_blanket.utils.cache[options.url].loaded){ throw new Error("error loading source script"); } },timeout); _blanket.utils.getFile( options.url, cb, function(){ throw new Error("error loading source script");} ); }, ifOrdered: function(nextScript,cb){ /** * ordered loading callback * @param {nextScript} factory for priority level * @param {cb} the done callback */ var currScript = nextScript(true); if (currScript){ _blanket.utils.loadAll(nextScript,cb); }else{ cb(new Error("Error in loading chain.")); } }, scriptIsLoaded: function(url,orderedCb,nextScript,cb){ /** * returns a callback that checks a loading list to see if a script is loaded. * @param {orderedCb} callback if ordered loading is being done * @param {nextScript} factory for next priority level * @param {cb} the done callback */ if (_blanket.options("debug")) {console.log("BLANKET-Returning function");} return function(){ if (_blanket.options("debug")) {console.log("BLANKET-Marking file as loaded: "+url);} _blanket.utils.cache[url].loaded=true; if (_blanket.utils.allLoaded()){ if (_blanket.options("debug")) {console.log("BLANKET-All files loaded");} cb(); }else if (orderedCb){ //if it's ordered we need to //traverse down to the next //priority level if (_blanket.options("debug")) {console.log("BLANKET-Load next file.");} orderedCb(nextScript,cb); } }; }, cache: {}, allLoaded: function (){ /** * check if depdencies are loaded in cache */ var cached = Object.keys(_blanket.utils.cache); for (var i=0;i -1){ callback(_blanket.blanketSession[key]); foundInSession=true; return; } } } if (!foundInSession){ var xhr = _blanket.utils.createXhr(); xhr.open('GET', url, true); //Allow overrides specified in config if (onXhr) { onXhr(xhr, url); } xhr.onreadystatechange = function (evt) { var status, err; //Do not explicitly handle errors, those should be //visible via console output in the browser. if (xhr.readyState === 4) { status = xhr.status; if ((status > 399 && status < 600) /*|| (status === 0 && navigator.userAgent.toLowerCase().indexOf('firefox') > -1) */ ) { //An http 4xx or 5xx error. Signal an error. err = new Error(url + ' HTTP status: ' + status); err.xhr = xhr; errback(err); } else { callback(xhr.responseText); } } }; try{ xhr.send(null); }catch(e){ if (e.code && (e.code === 101 || e.code === 1012) && _blanket.options("ignoreCors") === false){ //running locally and getting error from browser _blanket.showManualLoader(); } else { throw e; } } } } } }); (function(){ var require = blanket.options("commonJS") ? blanket._commonjs.require : window.require; var requirejs = blanket.options("commonJS") ? blanket._commonjs.requirejs : window.requirejs; if (!_blanket.options("engineOnly") && _blanket.options("existingRequireJS")){ _blanket.utils.oldloader = requirejs.load; requirejs.load = function (context, moduleName, url) { _blanket.requiringFile(url); _blanket.utils.getFile(url, function(content){ _blanket.utils.processFile( content, url, function newLoader(){ context.completeLoad(moduleName); }, function oldLoader(){ _blanket.utils.oldloader(context, moduleName, url); } ); }, function (err) { _blanket.requiringFile(); throw err; }); }; } })(); })(blanket); (function(){ if (typeof QUnit !== 'undefined'){ //check to make sure requirejs is completed before we start the test runner var allLoaded = function() { return window.QUnit.config.queue.length > 0 && blanket.noConflict().requireFilesLoaded(); }; if (!QUnit.config.urlConfig[0].tooltip){ //older versions we run coverage automatically //and we change how events are binded QUnit.begin=function(){ blanket.noConflict().setupCoverage(); }; QUnit.done=function(failures, total) { blanket.noConflict().onTestsDone(); }; QUnit.moduleStart=function( details ) { blanket.noConflict().onModuleStart(); }; QUnit.testStart=function( details ) { blanket.noConflict().onTestStart(); }; QUnit.testDone=function( details ) { blanket.noConflict().onTestDone(details.total,details.passed); }; blanket.beforeStartTestRunner({ condition: allLoaded, callback: QUnit.start }); }else{ QUnit.config.urlConfig.push({ id: "coverage", label: "Enable coverage", tooltip: "Enable code coverage." }); if ( QUnit.urlParams.coverage || blanket.options("autoStart") ) { QUnit.begin(function(){ blanket.noConflict().setupCoverage(); }); QUnit.done(function(failures, total) { blanket.noConflict().onTestsDone(); }); QUnit.moduleStart(function( details ) { blanket.noConflict().onModuleStart(); }); QUnit.testStart(function( details ) { blanket.noConflict().onTestStart(); }); QUnit.testDone(function( details ) { blanket.noConflict().onTestDone(details.total,details.passed); }); blanket.noConflict().beforeStartTestRunner({ condition: allLoaded, callback: function(){ if (!(blanket.options("existingRequireJS") && !blanket.options("autoStart"))){ QUnit.start(); } } }); }else{ if (blanket.options("existingRequireJS")){ requirejs.load = _blanket.utils.oldloader; } blanket.noConflict().beforeStartTestRunner({ condition: allLoaded, callback: function(){ if (!(blanket.options("existingRequireJS") && !blanket.options("autoStart"))){ QUnit.start(); } }, coverage:false }); } } } })();