1 (function webpackUniversalModuleDefinition(root, factory) {

     2 /* istanbul ignore next */

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

     4 		module.exports = factory();

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

     6 		define([], factory);

     7 /* istanbul ignore next */

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

     9 		exports["esprima"] = factory();

    10 	else

    11 		root["esprima"] = factory();

    12 })(this, function() {

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

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

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

    16 

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

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

    19 

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

    21 /* istanbul ignore if */

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

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

    24 

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

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

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

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

    29 /******/ 			loaded: false

    30 /******/ 		};

    31 

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

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

    34 

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

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

    37 

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

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

    40 /******/ 	}

    41 

    42 

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

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

    45 

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

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

    48 

    49 /******/ 	// __webpack_public_path__

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

    51 

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

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

    54 /******/ })

    55 /************************************************************************/

    56 /******/ ([

    57 /* 0 */

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

    59 

    60 	"use strict";

    61 	/*

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

    63 

    64 	  Redistribution and use in source and binary forms, with or without

    65 	  modification, are permitted provided that the following conditions are met:

    66 

    67 	    * Redistributions of source code must retain the above copyright

    68 	      notice, this list of conditions and the following disclaimer.

    69 	    * Redistributions in binary form must reproduce the above copyright

    70 	      notice, this list of conditions and the following disclaimer in the

    71 	      documentation and/or other materials provided with the distribution.

    72 

    73 	  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

    74 	  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    75 	  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

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

    77 	  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

    78 	  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

    79 	  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

    80 	  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    81 	  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

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

    83 	*/

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

    85 	var comment_handler_1 = __webpack_require__(1);

    86 	var jsx_parser_1 = __webpack_require__(3);

    87 	var parser_1 = __webpack_require__(8);

    88 	var tokenizer_1 = __webpack_require__(15);

    89 	function parse(code, options, delegate) {

    90 	    var commentHandler = null;

    91 	    var proxyDelegate = function (node, metadata) {

    92 	        if (delegate) {

    93 	            delegate(node, metadata);

    94 	        }

    95 	        if (commentHandler) {

    96 	            commentHandler.visit(node, metadata);

    97 	        }

    98 	    };

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

   100 	    var collectComment = false;

   101 	    if (options) {

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

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

   104 	        if (collectComment || attachComment) {

   105 	            commentHandler = new comment_handler_1.CommentHandler();

   106 	            commentHandler.attach = attachComment;

   107 	            options.comment = true;

   108 	            parserDelegate = proxyDelegate;

   109 	        }

   110 	    }

   111 	    var isModule = false;

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

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

   114 	    }

   115 	    var parser;

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

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

   118 	    }

   119 	    else {

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

   121 	    }

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

   123 	    var ast = program;

   124 	    if (collectComment && commentHandler) {

   125 	        ast.comments = commentHandler.comments;

   126 	    }

   127 	    if (parser.config.tokens) {

   128 	        ast.tokens = parser.tokens;

   129 	    }

   130 	    if (parser.config.tolerant) {

   131 	        ast.errors = parser.errorHandler.errors;

   132 	    }

   133 	    return ast;

   134 	}

   135 	exports.parse = parse;

   136 	function parseModule(code, options, delegate) {

   137 	    var parsingOptions = options || {};

   138 	    parsingOptions.sourceType = 'module';

   139 	    return parse(code, parsingOptions, delegate);

   140 	}

   141 	exports.parseModule = parseModule;

   142 	function parseScript(code, options, delegate) {

   143 	    var parsingOptions = options || {};

   144 	    parsingOptions.sourceType = 'script';

   145 	    return parse(code, parsingOptions, delegate);

   146 	}

   147 	exports.parseScript = parseScript;

   148 	function tokenize(code, options, delegate) {

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

   150 	    var tokens;

   151 	    tokens = [];

   152 	    try {

   153 	        while (true) {

   154 	            var token = tokenizer.getNextToken();

   155 	            if (!token) {

   156 	                break;

   157 	            }

   158 	            if (delegate) {

   159 	                token = delegate(token);

   160 	            }

   161 	            tokens.push(token);

   162 	        }

   163 	    }

   164 	    catch (e) {

   165 	        tokenizer.errorHandler.tolerate(e);

   166 	    }

   167 	    if (tokenizer.errorHandler.tolerant) {

   168 	        tokens.errors = tokenizer.errors();

   169 	    }

   170 	    return tokens;

   171 	}

   172 	exports.tokenize = tokenize;

   173 	var syntax_1 = __webpack_require__(2);

   174 	exports.Syntax = syntax_1.Syntax;

   175 	// Sync with *.json manifests.

   176 	exports.version = '4.0.0';

   177 

   178 

   179 /***/ },

   180 /* 1 */

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

   182 

   183 	"use strict";

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

   185 	var syntax_1 = __webpack_require__(2);

   186 	var CommentHandler = (function () {

   187 	    function CommentHandler() {

   188 	        this.attach = false;

   189 	        this.comments = [];

   190 	        this.stack = [];

   191 	        this.leading = [];

   192 	        this.trailing = [];

   193 	    }

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

   195 	        //  innnerComments for properties empty block

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

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

   198 	            var innerComments = [];

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

   200 	                var entry = this.leading[i];

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

   202 	                    innerComments.unshift(entry.comment);

   203 	                    this.leading.splice(i, 1);

   204 	                    this.trailing.splice(i, 1);

   205 	                }

   206 	            }

   207 	            if (innerComments.length) {

   208 	                node.innerComments = innerComments;

   209 	            }

   210 	        }

   211 	    };

   212 	    CommentHandler.prototype.findTrailingComments = function (metadata) {

   213 	        var trailingComments = [];

   214 	        if (this.trailing.length > 0) {

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

   216 	                var entry_1 = this.trailing[i];

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

   218 	                    trailingComments.unshift(entry_1.comment);

   219 	                }

   220 	            }

   221 	            this.trailing.length = 0;

   222 	            return trailingComments;

   223 	        }

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

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

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

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

   228 	                trailingComments = entry.node.trailingComments;

   229 	                delete entry.node.trailingComments;

   230 	            }

   231 	        }

   232 	        return trailingComments;

   233 	    };

   234 	    CommentHandler.prototype.findLeadingComments = function (metadata) {

   235 	        var leadingComments = [];

   236 	        var target;

   237 	        while (this.stack.length > 0) {

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

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

   240 	                target = entry.node;

   241 	                this.stack.pop();

   242 	            }

   243 	            else {

   244 	                break;

   245 	            }

   246 	        }

   247 	        if (target) {

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

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

   250 	                var comment = target.leadingComments[i];

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

   252 	                    leadingComments.unshift(comment);

   253 	                    target.leadingComments.splice(i, 1);

   254 	                }

   255 	            }

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

   257 	                delete target.leadingComments;

   258 	            }

   259 	            return leadingComments;

   260 	        }

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

   262 	            var entry = this.leading[i];

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

   264 	                leadingComments.unshift(entry.comment);

   265 	                this.leading.splice(i, 1);

   266 	            }

   267 	        }

   268 	        return leadingComments;

   269 	    };

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

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

   272 	            return;

   273 	        }

   274 	        this.insertInnerComments(node, metadata);

   275 	        var trailingComments = this.findTrailingComments(metadata);

   276 	        var leadingComments = this.findLeadingComments(metadata);

   277 	        if (leadingComments.length > 0) {

   278 	            node.leadingComments = leadingComments;

   279 	        }

   280 	        if (trailingComments.length > 0) {

   281 	            node.trailingComments = trailingComments;

   282 	        }

   283 	        this.stack.push({

   284 	            node: node,

   285 	            start: metadata.start.offset

   286 	        });

   287 	    };

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

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

   290 	        var comment = {

   291 	            type: type,

   292 	            value: node.value

   293 	        };

   294 	        if (node.range) {

   295 	            comment.range = node.range;

   296 	        }

   297 	        if (node.loc) {

   298 	            comment.loc = node.loc;

   299 	        }

   300 	        this.comments.push(comment);

   301 	        if (this.attach) {

   302 	            var entry = {

   303 	                comment: {

   304 	                    type: type,

   305 	                    value: node.value,

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

   307 	                },

   308 	                start: metadata.start.offset

   309 	            };

   310 	            if (node.loc) {

   311 	                entry.comment.loc = node.loc;

   312 	            }

   313 	            node.type = type;

   314 	            this.leading.push(entry);

   315 	            this.trailing.push(entry);

   316 	        }

   317 	    };

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

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

   320 	            this.visitComment(node, metadata);

   321 	        }

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

   323 	            this.visitComment(node, metadata);

   324 	        }

   325 	        else if (this.attach) {

   326 	            this.visitNode(node, metadata);

   327 	        }

   328 	    };

   329 	    return CommentHandler;

   330 	}());

   331 	exports.CommentHandler = CommentHandler;

   332 

   333 

   334 /***/ },

   335 /* 2 */

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

   337 

   338 	"use strict";

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

   340 	exports.Syntax = {

   341 	    AssignmentExpression: 'AssignmentExpression',

   342 	    AssignmentPattern: 'AssignmentPattern',

   343 	    ArrayExpression: 'ArrayExpression',

   344 	    ArrayPattern: 'ArrayPattern',

   345 	    ArrowFunctionExpression: 'ArrowFunctionExpression',

   346 	    AwaitExpression: 'AwaitExpression',

   347 	    BlockStatement: 'BlockStatement',

   348 	    BinaryExpression: 'BinaryExpression',

   349 	    BreakStatement: 'BreakStatement',

   350 	    CallExpression: 'CallExpression',

   351 	    CatchClause: 'CatchClause',

   352 	    ClassBody: 'ClassBody',

   353 	    ClassDeclaration: 'ClassDeclaration',

   354 	    ClassExpression: 'ClassExpression',

   355 	    ConditionalExpression: 'ConditionalExpression',

   356 	    ContinueStatement: 'ContinueStatement',

   357 	    DoWhileStatement: 'DoWhileStatement',

   358 	    DebuggerStatement: 'DebuggerStatement',

   359 	    EmptyStatement: 'EmptyStatement',

   360 	    ExportAllDeclaration: 'ExportAllDeclaration',

   361 	    ExportDefaultDeclaration: 'ExportDefaultDeclaration',

   362 	    ExportNamedDeclaration: 'ExportNamedDeclaration',

   363 	    ExportSpecifier: 'ExportSpecifier',

   364 	    ExpressionStatement: 'ExpressionStatement',

   365 	    ForStatement: 'ForStatement',

   366 	    ForOfStatement: 'ForOfStatement',

   367 	    ForInStatement: 'ForInStatement',

   368 	    FunctionDeclaration: 'FunctionDeclaration',

   369 	    FunctionExpression: 'FunctionExpression',

   370 	    Identifier: 'Identifier',

   371 	    IfStatement: 'IfStatement',

   372 	    ImportDeclaration: 'ImportDeclaration',

   373 	    ImportDefaultSpecifier: 'ImportDefaultSpecifier',

   374 	    ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',

   375 	    ImportSpecifier: 'ImportSpecifier',

   376 	    Literal: 'Literal',

   377 	    LabeledStatement: 'LabeledStatement',

   378 	    LogicalExpression: 'LogicalExpression',

   379 	    MemberExpression: 'MemberExpression',

   380 	    MetaProperty: 'MetaProperty',

   381 	    MethodDefinition: 'MethodDefinition',

   382 	    NewExpression: 'NewExpression',

   383 	    ObjectExpression: 'ObjectExpression',

   384 	    ObjectPattern: 'ObjectPattern',

   385 	    Program: 'Program',

   386 	    Property: 'Property',

   387 	    RestElement: 'RestElement',

   388 	    ReturnStatement: 'ReturnStatement',

   389 	    SequenceExpression: 'SequenceExpression',

   390 	    SpreadElement: 'SpreadElement',

   391 	    Super: 'Super',

   392 	    SwitchCase: 'SwitchCase',

   393 	    SwitchStatement: 'SwitchStatement',

   394 	    TaggedTemplateExpression: 'TaggedTemplateExpression',

   395 	    TemplateElement: 'TemplateElement',

   396 	    TemplateLiteral: 'TemplateLiteral',

   397 	    ThisExpression: 'ThisExpression',

   398 	    ThrowStatement: 'ThrowStatement',

   399 	    TryStatement: 'TryStatement',

   400 	    UnaryExpression: 'UnaryExpression',

   401 	    UpdateExpression: 'UpdateExpression',

   402 	    VariableDeclaration: 'VariableDeclaration',

   403 	    VariableDeclarator: 'VariableDeclarator',

   404 	    WhileStatement: 'WhileStatement',

   405 	    WithStatement: 'WithStatement',

   406 	    YieldExpression: 'YieldExpression'

   407 	};

   408 

   409 

   410 /***/ },

   411 /* 3 */

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

   413 

   414 	"use strict";

   415 /* istanbul ignore next */

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

   417 	    var extendStatics = Object.setPrototypeOf ||

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

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

   420 	    return function (d, b) {

   421 	        extendStatics(d, b);

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

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

   424 	    };

   425 	})();

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

   427 	var character_1 = __webpack_require__(4);

   428 	var JSXNode = __webpack_require__(5);

   429 	var jsx_syntax_1 = __webpack_require__(6);

   430 	var Node = __webpack_require__(7);

   431 	var parser_1 = __webpack_require__(8);

   432 	var token_1 = __webpack_require__(13);

   433 	var xhtml_entities_1 = __webpack_require__(14);

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

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

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

   437 	function getQualifiedElementName(elementName) {

   438 	    var qualifiedName;

   439 	    switch (elementName.type) {

   440 	        case jsx_syntax_1.JSXSyntax.JSXIdentifier:

   441 	            var id = elementName;

   442 	            qualifiedName = id.name;

   443 	            break;

   444 	        case jsx_syntax_1.JSXSyntax.JSXNamespacedName:

   445 	            var ns = elementName;

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

   447 	                getQualifiedElementName(ns.name);

   448 	            break;

   449 	        case jsx_syntax_1.JSXSyntax.JSXMemberExpression:

   450 	            var expr = elementName;

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

   452 	                getQualifiedElementName(expr.property);

   453 	            break;

   454 	        /* istanbul ignore next */

   455 	        default:

   456 	            break;

   457 	    }

   458 	    return qualifiedName;

   459 	}

   460 	var JSXParser = (function (_super) {

   461 	    __extends(JSXParser, _super);

   462 	    function JSXParser(code, options, delegate) {

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

   464 	    }

   465 	    JSXParser.prototype.parsePrimaryExpression = function () {

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

   467 	    };

   468 	    JSXParser.prototype.startJSX = function () {

   469 	        // Unwind the scanner before the lookahead token.

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

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

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

   473 	    };

   474 	    JSXParser.prototype.finishJSX = function () {

   475 	        // Prime the next lookahead.

   476 	        this.nextToken();

   477 	    };

   478 	    JSXParser.prototype.reenterJSX = function () {

   479 	        this.startJSX();

   480 	        this.expectJSX('}');

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

   482 	        if (this.config.tokens) {

   483 	            this.tokens.pop();

   484 	        }

   485 	    };

   486 	    JSXParser.prototype.createJSXNode = function () {

   487 	        this.collectComments();

   488 	        return {

   489 	            index: this.scanner.index,

   490 	            line: this.scanner.lineNumber,

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

   492 	        };

   493 	    };

   494 	    JSXParser.prototype.createJSXChildNode = function () {

   495 	        return {

   496 	            index: this.scanner.index,

   497 	            line: this.scanner.lineNumber,

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

   499 	        };

   500 	    };

   501 	    JSXParser.prototype.scanXHTMLEntity = function (quote) {

   502 	        var result = '&';

   503 	        var valid = true;

   504 	        var terminated = false;

   505 	        var numeric = false;

   506 	        var hex = false;

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

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

   509 	            if (ch === quote) {

   510 	                break;

   511 	            }

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

   513 	            result += ch;

   514 	            ++this.scanner.index;

   515 	            if (!terminated) {

   516 	                switch (result.length) {

   517 	                    case 2:

   518 	                        // e.g. '{'

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

   520 	                        break;

   521 	                    case 3:

   522 	                        if (numeric) {

   523 	                            // e.g. 'A'

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

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

   526 	                            numeric = numeric && !hex;

   527 	                        }

   528 	                        break;

   529 	                    default:

   530 	                        valid = valid && !(numeric && !character_1.Character.isDecimalDigit(ch.charCodeAt(0)));

   531 	                        valid = valid && !(hex && !character_1.Character.isHexDigit(ch.charCodeAt(0)));

   532 	                        break;

   533 	                }

   534 	            }

   535 	        }

   536 	        if (valid && terminated && result.length > 2) {

   537 	            // e.g. 'A' becomes just '#x41'

   538 	            var str = result.substr(1, result.length - 2);

   539 	            if (numeric && str.length > 1) {

   540 	                result = String.fromCharCode(parseInt(str.substr(1), 10));

   541 	            }

   542 	            else if (hex && str.length > 2) {

   543 	                result = String.fromCharCode(parseInt('0' + str.substr(1), 16));

   544 	            }

   545 	            else if (!numeric && !hex && xhtml_entities_1.XHTMLEntities[str]) {

   546 	                result = xhtml_entities_1.XHTMLEntities[str];

   547 	            }

   548 	        }

   549 	        return result;

   550 	    };

   551 	    // Scan the next JSX token. This replaces Scanner#lex when in JSX mode.

   552 	    JSXParser.prototype.lexJSX = function () {

   553 	        var cp = this.scanner.source.charCodeAt(this.scanner.index);

   554 	        // < > / : = { }

   555 	        if (cp === 60 || cp === 62 || cp === 47 || cp === 58 || cp === 61 || cp === 123 || cp === 125) {

   556 	            var value = this.scanner.source[this.scanner.index++];

   557 	            return {

   558 	                type: 7 /* Punctuator */,

   559 	                value: value,

   560 	                lineNumber: this.scanner.lineNumber,

   561 	                lineStart: this.scanner.lineStart,

   562 	                start: this.scanner.index - 1,

   563 	                end: this.scanner.index

   564 	            };

   565 	        }

   566 	        // " '

   567 	        if (cp === 34 || cp === 39) {

   568 	            var start = this.scanner.index;

   569 	            var quote = this.scanner.source[this.scanner.index++];

   570 	            var str = '';

   571 	            while (!this.scanner.eof()) {

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

   573 	                if (ch === quote) {

   574 	                    break;

   575 	                }

   576 	                else if (ch === '&') {

   577 	                    str += this.scanXHTMLEntity(quote);

   578 	                }

   579 	                else {

   580 	                    str += ch;

   581 	                }

   582 	            }

   583 	            return {

   584 	                type: 8 /* StringLiteral */,

   585 	                value: str,

   586 	                lineNumber: this.scanner.lineNumber,

   587 	                lineStart: this.scanner.lineStart,

   588 	                start: start,

   589 	                end: this.scanner.index

   590 	            };

   591 	        }

   592 	        // ... or .

   593 	        if (cp === 46) {

   594 	            var n1 = this.scanner.source.charCodeAt(this.scanner.index + 1);

   595 	            var n2 = this.scanner.source.charCodeAt(this.scanner.index + 2);

   596 	            var value = (n1 === 46 && n2 === 46) ? '...' : '.';

   597 	            var start = this.scanner.index;

   598 	            this.scanner.index += value.length;

   599 	            return {

   600 	                type: 7 /* Punctuator */,

   601 	                value: value,

   602 	                lineNumber: this.scanner.lineNumber,

   603 	                lineStart: this.scanner.lineStart,

   604 	                start: start,

   605 	                end: this.scanner.index

   606 	            };

   607 	        }

   608 	        // `

   609 	        if (cp === 96) {

   610 	            // Only placeholder, since it will be rescanned as a real assignment expression.

   611 	            return {

   612 	                type: 10 /* Template */,

   613 	                value: '',

   614 	                lineNumber: this.scanner.lineNumber,

   615 	                lineStart: this.scanner.lineStart,

   616 	                start: this.scanner.index,

   617 	                end: this.scanner.index

   618 	            };

   619 	        }

   620 	        // Identifer can not contain backslash (char code 92).

   621 	        if (character_1.Character.isIdentifierStart(cp) && (cp !== 92)) {

   622 	            var start = this.scanner.index;

   623 	            ++this.scanner.index;

   624 	            while (!this.scanner.eof()) {

   625 	                var ch = this.scanner.source.charCodeAt(this.scanner.index);

   626 	                if (character_1.Character.isIdentifierPart(ch) && (ch !== 92)) {

   627 	                    ++this.scanner.index;

   628 	                }

   629 	                else if (ch === 45) {

   630 	                    // Hyphen (char code 45) can be part of an identifier.

   631 	                    ++this.scanner.index;

   632 	                }

   633 	                else {

   634 	                    break;

   635 	                }

   636 	            }

   637 	            var id = this.scanner.source.slice(start, this.scanner.index);

   638 	            return {

   639 	                type: 100 /* Identifier */,

   640 	                value: id,

   641 	                lineNumber: this.scanner.lineNumber,

   642 	                lineStart: this.scanner.lineStart,

   643 	                start: start,

   644 	                end: this.scanner.index

   645 	            };

   646 	        }

   647 	        return this.scanner.lex();

   648 	    };

   649 	    JSXParser.prototype.nextJSXToken = function () {

   650 	        this.collectComments();

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

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

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

   654 	        var token = this.lexJSX();

   655 	        this.lastMarker.index = this.scanner.index;

   656 	        this.lastMarker.line = this.scanner.lineNumber;

   657 	        this.lastMarker.column = this.scanner.index - this.scanner.lineStart;

   658 	        if (this.config.tokens) {

   659 	            this.tokens.push(this.convertToken(token));

   660 	        }

   661 	        return token;

   662 	    };

   663 	    JSXParser.prototype.nextJSXText = function () {

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

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

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

   667 	        var start = this.scanner.index;

   668 	        var text = '';

   669 	        while (!this.scanner.eof()) {

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

   671 	            if (ch === '{' || ch === '<') {

   672 	                break;

   673 	            }

   674 	            ++this.scanner.index;

   675 	            text += ch;

   676 	            if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {

   677 	                ++this.scanner.lineNumber;

   678 	                if (ch === '\r' && this.scanner.source[this.scanner.index] === '\n') {

   679 	                    ++this.scanner.index;

   680 	                }

   681 	                this.scanner.lineStart = this.scanner.index;

   682 	            }

   683 	        }

   684 	        this.lastMarker.index = this.scanner.index;

   685 	        this.lastMarker.line = this.scanner.lineNumber;

   686 	        this.lastMarker.column = this.scanner.index - this.scanner.lineStart;

   687 	        var token = {

   688 	            type: 101 /* Text */,

   689 	            value: text,

   690 	            lineNumber: this.scanner.lineNumber,

   691 	            lineStart: this.scanner.lineStart,

   692 	            start: start,

   693 	            end: this.scanner.index

   694 	        };

   695 	        if ((text.length > 0) && this.config.tokens) {

   696 	            this.tokens.push(this.convertToken(token));

   697 	        }

   698 	        return token;

   699 	    };

   700 	    JSXParser.prototype.peekJSXToken = function () {

   701 	        var state = this.scanner.saveState();

   702 	        this.scanner.scanComments();

   703 	        var next = this.lexJSX();

   704 	        this.scanner.restoreState(state);

   705 	        return next;

   706 	    };

   707 	    // Expect the next JSX token to match the specified punctuator.

   708 	    // If not, an exception will be thrown.

   709 	    JSXParser.prototype.expectJSX = function (value) {

   710 	        var token = this.nextJSXToken();

   711 	        if (token.type !== 7 /* Punctuator */ || token.value !== value) {

   712 	            this.throwUnexpectedToken(token);

   713 	        }

   714 	    };

   715 	    // Return true if the next JSX token matches the specified punctuator.

   716 	    JSXParser.prototype.matchJSX = function (value) {

   717 	        var next = this.peekJSXToken();

   718 	        return next.type === 7 /* Punctuator */ && next.value === value;

   719 	    };

   720 	    JSXParser.prototype.parseJSXIdentifier = function () {

   721 	        var node = this.createJSXNode();

   722 	        var token = this.nextJSXToken();

   723 	        if (token.type !== 100 /* Identifier */) {

   724 	            this.throwUnexpectedToken(token);

   725 	        }

   726 	        return this.finalize(node, new JSXNode.JSXIdentifier(token.value));

   727 	    };

   728 	    JSXParser.prototype.parseJSXElementName = function () {

   729 	        var node = this.createJSXNode();

   730 	        var elementName = this.parseJSXIdentifier();

   731 	        if (this.matchJSX(':')) {

   732 	            var namespace = elementName;

   733 	            this.expectJSX(':');

   734 	            var name_1 = this.parseJSXIdentifier();

   735 	            elementName = this.finalize(node, new JSXNode.JSXNamespacedName(namespace, name_1));

   736 	        }

   737 	        else if (this.matchJSX('.')) {

   738 	            while (this.matchJSX('.')) {

   739 	                var object = elementName;

   740 	                this.expectJSX('.');

   741 	                var property = this.parseJSXIdentifier();

   742 	                elementName = this.finalize(node, new JSXNode.JSXMemberExpression(object, property));

   743 	            }

   744 	        }

   745 	        return elementName;

   746 	    };

   747 	    JSXParser.prototype.parseJSXAttributeName = function () {

   748 	        var node = this.createJSXNode();

   749 	        var attributeName;

   750 	        var identifier = this.parseJSXIdentifier();

   751 	        if (this.matchJSX(':')) {

   752 	            var namespace = identifier;

   753 	            this.expectJSX(':');

   754 	            var name_2 = this.parseJSXIdentifier();

   755 	            attributeName = this.finalize(node, new JSXNode.JSXNamespacedName(namespace, name_2));

   756 	        }

   757 	        else {

   758 	            attributeName = identifier;

   759 	        }

   760 	        return attributeName;

   761 	    };

   762 	    JSXParser.prototype.parseJSXStringLiteralAttribute = function () {

   763 	        var node = this.createJSXNode();

   764 	        var token = this.nextJSXToken();

   765 	        if (token.type !== 8 /* StringLiteral */) {

   766 	            this.throwUnexpectedToken(token);

   767 	        }

   768 	        var raw = this.getTokenRaw(token);

   769 	        return this.finalize(node, new Node.Literal(token.value, raw));

   770 	    };

   771 	    JSXParser.prototype.parseJSXExpressionAttribute = function () {

   772 	        var node = this.createJSXNode();

   773 	        this.expectJSX('{');

   774 	        this.finishJSX();

   775 	        if (this.match('}')) {

   776 	            this.tolerateError('JSX attributes must only be assigned a non-empty expression');

   777 	        }

   778 	        var expression = this.parseAssignmentExpression();

   779 	        this.reenterJSX();

   780 	        return this.finalize(node, new JSXNode.JSXExpressionContainer(expression));

   781 	    };

   782 	    JSXParser.prototype.parseJSXAttributeValue = function () {

   783 	        return this.matchJSX('{') ? this.parseJSXExpressionAttribute() :

   784 	            this.matchJSX('<') ? this.parseJSXElement() : this.parseJSXStringLiteralAttribute();

   785 	    };

   786 	    JSXParser.prototype.parseJSXNameValueAttribute = function () {

   787 	        var node = this.createJSXNode();

   788 	        var name = this.parseJSXAttributeName();

   789 	        var value = null;

   790 	        if (this.matchJSX('=')) {

   791 	            this.expectJSX('=');

   792 	            value = this.parseJSXAttributeValue();

   793 	        }

   794 	        return this.finalize(node, new JSXNode.JSXAttribute(name, value));

   795 	    };

   796 	    JSXParser.prototype.parseJSXSpreadAttribute = function () {

   797 	        var node = this.createJSXNode();

   798 	        this.expectJSX('{');

   799 	        this.expectJSX('...');

   800 	        this.finishJSX();

   801 	        var argument = this.parseAssignmentExpression();

   802 	        this.reenterJSX();

   803 	        return this.finalize(node, new JSXNode.JSXSpreadAttribute(argument));

   804 	    };

   805 	    JSXParser.prototype.parseJSXAttributes = function () {

   806 	        var attributes = [];

   807 	        while (!this.matchJSX('/') && !this.matchJSX('>')) {

   808 	            var attribute = this.matchJSX('{') ? this.parseJSXSpreadAttribute() :

   809 	                this.parseJSXNameValueAttribute();

   810 	            attributes.push(attribute);

   811 	        }

   812 	        return attributes;

   813 	    };

   814 	    JSXParser.prototype.parseJSXOpeningElement = function () {

   815 	        var node = this.createJSXNode();

   816 	        this.expectJSX('<');

   817 	        var name = this.parseJSXElementName();

   818 	        var attributes = this.parseJSXAttributes();

   819 	        var selfClosing = this.matchJSX('/');

   820 	        if (selfClosing) {

   821 	            this.expectJSX('/');

   822 	        }

   823 	        this.expectJSX('>');

   824 	        return this.finalize(node, new JSXNode.JSXOpeningElement(name, selfClosing, attributes));

   825 	    };

   826 	    JSXParser.prototype.parseJSXBoundaryElement = function () {

   827 	        var node = this.createJSXNode();

   828 	        this.expectJSX('<');

   829 	        if (this.matchJSX('/')) {

   830 	            this.expectJSX('/');

   831 	            var name_3 = this.parseJSXElementName();

   832 	            this.expectJSX('>');

   833 	            return this.finalize(node, new JSXNode.JSXClosingElement(name_3));

   834 	        }

   835 	        var name = this.parseJSXElementName();

   836 	        var attributes = this.parseJSXAttributes();

   837 	        var selfClosing = this.matchJSX('/');

   838 	        if (selfClosing) {

   839 	            this.expectJSX('/');

   840 	        }

   841 	        this.expectJSX('>');

   842 	        return this.finalize(node, new JSXNode.JSXOpeningElement(name, selfClosing, attributes));

   843 	    };

   844 	    JSXParser.prototype.parseJSXEmptyExpression = function () {

   845 	        var node = this.createJSXChildNode();

   846 	        this.collectComments();

   847 	        this.lastMarker.index = this.scanner.index;

   848 	        this.lastMarker.line = this.scanner.lineNumber;

   849 	        this.lastMarker.column = this.scanner.index - this.scanner.lineStart;

   850 	        return this.finalize(node, new JSXNode.JSXEmptyExpression());

   851 	    };

   852 	    JSXParser.prototype.parseJSXExpressionContainer = function () {

   853 	        var node = this.createJSXNode();

   854 	        this.expectJSX('{');

   855 	        var expression;

   856 	        if (this.matchJSX('}')) {

   857 	            expression = this.parseJSXEmptyExpression();

   858 	            this.expectJSX('}');

   859 	        }

   860 	        else {

   861 	            this.finishJSX();

   862 	            expression = this.parseAssignmentExpression();

   863 	            this.reenterJSX();

   864 	        }

   865 	        return this.finalize(node, new JSXNode.JSXExpressionContainer(expression));

   866 	    };

   867 	    JSXParser.prototype.parseJSXChildren = function () {

   868 	        var children = [];

   869 	        while (!this.scanner.eof()) {

   870 	            var node = this.createJSXChildNode();

   871 	            var token = this.nextJSXText();

   872 	            if (token.start < token.end) {

   873 	                var raw = this.getTokenRaw(token);

   874 	                var child = this.finalize(node, new JSXNode.JSXText(token.value, raw));

   875 	                children.push(child);

   876 	            }

   877 	            if (this.scanner.source[this.scanner.index] === '{') {

   878 	                var container = this.parseJSXExpressionContainer();

   879 	                children.push(container);

   880 	            }

   881 	            else {

   882 	                break;

   883 	            }

   884 	        }

   885 	        return children;

   886 	    };

   887 	    JSXParser.prototype.parseComplexJSXElement = function (el) {

   888 	        var stack = [];

   889 	        while (!this.scanner.eof()) {

   890 	            el.children = el.children.concat(this.parseJSXChildren());

   891 	            var node = this.createJSXChildNode();

   892 	            var element = this.parseJSXBoundaryElement();

   893 	            if (element.type === jsx_syntax_1.JSXSyntax.JSXOpeningElement) {

   894 	                var opening = element;

   895 	                if (opening.selfClosing) {

   896 	                    var child = this.finalize(node, new JSXNode.JSXElement(opening, [], null));

   897 	                    el.children.push(child);

   898 	                }

   899 	                else {

   900 	                    stack.push(el);

   901 	                    el = { node: node, opening: opening, closing: null, children: [] };

   902 	                }

   903 	            }

   904 	            if (element.type === jsx_syntax_1.JSXSyntax.JSXClosingElement) {

   905 	                el.closing = element;

   906 	                var open_1 = getQualifiedElementName(el.opening.name);

   907 	                var close_1 = getQualifiedElementName(el.closing.name);

   908 	                if (open_1 !== close_1) {

   909 	                    this.tolerateError('Expected corresponding JSX closing tag for %0', open_1);

   910 	                }

   911 	                if (stack.length > 0) {

   912 	                    var child = this.finalize(el.node, new JSXNode.JSXElement(el.opening, el.children, el.closing));

   913 	                    el = stack[stack.length - 1];

   914 	                    el.children.push(child);

   915 	                    stack.pop();

   916 	                }

   917 	                else {

   918 	                    break;

   919 	                }

   920 	            }

   921 	        }

   922 	        return el;

   923 	    };

   924 	    JSXParser.prototype.parseJSXElement = function () {

   925 	        var node = this.createJSXNode();

   926 	        var opening = this.parseJSXOpeningElement();

   927 	        var children = [];

   928 	        var closing = null;

   929 	        if (!opening.selfClosing) {

   930 	            var el = this.parseComplexJSXElement({ node: node, opening: opening, closing: closing, children: children });

   931 	            children = el.children;

   932 	            closing = el.closing;

   933 	        }

   934 	        return this.finalize(node, new JSXNode.JSXElement(opening, children, closing));

   935 	    };

   936 	    JSXParser.prototype.parseJSXRoot = function () {

   937 	        // Pop the opening '<' added from the lookahead.

   938 	        if (this.config.tokens) {

   939 	            this.tokens.pop();

   940 	        }

   941 	        this.startJSX();

   942 	        var element = this.parseJSXElement();

   943 	        this.finishJSX();

   944 	        return element;

   945 	    };

   946 	    JSXParser.prototype.isStartOfExpression = function () {

   947 	        return _super.prototype.isStartOfExpression.call(this) || this.match('<');

   948 	    };

   949 	    return JSXParser;

   950 	}(parser_1.Parser));

   951 	exports.JSXParser = JSXParser;

   952 

   953 

   954 /***/ },

   955 /* 4 */

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

   957 

   958 	"use strict";

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

   960 	// See also tools/generate-unicode-regex.js.

   961 	var Regex = {

   962 	    // Unicode v8.0.0 NonAsciiIdentifierStart:

   963 	    NonAsciiIdentifierStart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\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-\u08B4\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\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\u0AF9\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-\u0C39\u0C3D\u0C58-\u0C5A\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\u0D5F-\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-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\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\u2118-\u211D\u2124\u2126\u2128\u212A-\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\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\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]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD806[\uDCA0-\uDCDF\uDCFF\uDEC0-\uDEF8]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDC00-\uDCC4]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]/,

   964 	    // Unicode v8.0.0 NonAsciiIdentifierPart:

   965 	    NonAsciiIdentifierPart: /[\xAA\xB5\xB7\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\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-\u08B4\u08E3-\u0963\u0966-\u096F\u0971-\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\u0AF9\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\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C81-\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\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\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\u1369-\u1371\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\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-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\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\u2118-\u211D\u2124\u2126\u2128\u212A-\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\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\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-\uFE2F\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]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDCA-\uDDCC\uDDD0-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9\uDF00-\uDF19\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDCA0-\uDCE9\uDCFF\uDEC0-\uDEF8]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF]/

   966 	};

   967 	exports.Character = {

   968 	    /* tslint:disable:no-bitwise */

   969 	    fromCodePoint: function (cp) {

   970 	        return (cp < 0x10000) ? String.fromCharCode(cp) :

   971 	            String.fromCharCode(0xD800 + ((cp - 0x10000) >> 10)) +

   972 	                String.fromCharCode(0xDC00 + ((cp - 0x10000) & 1023));

   973 	    },

   974 	    // https://tc39.github.io/ecma262/#sec-white-space

   975 	    isWhiteSpace: function (cp) {

   976 	        return (cp === 0x20) || (cp === 0x09) || (cp === 0x0B) || (cp === 0x0C) || (cp === 0xA0) ||

   977 	            (cp >= 0x1680 && [0x1680, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x202F, 0x205F, 0x3000, 0xFEFF].indexOf(cp) >= 0);

   978 	    },

   979 	    // https://tc39.github.io/ecma262/#sec-line-terminators

   980 	    isLineTerminator: function (cp) {

   981 	        return (cp === 0x0A) || (cp === 0x0D) || (cp === 0x2028) || (cp === 0x2029);

   982 	    },

   983 	    // https://tc39.github.io/ecma262/#sec-names-and-keywords

   984 	    isIdentifierStart: function (cp) {

   985 	        return (cp === 0x24) || (cp === 0x5F) ||

   986 	            (cp >= 0x41 && cp <= 0x5A) ||

   987 	            (cp >= 0x61 && cp <= 0x7A) ||

   988 	            (cp === 0x5C) ||

   989 	            ((cp >= 0x80) && Regex.NonAsciiIdentifierStart.test(exports.Character.fromCodePoint(cp)));

   990 	    },

   991 	    isIdentifierPart: function (cp) {

   992 	        return (cp === 0x24) || (cp === 0x5F) ||

   993 	            (cp >= 0x41 && cp <= 0x5A) ||

   994 	            (cp >= 0x61 && cp <= 0x7A) ||

   995 	            (cp >= 0x30 && cp <= 0x39) ||

   996 	            (cp === 0x5C) ||

   997 	            ((cp >= 0x80) && Regex.NonAsciiIdentifierPart.test(exports.Character.fromCodePoint(cp)));

   998 	    },

   999 	    // https://tc39.github.io/ecma262/#sec-literals-numeric-literals

  1000 	    isDecimalDigit: function (cp) {

  1001 	        return (cp >= 0x30 && cp <= 0x39); // 0..9

  1002 	    },

  1003 	    isHexDigit: function (cp) {

  1004 	        return (cp >= 0x30 && cp <= 0x39) ||

  1005 	            (cp >= 0x41 && cp <= 0x46) ||

  1006 	            (cp >= 0x61 && cp <= 0x66); // a..f

  1007 	    },

  1008 	    isOctalDigit: function (cp) {

  1009 	        return (cp >= 0x30 && cp <= 0x37); // 0..7

  1010 	    }

  1011 	};

  1012 

  1013 

  1014 /***/ },

  1015 /* 5 */

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

  1017 

  1018 	"use strict";

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

  1020 	var jsx_syntax_1 = __webpack_require__(6);

  1021 	/* tslint:disable:max-classes-per-file */

  1022 	var JSXClosingElement = (function () {

  1023 	    function JSXClosingElement(name) {

  1024 	        this.type = jsx_syntax_1.JSXSyntax.JSXClosingElement;

  1025 	        this.name = name;

  1026 	    }

  1027 	    return JSXClosingElement;

  1028 	}());

  1029 	exports.JSXClosingElement = JSXClosingElement;

  1030 	var JSXElement = (function () {

  1031 	    function JSXElement(openingElement, children, closingElement) {

  1032 	        this.type = jsx_syntax_1.JSXSyntax.JSXElement;

  1033 	        this.openingElement = openingElement;

  1034 	        this.children = children;

  1035 	        this.closingElement = closingElement;

  1036 	    }

  1037 	    return JSXElement;

  1038 	}());

  1039 	exports.JSXElement = JSXElement;

  1040 	var JSXEmptyExpression = (function () {

  1041 	    function JSXEmptyExpression() {

  1042 	        this.type = jsx_syntax_1.JSXSyntax.JSXEmptyExpression;

  1043 	    }

  1044 	    return JSXEmptyExpression;

  1045 	}());

  1046 	exports.JSXEmptyExpression = JSXEmptyExpression;

  1047 	var JSXExpressionContainer = (function () {

  1048 	    function JSXExpressionContainer(expression) {

  1049 	        this.type = jsx_syntax_1.JSXSyntax.JSXExpressionContainer;

  1050 	        this.expression = expression;

  1051 	    }

  1052 	    return JSXExpressionContainer;

  1053 	}());

  1054 	exports.JSXExpressionContainer = JSXExpressionContainer;

  1055 	var JSXIdentifier = (function () {

  1056 	    function JSXIdentifier(name) {

  1057 	        this.type = jsx_syntax_1.JSXSyntax.JSXIdentifier;

  1058 	        this.name = name;

  1059 	    }

  1060 	    return JSXIdentifier;

  1061 	}());

  1062 	exports.JSXIdentifier = JSXIdentifier;

  1063 	var JSXMemberExpression = (function () {

  1064 	    function JSXMemberExpression(object, property) {

  1065 	        this.type = jsx_syntax_1.JSXSyntax.JSXMemberExpression;

  1066 	        this.object = object;

  1067 	        this.property = property;

  1068 	    }

  1069 	    return JSXMemberExpression;

  1070 	}());

  1071 	exports.JSXMemberExpression = JSXMemberExpression;

  1072 	var JSXAttribute = (function () {

  1073 	    function JSXAttribute(name, value) {

  1074 	        this.type = jsx_syntax_1.JSXSyntax.JSXAttribute;

  1075 	        this.name = name;

  1076 	        this.value = value;

  1077 	    }

  1078 	    return JSXAttribute;

  1079 	}());

  1080 	exports.JSXAttribute = JSXAttribute;

  1081 	var JSXNamespacedName = (function () {

  1082 	    function JSXNamespacedName(namespace, name) {

  1083 	        this.type = jsx_syntax_1.JSXSyntax.JSXNamespacedName;

  1084 	        this.namespace = namespace;

  1085 	        this.name = name;

  1086 	    }

  1087 	    return JSXNamespacedName;

  1088 	}());

  1089 	exports.JSXNamespacedName = JSXNamespacedName;

  1090 	var JSXOpeningElement = (function () {

  1091 	    function JSXOpeningElement(name, selfClosing, attributes) {

  1092 	        this.type = jsx_syntax_1.JSXSyntax.JSXOpeningElement;

  1093 	        this.name = name;

  1094 	        this.selfClosing = selfClosing;

  1095 	        this.attributes = attributes;

  1096 	    }

  1097 	    return JSXOpeningElement;

  1098 	}());

  1099 	exports.JSXOpeningElement = JSXOpeningElement;

  1100 	var JSXSpreadAttribute = (function () {

  1101 	    function JSXSpreadAttribute(argument) {

  1102 	        this.type = jsx_syntax_1.JSXSyntax.JSXSpreadAttribute;

  1103 	        this.argument = argument;

  1104 	    }

  1105 	    return JSXSpreadAttribute;

  1106 	}());

  1107 	exports.JSXSpreadAttribute = JSXSpreadAttribute;

  1108 	var JSXText = (function () {

  1109 	    function JSXText(value, raw) {

  1110 	        this.type = jsx_syntax_1.JSXSyntax.JSXText;

  1111 	        this.value = value;

  1112 	        this.raw = raw;

  1113 	    }

  1114 	    return JSXText;

  1115 	}());

  1116 	exports.JSXText = JSXText;

  1117 

  1118 

  1119 /***/ },

  1120 /* 6 */

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

  1122 

  1123 	"use strict";

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

  1125 	exports.JSXSyntax = {

  1126 	    JSXAttribute: 'JSXAttribute',

  1127 	    JSXClosingElement: 'JSXClosingElement',

  1128 	    JSXElement: 'JSXElement',

  1129 	    JSXEmptyExpression: 'JSXEmptyExpression',

  1130 	    JSXExpressionContainer: 'JSXExpressionContainer',

  1131 	    JSXIdentifier: 'JSXIdentifier',

  1132 	    JSXMemberExpression: 'JSXMemberExpression',

  1133 	    JSXNamespacedName: 'JSXNamespacedName',

  1134 	    JSXOpeningElement: 'JSXOpeningElement',

  1135 	    JSXSpreadAttribute: 'JSXSpreadAttribute',

  1136 	    JSXText: 'JSXText'