(function webpackUniversalModuleDefinition(root, factory) {

/* istanbul ignore next */

	if(typeof exports === 'object' && typeof module === 'object')

		module.exports = factory();

	else if(typeof define === 'function' && define.amd)

		define([], factory);

/* istanbul ignore next */

	else if(typeof exports === 'object')

		exports["esprima"] = factory();

	else

		root["esprima"] = factory();

})(this, function() {

return /******/ (function(modules) { // webpackBootstrap

/******/ 	// The module cache

/******/ 	var installedModules = {};

/******/ 	// The require function

/******/ 	function __webpack_require__(moduleId) {

/******/ 		// Check if module is in cache

/* istanbul ignore if */

/******/ 		if(installedModules[moduleId])

/******/ 			return installedModules[moduleId].exports;

/******/ 		// Create a new module (and put it into the cache)

/******/ 		var module = installedModules[moduleId] = {

/******/ 			exports: {},

/******/ 			id: moduleId,

/******/ 			loaded: false

/******/ 		};

/******/ 		// Execute the module function

/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/ 		// Flag the module as loaded

/******/ 		module.loaded = true;

/******/ 		// Return the exports of the module

/******/ 		return module.exports;

/******/ 	}

/******/ 	// expose the modules object (__webpack_modules__)

/******/ 	__webpack_require__.m = modules;

/******/ 	// expose the module cache

/******/ 	__webpack_require__.c = installedModules;

/******/ 	// __webpack_public_path__

/******/ 	__webpack_require__.p = "";

/******/ 	// Load entry module and return exports

/******/ 	return __webpack_require__(0);

/******/ })

/************************************************************************/

/******/ ([

/* 0 */

/***/ function(module, exports, __webpack_require__) {

	"use strict";

	/*

	  Copyright JS Foundation and other contributors, https://js.foundation/

	  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 <COPYRIGHT HOLDER> 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.

	*/

	Object.defineProperty(exports, "__esModule", { value: true });

	var comment_handler_1 = __webpack_require__(1);

	var jsx_parser_1 = __webpack_require__(3);

	var parser_1 = __webpack_require__(8);

	var tokenizer_1 = __webpack_require__(15);

	function parse(code, options, delegate) {

	    var commentHandler = null;

	    var proxyDelegate = function (node, metadata) {

	        if (delegate) {

	            delegate(node, metadata);

	        }

	        if (commentHandler) {

	            commentHandler.visit(node, metadata);

	        }

	    };

	    var parserDelegate = (typeof delegate === 'function') ? proxyDelegate : null;

	    var collectComment = false;

	    if (options) {

	        collectComment = (typeof options.comment === 'boolean' && options.comment);

	        var attachComment = (typeof options.attachComment === 'boolean' && options.attachComment);

	        if (collectComment || attachComment) {

	            commentHandler = new comment_handler_1.CommentHandler();

	            commentHandler.attach = attachComment;

	            options.comment = true;

	            parserDelegate = proxyDelegate;

	        }

	    }

	    var isModule = false;

	    if (options && typeof options.sourceType === 'string') {

	        isModule = (options.sourceType === 'module');

	    }

	    var parser;

	    if (options && typeof options.jsx === 'boolean' && options.jsx) {

	        parser = new jsx_parser_1.JSXParser(code, options, parserDelegate);

	    }

	    else {

	        parser = new parser_1.Parser(code, options, parserDelegate);

	    }

	    var program = isModule ? parser.parseModule() : parser.parseScript();

	    var ast = program;

	    if (collectComment && commentHandler) {

	        ast.comments = commentHandler.comments;

	    }

	    if (parser.config.tokens) {

	        ast.tokens = parser.tokens;

	    }

	    if (parser.config.tolerant) {

	        ast.errors = parser.errorHandler.errors;

	    }

	    return ast;

	}

	exports.parse = parse;

	function parseModule(code, options, delegate) {

	    var parsingOptions = options || {};

	    parsingOptions.sourceType = 'module';

	    return parse(code, parsingOptions, delegate);

	}

	exports.parseModule = parseModule;

	function parseScript(code, options, delegate) {

	    var parsingOptions = options || {};

	    parsingOptions.sourceType = 'script';

	    return parse(code, parsingOptions, delegate);

	}

	exports.parseScript = parseScript;

	function tokenize(code, options, delegate) {

	    var tokenizer = new tokenizer_1.Tokenizer(code, options);

	    var tokens;

	    tokens = [];

	    try {

	        while (true) {

	            var token = tokenizer.getNextToken();

	            if (!token) {

	                break;

	            }

	            if (delegate) {

	                token = delegate(token);

	            }

	            tokens.push(token);

	        }

	    }

	    catch (e) {

	        tokenizer.errorHandler.tolerate(e);

	    }

	    if (tokenizer.errorHandler.tolerant) {

	        tokens.errors = tokenizer.errors();

	    }

	    return tokens;

	}

	exports.tokenize = tokenize;

	var syntax_1 = __webpack_require__(2);

	exports.Syntax = syntax_1.Syntax;

	// Sync with *.json manifests.

	exports.version = '4.0.0';

/***/ },

/* 1 */

/***/ function(module, exports, __webpack_require__) {

	"use strict";

	Object.defineProperty(exports, "__esModule", { value: true });

	var syntax_1 = __webpack_require__(2);

	var CommentHandler = (function () {

	    function CommentHandler() {

	        this.attach = false;

	        this.comments = [];

	        this.stack = [];

	        this.leading = [];

	        this.trailing = [];

	    }

	    CommentHandler.prototype.insertInnerComments = function (node, metadata) {

	        //  innnerComments for properties empty block

	        //  `function a() {/** comments **\/}`

	        if (node.type === syntax_1.Syntax.BlockStatement && node.body.length === 0) {

	            var innerComments = [];

	            for (var i = this.leading.length - 1; i >= 0; --i) {

	                var entry = this.leading[i];

	                if (metadata.end.offset >= entry.start) {

	                    innerComments.unshift(entry.comment);

	                    this.leading.splice(i, 1);

	                    this.trailing.splice(i, 1);

	                }

	            }

	            if (innerComments.length) {

	                node.innerComments = innerComments;

	            }

	        }

	    };

	    CommentHandler.prototype.findTrailingComments = function (metadata) {

	        var trailingComments = [];

	        if (this.trailing.length > 0) {

	            for (var i = this.trailing.length - 1; i >= 0; --i) {

	                var entry_1 = this.trailing[i];

	                if (entry_1.start >= metadata.end.offset) {

	                    trailingComments.unshift(entry_1.comment);

	                }

	            }

	            this.trailing.length = 0;

	            return trailingComments;

	        }

	        var entry = this.stack[this.stack.length - 1];

	        if (entry && entry.node.trailingComments) {

	            var firstComment = entry.node.trailingComments[0];

	            if (firstComment && firstComment.range[0] >= metadata.end.offset) {

	                trailingComments = entry.node.trailingComments;

	                delete entry.node.trailingComments;

	            }

	        }

	        return trailingComments;

	    };

	    CommentHandler.prototype.findLeadingComments = function (metadata) {

	        var leadingComments = [];

	        var target;

	        while (this.stack.length > 0) {

	            var entry = this.stack[this.stack.length - 1];

	            if (entry && entry.start >= metadata.start.offset) {

	                target = entry.node;

	                this.stack.pop();

	            }

	            else {

	                break;

	            }

	        }

	        if (target) {

	            var count = target.leadingComments ? target.leadingComments.length : 0;

	            for (var i = count - 1; i >= 0; --i) {

	                var comment = target.leadingComments[i];

	                if (comment.range[1] <= metadata.start.offset) {

	                    leadingComments.unshift(comment);

	                    target.leadingComments.splice(i, 1);

	                }

	            }

	            if (target.leadingComments && target.leadingComments.length === 0) {

	                delete target.leadingComments;

	            }

	            return leadingComments;

	        }

	        for (var i = this.leading.length - 1; i >= 0; --i) {

	            var entry = this.leading[i];

	            if (entry.start <= metadata.start.offset) {

	                leadingComments.unshift(entry.comment);

	                this.leading.splice(i, 1);

	            }

	        }

	        return leadingComments;

	    };

	    CommentHandler.prototype.visitNode = function (node, metadata) {

	        if (node.type === syntax_1.Syntax.Program && node.body.length > 0) {

	            return;

	        }

	        this.insertInnerComments(node, metadata);

	        var trailingComments = this.findTrailingComments(metadata);

	        var leadingComments = this.findLeadingComments(metadata);

	        if (leadingComments.length > 0) {

	            node.leadingComments = leadingComments;

	        }

	        if (trailingComments.length > 0) {

	            node.trailingComments = trailingComments;

	        }

	        this.stack.push({

	            node: node,

	            start: metadata.start.offset

	        });

	    };

	    CommentHandler.prototype.visitComment = function (node, metadata) {

	        var type = (node.type[0] === 'L') ? 'Line' : 'Block';

	        var comment = {

	            type: type,

	            value: node.value

	        };

	        if (node.range) {

	            comment.range = node.range;

	        }

	        if (node.loc) {

	            comment.loc = node.loc;

	        }

	        this.comments.push(comment);

	        if (this.attach) {

	            var entry = {

	                comment: {

	                    type: type,

	                    value: node.value,

	                    range: [metadata.start.offset, metadata.end.offset]

	                },

	                start: metadata.start.offset

	            };

	            if (node.loc) {

	                entry.comment.loc = node.loc;

	            }

	            node.type = type;

	            this.leading.push(entry);

	            this.trailing.push(entry);

	        }

	    };

	    CommentHandler.prototype.visit = function (node, metadata) {

	        if (node.type === 'LineComment') {

	            this.visitComment(node, metadata);

	        }

	        else if (node.type === 'BlockComment') {

	            this.visitComment(node, metadata);

	        }

	        else if (this.attach) {

	            this.visitNode(node, metadata);

	        }

	    };

	    return CommentHandler;

	}());

	exports.CommentHandler = CommentHandler;

/***/ },

/* 2 */

/***/ function(module, exports) {

	"use strict";

	Object.defineProperty(exports, "__esModule", { value: true });

	exports.Syntax = {

	    AssignmentExpression: 'AssignmentExpression',

	    AssignmentPattern: 'AssignmentPattern',

	    ArrayExpression: 'ArrayExpression',

	    ArrayPattern: 'ArrayPattern',

	    ArrowFunctionExpression: 'ArrowFunctionExpression',

	    AwaitExpression: 'AwaitExpression',

	    BlockStatement: 'BlockStatement',

	    BinaryExpression: 'BinaryExpression',

	    BreakStatement: 'BreakStatement',

	    CallExpression: 'CallExpression',

	    CatchClause: 'CatchClause',

	    ClassBody: 'ClassBody',

	    ClassDeclaration: 'ClassDeclaration',

	    ClassExpression: 'ClassExpression',

	    ConditionalExpression: 'ConditionalExpression',

	    ContinueStatement: 'ContinueStatement',

	    DoWhileStatement: 'DoWhileStatement',

	    DebuggerStatement: 'DebuggerStatement',

	    EmptyStatement: 'EmptyStatement',

	    ExportAllDeclaration: 'ExportAllDeclaration',

	    ExportDefaultDeclaration: 'ExportDefaultDeclaration',

	    ExportNamedDeclaration: 'ExportNamedDeclaration',

	    ExportSpecifier: 'ExportSpecifier',

	    ExpressionStatement: 'ExpressionStatement',

	    ForStatement: 'ForStatement',

	    ForOfStatement: 'ForOfStatement',

	    ForInStatement: 'ForInStatement',

	    FunctionDeclaration: 'FunctionDeclaration',

	    FunctionExpression: 'FunctionExpression',

	    Identifier: 'Identifier',

	    IfStatement: 'IfStatement',

	    ImportDeclaration: 'ImportDeclaration',

	    ImportDefaultSpecifier: 'ImportDefaultSpecifier',

	    ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',

	    ImportSpecifier: 'ImportSpecifier',

	    Literal: 'Literal',

	    LabeledStatement: 'LabeledStatement',

	    LogicalExpression: 'LogicalExpression',

	    MemberExpression: 'MemberExpression',

	    MetaProperty: 'MetaProperty',

	    MethodDefinition: 'MethodDefinition',

	    NewExpression: 'NewExpression',

	    ObjectExpression: 'ObjectExpression',

	    ObjectPattern: 'ObjectPattern',

	    Program: 'Program',

	    Property: 'Property',

	    RestElement: 'RestElement',

	    ReturnStatement: 'ReturnStatement',

	    SequenceExpression: 'SequenceExpression',

	    SpreadElement: 'SpreadElement',

	    Super: 'Super',

	    SwitchCase: 'SwitchCase',

	    SwitchStatement: 'SwitchStatement',

	    TaggedTemplateExpression: 'TaggedTemplateExpression',

	    TemplateElement: 'TemplateElement',

	    TemplateLiteral: 'TemplateLiteral',

	    ThisExpression: 'ThisExpression',

	    ThrowStatement: 'ThrowStatement',

	    TryStatement: 'TryStatement',

	    UnaryExpression: 'UnaryExpression',

	    UpdateExpression: 'UpdateExpression',

	    VariableDeclaration: 'VariableDeclaration',

	    VariableDeclarator: 'VariableDeclarator',

	    WhileStatement: 'WhileStatement',

	    WithStatement: 'WithStatement',

	    YieldExpression: 'YieldExpression'

	};

/***/ },

/* 3 */

/***/ function(module, exports, __webpack_require__) {

	"use strict";

/* istanbul ignore next */

	var __extends = (this && this.__extends) || (function () {

	    var extendStatics = Object.setPrototypeOf ||

	        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||

	        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };

	    return function (d, b) {

	        extendStatics(d, b);

	        function __() { this.constructor = d; }

	        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());

	    };

	})();

	Object.defineProperty(exports, "__esModule", { value: true });

	var character_1 = __webpack_require__(4);

	var JSXNode = __webpack_require__(5);

	var jsx_syntax_1 = __webpack_require__(6);

	var Node = __webpack_require__(7);

	var parser_1 = __webpack_require__(8);

	var token_1 = __webpack_require__(13);

	var xhtml_entities_1 = __webpack_require__(14);

	token_1.TokenName[100 /* Identifier */] = 'JSXIdentifier';

	token_1.TokenName[101 /* Text */] = 'JSXText';

	// Fully qualified element name, e.g. <svg:path> returns "svg:path"

	function getQualifiedElementName(elementName) {

	    var qualifiedName;

	    switch (elementName.type) {

	        case jsx_syntax_1.JSXSyntax.JSXIdentifier:

	            var id = elementName;

	            qualifiedName = id.name;

	            break;

	        case jsx_syntax_1.JSXSyntax.JSXNamespacedName:

	            var ns = elementName;

	            qualifiedName = getQualifiedElementName(ns.namespace) + ':' +

	                getQualifiedElementName(ns.name);

	            break;

	        case jsx_syntax_1.JSXSyntax.JSXMemberExpression:

	            var expr = elementName;

	            qualifiedName = getQualifiedElementName(expr.object) + '.' +

	                getQualifiedElementName(expr.property);

	            break;

	        /* istanbul ignore next */

	        default:

	            break;

	    }

	    return qualifiedName;

	}

	var JSXParser = (function (_super) {

	    __extends(JSXParser, _super);

	    function JSXParser(code, options, delegate) {

	        return _super.call(this, code, options, delegate) || this;

	    }

	    JSXParser.prototype.parsePrimaryExpression = function () {

	        return this.match('<') ? this.parseJSXRoot() : _super.prototype.parsePrimaryExpression.call(this);

	    };

	    JSXParser.prototype.startJSX = function () {

	        // Unwind the scanner before the lookahead token.

	        this.scanner.index = this.startMarker.index;

	        this.scanner.lineNumber = this.startMarker.line;

	        this.scanner.lineStart = this.startMarker.index - this.startMarker.column;

	    };

	    JSXParser.prototype.finishJSX = function () {

	        // Prime the next lookahead.

	        this.nextToken();

	    };

	    JSXParser.prototype.reenterJSX = function () {

	        this.startJSX();

	        this.expectJSX('}');

	        // Pop the closing '}' added from the lookahead.

	        if (this.config.tokens) {

	            this.tokens.pop();

	        }

	    };

	    JSXParser.prototype.createJSXNode = function () {

	        this.collectComments();

	        return {

	            index: this.scanner.index,

	            line: this.scanner.lineNumber,

	            column: this.scanner.index - this.scanner.lineStart

	        };

	    };

	    JSXParser.prototype.createJSXChildNode = function () {

	        return {

	            index: this.scanner.index,

	            line: this.scanner.lineNumber,

	            column: this.scanner.index - this.scanner.lineStart

	        };

	    };

	    JSXParser.prototype.scanXHTMLEntity = function (quote) {

	        var result = '&';

	        var valid = true;

	        var terminated = false;

	        var numeric = false;

	        var hex = false;

	        while (!this.scanner.eof() && valid && !terminated) {

	            var ch = this.scanner.source[this.scanner.index];

	            if (ch === quote) {

	                break;

	            }

	            terminated = (ch === ';');

	            result += ch;

	            ++this.scanner.index;

	            if (!terminated) {

	                switch (result.length) {

	                    case 2:

	                        // e.g. '{'

	                        numeric = (ch === '#');

	                        break;

	                    case 3:

	                        if (numeric) {

	                            // e.g. 'A'

	                            hex = (ch === 'x');

	                            valid = hex || character_1.Character.isDecimalDigit(ch.charCodeAt(0));

	                            numeric = numeric && !hex;

	                        }

	                        break;

	                    default: