WordPress/WordPress

File esprima.js has 6151 lines of code (exceeds 250 allowed). Consider refactoring.

Open

(function webpackUniversalModuleDefinition(root, factory) {
/* istanbul ignore next */
    if(typeof exports === 'object' && typeof module === 'object')
        module.exports = factory();
    else if(typeof define === 'function' && define.amd)

Function Parser has 2892 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    var Parser = (function () {
        function Parser(code, options, delegate) {
            if (options === void 0) { options = {}; }
            this.config = {
                range: (typeof options.range === 'boolean') && options.range,

Function Scanner has 1054 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    var Scanner = (function () {
        function Scanner(code, handler) {
            this.source = code;
            this.errorHandler = handler;
            this.trackComment = false;

Function JSXParser has 461 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    var JSXParser = (function (_super) {
        __extends(JSXParser, _super);
        function JSXParser(code, options, delegate) {
            return _super.call(this, code, options, delegate) || this;
        }

Function parseForStatement has 144 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.parseForStatement = function () {
            var init = null;
            var test = null;
            var update = null;
            var forIn = true;

Function CommentHandler has 141 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    var CommentHandler = (function () {
        function CommentHandler() {
            this.attach = false;
            this.comments = [];
            this.stack = [];

Consider simplifying this complex logical expression.

Open

                            if (str === '&&' || str === '||' || str === '==' || str === '!=' ||
                                str === '+=' || str === '-=' || str === '*=' || str === '/=' ||
                                str === '++' || str === '--' || str === '<<' || str === '>>' ||
                                str === '&=' || str === '|=' || str === '^=' || str === '%=' ||
                                str === '<=' || str === '>=' || str === '=>' || str === '**') {

Function scanTemplate has 122 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Scanner.prototype.scanTemplate = function () {
            var cooked = '';
            var terminated = false;
            var start = this.index;
            var head = (this.source[start] === '`');

Function parseGroupExpression has 119 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.parseGroupExpression = function () {
            var expr;
            this.expect('(');
            if (this.match(')')) {
                this.nextToken();

Function scanStringLiteral has 98 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Scanner.prototype.scanStringLiteral = function () {
            var start = this.index;
            var quote = this.source[start];
            assert_1.assert((quote === '\'' || quote === '"'), 'String literal must starts with a quote');
            ++this.index;

Function parseClassElement has 92 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.parseClassElement = function (hasConstructor) {
            var token = this.lookahead;
            var node = this.createNode();
            var kind = '';
            var key = null;

Function parseAssignmentExpression has 91 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.parseAssignmentExpression = function () {
            var expr;
            if (!this.context.allowYield && this.matchKeyword('yield')) {
                expr = this.parseYieldExpression();
            }

Function parseExportDeclaration has 89 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.parseExportDeclaration = function () {
            if (this.context.inFunctionBody) {
                this.throwError(messages_1.Messages.IllegalExportDeclaration);
            }
            var node = this.createNode();

Function Parser has 85 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        function Parser(code, options, delegate) {
            if (options === void 0) { options = {}; }
            this.config = {
                range: (typeof options.range === 'boolean') && options.range,
                loc: (typeof options.loc === 'boolean') && options.loc,

Function parsePrimaryExpression has 84 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.parsePrimaryExpression = function () {
            var node = this.createNode();
            var expr;
            var token, raw;
            switch (this.lookahead.type) {

Function lexJSX has 83 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        JSXParser.prototype.lexJSX = function () {
            var cp = this.scanner.source.charCodeAt(this.scanner.index);
            // < > / : = { }
            if (cp === 60 || cp === 62 || cp === 47 || cp === 58 || cp === 61 || cp === 123 || cp === 125) {
                var value = this.scanner.source[this.scanner.index++];

Function parseObjectProperty has 78 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.parseObjectProperty = function (hasProto) {
            var node = this.createNode();
            var token = this.lookahead;
            var kind;
            var key = null;

Function parseStatement has 72 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.parseStatement = function () {
            var statement;
            switch (this.lookahead.type) {
                case 1 /* BooleanLiteral */:
                case 5 /* NullLiteral */:

Function Tokenizer has 71 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    var Tokenizer = (function () {
        function Tokenizer(code, config) {
            this.errorHandler = new error_handler_1.ErrorHandler();
            this.errorHandler.tolerant = config ? (typeof config.tolerant === 'boolean' && config.tolerant) : false;
            this.scanner = new scanner_1.Scanner(code, this.errorHandler);

Function scanPunctuator has 70 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Scanner.prototype.scanPunctuator = function () {
            var start = this.index;
            // Check for most common single-character punctuators.
            var str = this.source[this.index];
            switch (str) {

Function scanComments has 69 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Scanner.prototype.scanComments = function () {
            var comments;
            if (this.trackComment) {
                comments = [];
            }

Function skipMultiLineComment has 62 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Scanner.prototype.skipMultiLineComment = function () {
            var comments = [];
            var start, loc;
            if (this.trackComment) {
                comments = [];

Function scanNumericLiteral has 62 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Scanner.prototype.scanNumericLiteral = function () {
            var start = this.index;
            var ch = this.source[start];
            assert_1.assert(character_1.Character.isDecimalDigit(ch.charCodeAt(0)) || (ch === '.'), 'Numeric literal must start with a decimal digit or a decimal point');
            var num = '';

Function parseFunctionDeclaration has 59 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.parseFunctionDeclaration = function (identifierIsOptional) {
            var node = this.createNode();
            var isAsync = this.matchContextualKeyword('async');
            if (isAsync) {
                this.nextToken();

Function parseFunctionExpression has 59 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.parseFunctionExpression = function () {
            var node = this.createNode();
            var isAsync = this.matchContextualKeyword('async');
            if (isAsync) {
                this.nextToken();

Function parseLeftHandSideExpressionAllowCall has 58 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.parseLeftHandSideExpressionAllowCall = function () {
            var startToken = this.lookahead;
            var maybeAsync = this.matchContextualKeyword('async');
            var previousAllowIn = this.context.allowIn;
            this.context.allowIn = true;

Function getNextToken has 55 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Tokenizer.prototype.getNextToken = function () {
            if (this.buffer.length === 0) {
                var comments = this.scanner.scanComments();
                if (this.scanner.trackComment) {
                    for (var i = 0; i < comments.length; ++i) {

Function reinterpretAsCoverFormalsList has 55 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.reinterpretAsCoverFormalsList = function (expr) {
            var params = [expr];
            var options;
            var asyncArrow = false;
            switch (expr.type) {

Function Reader has 55 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    var Reader = (function () {
        function Reader() {
            this.values = [];
            this.curly = this.paren = -1;
        }

Function skipSingleLineComment has 52 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Scanner.prototype.skipSingleLineComment = function (offset) {
            var comments = [];
            var start, loc;
            if (this.trackComment) {
                comments = [];

Function ErrorHandler has 49 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    var ErrorHandler = (function () {
        function ErrorHandler() {
            this.errors = [];
            this.tolerant = false;
        }

Function getComplexIdentifier has 49 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Scanner.prototype.getComplexIdentifier = function () {
            var cp = this.codePointAt(this.index);
            var id = character_1.Character.fromCodePoint(cp);
            this.index += id.length;
            // '\u' (U+005C, U+0075) denotes an escaped character.

Function scanXHTMLEntity has 45 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        JSXParser.prototype.scanXHTMLEntity = function (quote) {
            var result = '&';
            var valid = true;
            var terminated = false;
            var numeric = false;

Function parse has 44 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function parse(code, options, delegate) {
        var commentHandler = null;
        var proxyDelegate = function (node, metadata) {
            if (delegate) {
                delegate(node, metadata);

Function parseImportDeclaration has 43 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.parseImportDeclaration = function () {
            if (this.context.inFunctionBody) {
                this.throwError(messages_1.Messages.IllegalImportDeclaration);
            }
            var node = this.createNode();

Function parseBinaryExpression has 43 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.parseBinaryExpression = function () {
            var startToken = this.lookahead;
            var expr = this.inheritCoverGrammar(this.parseExponentiationExpression);
            var token = this.lookahead;
            var prec = this.binaryPrecedence(token);

Function parseLabelledStatement has 38 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.parseLabelledStatement = function () {
            var node = this.createNode();
            var expr = this.parseExpression();
            var statement;
            if ((expr.type === syntax_1.Syntax.Identifier) && this.match(':')) {

Function scanRegExpFlags has 38 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Scanner.prototype.scanRegExpFlags = function () {
            var str = '';
            var flags = '';
            while (!this.eof()) {
                var ch = this.source[this.index];

Function parseStatementListItem has 37 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.parseStatementListItem = function () {
            var statement;
            this.context.isAssignmentTarget = true;
            this.context.isBindingElement = true;
            if (this.lookahead.type === 4 /* Keyword */) {

Function scanRegExpBody has 37 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Scanner.prototype.scanRegExpBody = function () {
            var ch = this.source[this.index];
            assert_1.assert(ch === '/', 'Regular expression literal must start with a slash');
            var str = this.source[this.index++];
            var classMarker = false;

Function lex has 37 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Scanner.prototype.lex = function () {
            if (this.eof()) {
                return {
                    type: 2 /* EOF */,
                    value: '',

Function parseComplexJSXElement has 35 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        JSXParser.prototype.parseComplexJSXElement = function (el) {
            var stack = [];
            while (!this.scanner.eof()) {
                el.children = el.children.concat(this.parseJSXChildren());
                var node = this.createJSXChildNode();

Function collectComments has 35 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.collectComments = function () {
            if (!this.config.comment) {
                this.scanner.scanComments();
            }
            else {

Function parseUpdateExpression has 35 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.parseUpdateExpression = function () {
            var expr;
            var startToken = this.lookahead;
            if (this.match('++') || this.match('--')) {
                var node = this.startNode(startToken);

Function finalize has 34 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.finalize = function (marker, node) {
            if (this.config.range) {
                node.range = [marker.index, this.lastMarker.index];
            }
            if (this.config.loc) {

Function findLeadingComments has 34 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        CommentHandler.prototype.findLeadingComments = function (metadata) {
            var leadingComments = [];
            var target;
            while (this.stack.length > 0) {
                var entry = this.stack[this.stack.length - 1];

Function nextJSXText has 34 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        JSXParser.prototype.nextJSXText = function () {
            this.startMarker.index = this.scanner.index;
            this.startMarker.line = this.scanner.lineNumber;
            this.startMarker.column = this.scanner.index - this.scanner.lineStart;
            var start = this.scanner.index;

Function parsePropertyPattern has 33 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.parsePropertyPattern = function (params, kind) {
            var node = this.createNode();
            var computed = false;
            var shorthand = false;
            var method = false;

Function unexpectedTokenError has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.unexpectedTokenError = function (token, message) {
            var msg = message || messages_1.Messages.UnexpectedToken;
            var value;
            if (token) {
                if (!message) {

Function reinterpretExpressionAsPattern has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.reinterpretExpressionAsPattern = function (expr) {
            switch (expr.type) {
                case syntax_1.Syntax.Identifier:
                case syntax_1.Syntax.MemberExpression:
                case syntax_1.Syntax.RestElement:

Function validateParam has 31 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.validateParam = function (options, param, name) {
            var key = '$' + name;
            if (this.context.strict) {
                if (this.scanner.isRestrictedWord(name)) {
                    options.stricted = param;

Function testRegExp has 29 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Scanner.prototype.testRegExp = function (pattern, flags) {
            // The BMP character to use as a replacement for astral symbols when
            // translating an ES6 "u"-flagged pattern to an ES5-compatible
            // approximation.
            // Note: replacing with '\uFFFF' enables false positives in unlikely

Function scanOctalLiteral has 29 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Scanner.prototype.scanOctalLiteral = function (prefix, start) {
            var num = '';
            var octal = false;
            if (character_1.Character.isOctalDigit(prefix.charCodeAt(0))) {
                octal = true;

Function parseLeftHandSideExpression has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.parseLeftHandSideExpression = function () {
            assert_1.assert(this.context.allowIn, 'callee of new expression always allow in keyword.');
            var node = this.startNode(this.lookahead);
            var expr = (this.matchKeyword('super') && this.context.inFunctionBody) ? this.parseSuper() :
                this.inheritCoverGrammar(this.matchKeyword('new') ? this.parseNewExpression : this.parsePrimaryExpression);

Function visitComment has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        CommentHandler.prototype.visitComment = function (node, metadata) {
            var type = (node.type[0] === 'L') ? 'Line' : 'Block';
            var comment = {
                type: type,
                value: node.value

Function parseDirectivePrologues has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.parseDirectivePrologues = function () {
            var firstRestricted = null;
            var body = [];
            while (true) {
                var token = this.lookahead;

Function parseFormalParameters has 27 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.parseFormalParameters = function (firstRestricted) {
            var options;
            options = {
                simple: true,
                params: [],

Function scanIdentifier has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Scanner.prototype.scanIdentifier = function () {
            var type;
            var start = this.index;
            // Backslash (U+005C) starts an escaped character.
            var id = (this.source.charCodeAt(start) === 0x5C) ? this.getComplexIdentifier() : this.getIdentifier();

Function isRegexStart has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Reader.prototype.isRegexStart = function () {
            var previous = this.values[this.values.length - 1];
            var regex = (previous !== null);
            switch (previous) {
                case 'this':

Function parseArrayInitializer has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.parseArrayInitializer = function () {
            var node = this.createNode();
            var elements = [];
            this.expect('[');
            while (!this.match(']')) {

Function parseSwitchStatement has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.parseSwitchStatement = function () {
            var node = this.createNode();
            this.expectKeyword('switch');
            this.expect('(');
            var discriminant = this.parseExpression();

Function checkPatternParam has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        Parser.prototype.checkPatternParam = function (options, param) {
            switch (param.type) {
                case syntax_1.Syntax.Identifier:
                    this.validateParam(options, param, param.name);
                    break;

Consider simplifying this complex logical expression.

Open

            if (this.match('+') || this.match('-') || this.match('~') || this.match('!') ||
                this.matchKeyword('delete') || this.matchKeyword('void') || this.matchKeyword('typeof')) {
                var node = this.startNode(this.lookahead);
                var token = this.nextToken();
                expr = this.inheritCoverGrammar(this.parseUnaryExpression);

Consider simplifying this complex logical expression.

Open

            if (cp === 60 || cp === 62 || cp === 47 || cp === 58 || cp === 61 || cp === 123 || cp === 125) {
                var value = this.scanner.source[this.scanner.index++];
                return {
                    type: 7 /* Punctuator */,
                    value: value,

Avoid deeply nested control flow statements.

Open

                            if (arrow) {
                                break;
                            }

Avoid deeply nested control flow statements.

Open

                                if (unescaped === null) {
                                    this.throwUnexpectedToken(messages_1.Messages.InvalidHexEscapeSequence);
                                }

Avoid deeply nested control flow statements.

Open

                                if (ch && character_1.Character.isOctalDigit(ch.charCodeAt(0))) {
                                    var octToDec = this.octalToDecimal(ch);
                                    octal = octToDec.octal || octal;
                                    str += String.fromCharCode(octToDec.code);
                                }

Avoid deeply nested control flow statements.

Open

                            if (expr.type === syntax_1.Syntax.Identifier && expr.name === 'yield') {
                                arrow = true;
                                expr = {
                                    type: ArrowParameterPlaceHolder,
                                    params: [expr],

Avoid deeply nested control flow statements.

Open

                        if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {
                            this.tolerateError(messages_1.Messages.InvalidLHSInForIn);
                        }

Avoid deeply nested control flow statements.

Open

                                if (this.source[this.index] === '{') {
                                    ++this.index;
                                    str += this.scanUnicodeCodePointEscape();
                                }
                                else {

Avoid deeply nested control flow statements.

Open

                            if (this.scanner.isRestrictedWord(id.name)) {
                                this.tolerateUnexpectedToken(token, messages_1.Messages.StrictLHSAssignment);
                            }

Avoid deeply nested control flow statements.

Open

                        if (this.trackComment) {
                            comments = comments.concat(comment);
                        }

Avoid deeply nested control flow statements.

Open

                                if ('<>=!+-*%&|^/'.indexOf(str) >= 0) {
                                    ++this.index;
                                }

Avoid deeply nested control flow statements.

Open

                        if (declarations.length === 1 && declarations[0].init === null && this.matchKeyword('in')) {
                            init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
                            this.nextToken();
                            left = init;
                            right = this.parseExpression();

Avoid deeply nested control flow statements.

Open

                        if (this.trackComment) {
                            loc.end = {
                                line: this.lineNumber,
                                column: this.index - this.lineStart
                            };

Avoid deeply nested control flow statements.

Open

                while (!this.match('}')) {
                    isExportFromIdentifier = isExportFromIdentifier || this.matchKeyword('default');
                    specifiers.push(this.parseExportSpecifier());
                    if (!this.match('}')) {
                        this.expect(',');

Avoid deeply nested control flow statements.

Open

                            if (!this.match(',')) {
                                break;
                            }

Avoid deeply nested control flow statements.

Open

                    else if (ch === 0x2A) {
                        this.index += 2;
                        var comment = this.skipMultiLineComment();
                        if (this.trackComment) {
                            comments = comments.concat(comment);

Avoid deeply nested control flow statements.

Open

                    if ((this.source.charCodeAt(this.index + 1) === 0x2D) && (this.source.charCodeAt(this.index + 2) === 0x3E)) {
                        // '-->' is a single-line comment
                        this.index += 3;
                        var comment = this.skipSingleLineComment(3);
                        if (this.trackComment) {

Avoid deeply nested control flow statements.

Open

                else if (ch === 0x3C) {
                    if (this.source.slice(this.index + 1, this.index + 4) === '!--') {
                        this.index += 4; // `<!--`
                        var comment = this.skipSingleLineComment(4);
                        if (this.trackComment) {

Avoid deeply nested control flow statements.

Open

                            if (!arrow) {
                                if (!this.context.isBindingElement) {
                                    this.throwUnexpectedToken(this.lookahead);
                                }
                                if (expr.type === syntax_1.Syntax.SequenceExpression) {

Avoid deeply nested control flow statements.

Open

                    if (ch === '\r' && this.source[this.index] === '\n') {
                        ++this.index;
                    }

Avoid deeply nested control flow statements.

Open

                            for (str += '\\u'; restore < this.index; ++restore) {
                                str += this.source[restore];
                            }

Avoid deeply nested control flow statements.

Open

                            if (this.scanner.isStrictModeReservedWord(id.name)) {
                                this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);
                            }

Avoid deeply nested control flow statements.

Open

                            if (token.value === 'get' || token.value === 'set') {
                                this.tolerateUnexpectedToken(token);
                            }
                            else if (token.value === 'constructor') {
                                this.tolerateUnexpectedToken(token, messages_1.Messages.ConstructorIsAsync);

Avoid deeply nested control flow statements.

Open

                if (this.matchContextualKeyword('from')) {
                    // export {default} from 'foo';
                    // export {foo} from 'foo';
                    this.nextToken();
                    source = this.parseModuleSpecifier();

Avoid deeply nested control flow statements.

Open

                        switch (ch) {
                            case 'n':
                                cooked += '\n';
                                break;
                            case 'r':

Function Property has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

        function Property(kind, key, computed, value, method, shorthand) {

Avoid deeply nested control flow statements.

Open

                            if (this.match(')')) {
                                this.nextToken();
                                for (var i = 0; i < expressions.length; i++) {
                                    this.reinterpretExpressionAsPattern(expressions[i]);
                                }

Avoid deeply nested control flow statements.

Open

                    else if (this.matchContextualKeyword('of')) {
                        if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {
                            this.tolerateError(messages_1.Messages.InvalidLHSInForLoop);
                        }
                        this.nextToken();

Avoid deeply nested control flow statements.

Open

                        if (ch === '\r' && this.source[this.index] === '\n') {
                            ++this.index;
                        }

Consider simplifying this complex logical expression.

Open

                        if (str === '===' || str === '!==' || str === '>>>' ||
                            str === '<<=' || str === '>>=' || str === '**=') {
                            this.index += 3;
                        }
                        else {

Function MethodDefinition has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

        function MethodDefinition(key, computed, value, kind, isStatic) {

Avoid too many return statements within this function.

Open

                    return this.scanIdentifier();

Avoid too many return statements within this function.

Open

                    return this.scanNumericLiteral();

Avoid too many return statements within this function.

Open

                return {
                    type: 100 /* Identifier */,
                    value: id,
                    lineNumber: this.scanner.lineNumber,
                    lineStart: this.scanner.lineStart,

Avoid too many return statements within this function.

Open

            return this.scanner.lex();

Avoid too many return statements within this function.

Open

                return this.scanPunctuator();

Avoid too many return statements within this function.

Open

                return this.scanTemplate();

Avoid too many return statements within this function.

Open

            return this.scanPunctuator();

Avoid too many return statements within this function.

Open

            return {
                type: 6 /* NumericLiteral */,
                value: parseFloat(num),
                lineNumber: this.lineNumber,
                lineStart: this.lineStart,

Avoid too many return statements within this function.

Open

                return this.scanNumericLiteral();

Similar blocks of code found in 2 locations. Consider refactoring.

Open

            if (!this.config.comment) {
                this.scanner.scanComments();
            }
            else {
                var comments = this.scanner.scanComments();

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        Parser.prototype.parseArguments = function () {
            this.expect('(');
            var args = [];
            if (!this.match(')')) {
                while (true) {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        Parser.prototype.parseAsyncArguments = function () {
            this.expect('(');
            var args = [];
            if (!this.match(')')) {
                while (true) {

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

                if (this.context.strict) {
                    if (this.scanner.isRestrictedWord(token.value)) {
                        this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunctionName);
                    }
                }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

                if (this.context.strict) {
                    if (this.scanner.isRestrictedWord(token.value)) {
                        this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunctionName);
                    }
                }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

            this.operatorPrecedence = {
                ')': 0,
                ';': 0,
                ',': 0,
                '=': 0,

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

                if (this.source[this.index] === '{') {
                    ++this.index;
                    ch = this.scanUnicodeCodePointEscape();
                }
                else {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

                    if (this.source[this.index] === '{') {
                        ++this.index;
                        ch = this.scanUnicodeCodePointEscape();
                    }
                    else {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    var FunctionDeclaration = (function () {
        function FunctionDeclaration(id, params, body, generator) {
            this.type = syntax_1.Syntax.FunctionDeclaration;
            this.id = id;
            this.params = params;

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    var FunctionExpression = (function () {
        function FunctionExpression(id, params, body, generator) {
            this.type = syntax_1.Syntax.FunctionExpression;
            this.id = id;
            this.params = params;

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    var ArrowFunctionExpression = (function () {
        function ArrowFunctionExpression(params, body, expression) {
            this.type = syntax_1.Syntax.ArrowFunctionExpression;
            this.id = null;
            this.params = params;

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    var AsyncArrowFunctionExpression = (function () {
        function AsyncArrowFunctionExpression(params, body, expression) {
            this.type = syntax_1.Syntax.ArrowFunctionExpression;
            this.id = null;
            this.params = params;

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    var AsyncFunctionExpression = (function () {
        function AsyncFunctionExpression(id, params, body) {
            this.type = syntax_1.Syntax.FunctionExpression;
            this.id = id;
            this.params = params;

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    var AsyncFunctionDeclaration = (function () {
        function AsyncFunctionDeclaration(id, params, body) {
            this.type = syntax_1.Syntax.FunctionDeclaration;
            this.id = id;
            this.params = params;

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

            return op === '=' ||
                op === '*=' ||
                op === '**=' ||
                op === '/=' ||
                op === '%=' ||

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

                            if (str === '&&' || str === '||' || str === '==' || str === '!=' ||
                                str === '+=' || str === '-=' || str === '*=' || str === '/=' ||
                                str === '++' || str === '--' || str === '<<' || str === '>>' ||
                                str === '&=' || str === '|=' || str === '^=' || str === '%=' ||

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

        JSXParser.prototype.expectJSX = function (value) {
            var token = this.nextJSXToken();
            if (token.type !== 7 /* Punctuator */ || token.value !== value) {
                this.throwUnexpectedToken(token);
            }

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

        Parser.prototype.expectKeyword = function (keyword) {
            var token = this.nextToken();
            if (token.type !== 4 /* Keyword */ || token.value !== keyword) {
                this.throwUnexpectedToken(token);
            }

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

        Parser.prototype.expect = function (value) {
            var token = this.nextToken();
            if (token.type !== 7 /* Punctuator */ || token.value !== value) {
                this.throwUnexpectedToken(token);
            }

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

    var ClassExpression = (function () {
        function ClassExpression(id, superClass, body) {
            this.type = syntax_1.Syntax.ClassExpression;
            this.id = id;
            this.superClass = superClass;

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

    var ConditionalExpression = (function () {
        function ConditionalExpression(test, consequent, alternate) {
            this.type = syntax_1.Syntax.ConditionalExpression;
            this.test = test;
            this.consequent = consequent;

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

    var JSXElement = (function () {
        function JSXElement(openingElement, children, closingElement) {
            this.type = jsx_syntax_1.JSXSyntax.JSXElement;
            this.openingElement = openingElement;
            this.children = children;

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

    var AssignmentExpression = (function () {
        function AssignmentExpression(operator, left, right) {
            this.type = syntax_1.Syntax.AssignmentExpression;
            this.operator = operator;
            this.left = left;

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

    var TryStatement = (function () {
        function TryStatement(block, handler, finalizer) {
            this.type = syntax_1.Syntax.TryStatement;
            this.block = block;
            this.handler = handler;

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

    var UpdateExpression = (function () {
        function UpdateExpression(operator, argument, prefix) {
            this.type = syntax_1.Syntax.UpdateExpression;
            this.operator = operator;
            this.argument = argument;

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

    var ExportNamedDeclaration = (function () {
        function ExportNamedDeclaration(declaration, specifiers, source) {
            this.type = syntax_1.Syntax.ExportNamedDeclaration;
            this.declaration = declaration;
            this.specifiers = specifiers;

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

    var IfStatement = (function () {
        function IfStatement(test, consequent, alternate) {
            this.type = syntax_1.Syntax.IfStatement;
            this.test = test;
            this.consequent = consequent;

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

    var ClassDeclaration = (function () {
        function ClassDeclaration(id, superClass, body) {
            this.type = syntax_1.Syntax.ClassDeclaration;
            this.id = id;
            this.superClass = superClass;

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

    var JSXOpeningElement = (function () {
        function JSXOpeningElement(name, selfClosing, attributes) {
            this.type = jsx_syntax_1.JSXSyntax.JSXOpeningElement;
            this.name = name;
            this.selfClosing = selfClosing;

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

    var ForOfStatement = (function () {
        function ForOfStatement(left, right, body) {
            this.type = syntax_1.Syntax.ForOfStatement;
            this.left = left;
            this.right = right;

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    var StaticMemberExpression = (function () {
        function StaticMemberExpression(object, property) {
            this.type = syntax_1.Syntax.MemberExpression;
            this.computed = false;
            this.object = object;

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    var ComputedMemberExpression = (function () {
        function ComputedMemberExpression(object, property) {
            this.type = syntax_1.Syntax.MemberExpression;
            this.computed = true;
            this.object = object;

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

            if (this.context.strict && id.type === syntax_1.Syntax.Identifier) {
                if (this.scanner.isRestrictedWord(id.name)) {
                    this.tolerateError(messages_1.Messages.StrictVarName);
                }
            }

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

            if (this.context.strict && param.type === syntax_1.Syntax.Identifier) {
                if (this.scanner.isRestrictedWord(param.name)) {
                    this.tolerateError(messages_1.Messages.StrictCatchVariable);
                }
            }

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

            if (this.context.strict && id.type === syntax_1.Syntax.Identifier) {
                if (this.scanner.isRestrictedWord(id.name)) {
                    this.tolerateError(messages_1.Messages.StrictVarName);
                }
            }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

            while (!this.eof()) {
                if (!character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) {
                    break;
                }
                num += this.source[this.index++];

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

            while (!this.eof()) {
                if (!character_1.Character.isHexDigit(this.source.charCodeAt(this.index))) {
                    break;
                }
                num += this.source[this.index++];

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

                if (!this.matchContextualKeyword('from')) {
                    var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;
                    this.throwError(message, this.lookahead.value);
                }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

                if (!this.matchContextualKeyword('from')) {
                    var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;
                    this.throwError(message, this.lookahead.value);
                }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

                if (this.context.strict && expr.type === syntax_1.Syntax.Identifier && this.scanner.isRestrictedWord(expr.name)) {
                    this.tolerateError(messages_1.Messages.StrictLHSPrefix);
                }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

                        if (this.context.strict && expr.type === syntax_1.Syntax.Identifier && this.scanner.isRestrictedWord(expr.name)) {
                            this.tolerateError(messages_1.Messages.StrictLHSPostfix);
                        }

• Read up
  Read up

Similar blocks of code found in 26 locations. Consider refactoring.

Open

    var ExportSpecifier = (function () {
        function ExportSpecifier(local, exported) {
            this.type = syntax_1.Syntax.ExportSpecifier;
            this.exported = exported;
            this.local = local;

• Read up
  Read up

Similar blocks of code found in 26 locations. Consider refactoring.

Open

    var MetaProperty = (function () {
        function MetaProperty(meta, property) {
            this.type = syntax_1.Syntax.MetaProperty;
            this.meta = meta;
            this.property = property;

• Read up
  Read up

Similar blocks of code found in 26 locations. Consider refactoring.

Open

    var JSXAttribute = (function () {
        function JSXAttribute(name, value) {
            this.type = jsx_syntax_1.JSXSyntax.JSXAttribute;
            this.name = name;
            this.value = value;

• Read up
  Read up

Similar blocks of code found in 26 locations. Consider refactoring.

Open

    var JSXNamespacedName = (function () {
        function JSXNamespacedName(namespace, name) {
            this.type = jsx_syntax_1.JSXSyntax.JSXNamespacedName;
            this.namespace = namespace;
            this.name = name;

• Read up
  Read up

Similar blocks of code found in 26 locations. Consider refactoring.

Open

    var Directive = (function () {
        function Directive(expression, directive) {
            this.type = syntax_1.Syntax.ExpressionStatement;
            this.expression = expression;
            this.directive = directive;

• Read up
  Read up

Similar blocks of code found in 26 locations. Consider refactoring.

Open

    var WithStatement = (function () {
        function WithStatement(object, body) {
            this.type = syntax_1.Syntax.WithStatement;
            this.object = object;
            this.body = body;

• Read up
  Read up

Similar blocks of code found in 26 locations. Consider refactoring.

Open

    var ImportDeclaration = (function () {
        function ImportDeclaration(specifiers, source) {
            this.type = syntax_1.Syntax.ImportDeclaration;
            this.specifiers = specifiers;
            this.source = source;

• Read up
  Read up

Similar blocks of code found in 26 locations. Consider refactoring.

Open

    var LabeledStatement = (function () {
        function LabeledStatement(label, body) {
            this.type = syntax_1.Syntax.LabeledStatement;
            this.label = label;
            this.body = body;

• Read up
  Read up

Similar blocks of code found in 26 locations. Consider refactoring.

Open

    var YieldExpression = (function () {
        function YieldExpression(argument, delegate) {
            this.type = syntax_1.Syntax.YieldExpression;
            this.argument = argument;
            this.delegate = delegate;

• Read up
  Read up

Similar blocks of code found in 26 locations. Consider refactoring.

Open

    var Literal = (function () {
        function Literal(value, raw) {
            this.type = syntax_1.Syntax.Literal;
            this.value = value;
            this.raw = raw;

• Read up
  Read up

Similar blocks of code found in 26 locations. Consider refactoring.

Open

    var NewExpression = (function () {
        function NewExpression(callee, args) {
            this.type = syntax_1.Syntax.NewExpression;
            this.callee = callee;
            this.arguments = args;

• Read up
  Read up

Similar blocks of code found in 26 locations. Consider refactoring.

Open

    var ImportSpecifier = (function () {
        function ImportSpecifier(local, imported) {
            this.type = syntax_1.Syntax.ImportSpecifier;
            this.local = local;
            this.imported = imported;

• Read up
  Read up

Similar blocks of code found in 26 locations. Consider refactoring.

Open

    var TemplateLiteral = (function () {
        function TemplateLiteral(quasis, expressions) {
            this.type = syntax_1.Syntax.TemplateLiteral;
            this.quasis = quasis;
            this.expressions = expressions;

• Read up
  Read up

Similar blocks of code found in 26 locations. Consider refactoring.

Open

    var JSXMemberExpression = (function () {
        function JSXMemberExpression(object, property) {
            this.type = jsx_syntax_1.JSXSyntax.JSXMemberExpression;
            this.object = object;
            this.property = property;

• Read up
  Read up

Similar blocks of code found in 26 locations. Consider refactoring.

Open

    var CatchClause = (function () {
        function CatchClause(param, body) {
            this.type = syntax_1.Syntax.CatchClause;
            this.param = param;
            this.body = body;

• Read up
  Read up

Similar blocks of code found in 26 locations. Consider refactoring.

Open

    var AssignmentPattern = (function () {
        function AssignmentPattern(left, right) {
            this.type = syntax_1.Syntax.AssignmentPattern;
            this.left = left;
            this.right = right;

• Read up
  Read up

Similar blocks of code found in 26 locations. Consider refactoring.

Open

    var VariableDeclaration = (function () {
        function VariableDeclaration(declarations, kind) {
            this.type = syntax_1.Syntax.VariableDeclaration;
            this.declarations = declarations;
            this.kind = kind;

• Read up
  Read up

Similar blocks of code found in 26 locations. Consider refactoring.

Open

    var CallExpression = (function () {
        function CallExpression(callee, args) {
            this.type = syntax_1.Syntax.CallExpression;
            this.callee = callee;
            this.arguments = args;

• Read up
  Read up

Similar blocks of code found in 26 locations. Consider refactoring.

Open

    var TaggedTemplateExpression = (function () {
        function TaggedTemplateExpression(tag, quasi) {
            this.type = syntax_1.Syntax.TaggedTemplateExpression;
            this.tag = tag;
            this.quasi = quasi;

• Read up
  Read up