[WIP] Add support for running Node tests against build output

Stack traces still need work
diff --git a/lib/src/bootstrap/node.dart b/lib/src/bootstrap/node.dart
index baf4283..d56e87a 100644
--- a/lib/src/bootstrap/node.dart
+++ b/lib/src/bootstrap/node.dart
@@ -2,14 +2,29 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+@JS()
+library test.src.bootstrap.node;
+
+import 'package:js/js.dart';
+import 'package:package_resolver/package_resolver.dart';
+
+import "../runner/browser/lazy_mapping.dart";
 import "../runner/plugin/remote_platform_helpers.dart";
 import "../runner/node/socket_channel.dart";
+import '../util/stack_trace_mapper.dart';
+
+@JS('\$dartTestGetSourceMap')
+external Object _getSourceMap(String module);
 
 /// Bootstraps a browser test to communicate with the test runner.
 ///
 /// This should NOT be used directly, instead use the `test/pub_serve`
 /// transformer which will bootstrap your test and call this method.
 void internalBootstrapNodeTest(Function getMain()) {
-  var channel = serializeSuite(getMain);
+  var channel = serializeSuite(getMain,
+      stackTraceMapper: _getSourceMap == null
+          ? null
+          : new StackTraceMapper.parsed(new LazyMapping(),
+              packageResolver: new SyncPackageResolver.root('packages/')));
   socketChannel().pipe(channel);
 }
diff --git a/lib/src/runner/browser/lazy_mapping.dart b/lib/src/runner/browser/lazy_mapping.dart
index 7f4f67a..4b9f045 100644
--- a/lib/src/runner/browser/lazy_mapping.dart
+++ b/lib/src/runner/browser/lazy_mapping.dart
@@ -13,7 +13,7 @@
 @JS('\$dartTestGetSourceMap')
 external Object _getSourceMap(String module);
 
-/// The URL beneath which test files are served.
+/// The URL beneath which test files are served on the browser.
 final _rootUrl = p.joinAll(p.split(p.current).take(2));
 
 /// A source mapping that loads source maps as-needed using [_getSourceMap].
diff --git a/lib/src/runner/build.dart b/lib/src/runner/build.dart
index bd01381..36ef45b 100644
--- a/lib/src/runner/build.dart
+++ b/lib/src/runner/build.dart
@@ -12,7 +12,7 @@
 import '../util/io.dart';
 
 /// The directory in which the build package generates output.
-final generatedDir = '.dart_tool/build/generated';
+final generatedDir = p.absolute('.dart_tool/build/generated');
 
 /// Whether this package uses the build package.
 final isInUse = new Directory(generatedDir).existsSync();
diff --git a/lib/src/runner/node/platform.dart b/lib/src/runner/node/platform.dart
index 8d15478..fda1d6c 100644
--- a/lib/src/runner/node/platform.dart
+++ b/lib/src/runner/node/platform.dart
@@ -4,6 +4,7 @@
 
 import 'dart:async';
 import 'dart:io';
+import 'dart:isolate';
 import 'dart:convert';
 
 import 'package:async/async.dart';
@@ -14,11 +15,13 @@
 import 'package:stream_channel/stream_channel.dart';
 import 'package:yaml/yaml.dart';
 
+import '../../backend/compiler.dart';
 import '../../backend/test_platform.dart';
 import '../../util/io.dart';
 import '../../util/stack_trace_mapper.dart';
 import '../../utils.dart';
 import '../application_exception.dart';
+import '../build.dart' as build;
 import '../compiler_pool.dart';
 import '../configuration.dart';
 import '../configuration/suite.dart';
@@ -79,7 +82,9 @@
       SuiteConfiguration suiteConfig, Object message) async {
     assert(platform == TestPlatform.nodeJS);
 
-    var pair = await _loadChannel(path, platform, suiteConfig);
+    var compiler = Compiler.find((message as Map)['compiler'] as String);
+
+    var pair = await _loadChannel(path, platform, compiler, suiteConfig);
     var controller = await deserializeSuite(path, platform, suiteConfig,
         new PluginEnvironment(), pair.first, message,
         mapper: pair.last);
@@ -90,11 +95,15 @@
   ///
   /// Returns that channel along with a [StackTraceMapper] representing the
   /// source map for the compiled suite.
-  Future<Pair<StreamChannel, StackTraceMapper>> _loadChannel(String path,
-      TestPlatform platform, SuiteConfiguration suiteConfig) async {
+  Future<Pair<StreamChannel, StackTraceMapper>> _loadChannel(
+      String path,
+      TestPlatform platform,
+      Compiler compiler,
+      SuiteConfiguration suiteConfig) async {
     var server = await MultiServerSocket.loopback(0);
 
-    var pair = await _spawnProcess(path, platform, suiteConfig, server.port);
+    var pair =
+        await _spawnProcess(path, platform, compiler, suiteConfig, server.port);
     var process = pair.first;
 
     // Forward Node's standard IO to the print handler so it's associated with
@@ -126,21 +135,99 @@
   Future<Pair<Process, StackTraceMapper>> _spawnProcess(
       String path,
       TestPlatform platform,
+      Compiler compiler,
       SuiteConfiguration suiteConfig,
       int socketPort) async {
     var dir = new Directory(_compiledDir).createTempSync('test_').path;
     var jsPath = p.join(dir, p.basename(path) + ".node_test.dart.js");
 
     StackTraceMapper mapper;
-    if (_config.pubServeUrl == null) {
-      mapper = await _compileSuite(path, jsPath, suiteConfig);
-    } else {
+    if (_config.pubServeUrl != null) {
       mapper = await _downloadPubServeSuite(path, jsPath, suiteConfig);
+    } else if (compiler == Compiler.build) {
+      await _writeBuildSuite(path, jsPath);
+    } else {
+      mapper = await _compileSuite(path, jsPath, suiteConfig);
     }
 
     return new Pair(await _startProcess(platform, jsPath, socketPort), mapper);
   }
 
+  /// Compiles the test suite at [dartPath] to JavaScript at [jsPath] from `pub
+  /// serve`.
+  ///
+  /// If [suiteConfig.jsTrace] is `true`, returns a [StackTraceMapper] that will
+  /// convert JS stack traces to Dart.
+  Future<StackTraceMapper> _downloadPubServeSuite(
+      String dartPath, String jsPath, SuiteConfiguration suiteConfig) async {
+    var url = _config.pubServeUrl.resolveUri(
+        p.toUri(p.relative(dartPath, from: 'test') + '.node_test.dart.js'));
+
+    var js = await _get(url, dartPath);
+    await new File(jsPath)
+        .writeAsString(preamble.getPreamble(minified: true) + js);
+    if (suiteConfig.jsTrace) return null;
+
+    var mapUrl = url.replace(path: url.path + '.map');
+    return new StackTraceMapper(await _get(mapUrl, dartPath),
+        mapUrl: mapUrl,
+        packageResolver: new SyncPackageResolver.root('packages'),
+        sdkRoot: p.toUri('packages/\$sdk'));
+  }
+
+  Future _writeBuildSuite(String dartPath, String jsPath) async {
+    var bootstrapPath = await _compileBootstrap();
+
+    var modulePaths = {
+      "dart_sdk": p.join(sdkDir, 'lib/dev_compiler/amd/dart_sdk'),
+      "packages/test/src/bootstrap/node": p.withoutExtension(bootstrapPath)
+    };
+    for (var path in build.ddcModules) {
+      var components = p.split(p.relative(path, from: build.generatedDir));
+      Uri module;
+      if (components[1] == 'lib') {
+        var package = components.first;
+        var pathInLib = p.joinAll(components.skip(2));
+        module = p.toUri(p.join('packages', package, pathInLib));
+      } else {
+        assert(components.first == rootPackageName);
+        module = p.toUri(p.joinAll(components.skip(1)));
+      }
+      modulePaths[module.toString()] = p.absolute("$path.ddc");
+    }
+
+    var moduleName = p.withoutExtension(dartPath);
+
+    var requires = [moduleName, "packages/test/src/bootstrap/node", "dart_sdk"];
+    var moduleIdentifier =
+        p.url.split(moduleName).skip(1).join('__').replaceAll('.', '\$46');
+
+    var requirejsPath = p.fromUri(await Isolate.resolvePackageUri(
+        Uri.parse('package:test/src/runner/node/vendor/r.js')));
+
+    new File(jsPath).writeAsStringSync('''
+      ${preamble.getPreamble()}
+
+      (function() {
+        let requirejs = require(${JSON.encode(requirejsPath)});
+        requirejs.config({waitSeconds: 0, paths: ${JSON.encode(modulePaths)}});
+
+        requirejs(${JSON.encode(requires)}, function(app, bootstrap, dart_sdk) {
+          dart_sdk._isolate_helper.startRootIsolate(() => {}, []);
+          dart_sdk._debugger.registerDevtoolsFormatter();
+          dart_sdk.dart.global = self;
+          global.self = self;
+          self.\$dartTestGetSourceMap = dart_sdk.dart.getSourceMap;
+
+          bootstrap.src__bootstrap__node.internalBootstrapNodeTest(
+              function() {
+            return app.$moduleIdentifier.main;
+          });
+        });
+      })();
+    ''');
+  }
+
   /// Compiles the test suite at [dartPath] to JavaScript at [jsPath] using
   /// dart2js.
   ///
@@ -172,28 +259,6 @@
         sdkRoot: p.toUri(sdkDir));
   }
 
-  /// Compiles the test suite at [dartPath] to JavaScript at [jsPath] from `pub
-  /// serve`.
-  ///
-  /// If [suiteConfig.jsTrace] is `true`, returns a [StackTraceMapper] that will
-  /// convert JS stack traces to Dart.
-  Future<StackTraceMapper> _downloadPubServeSuite(
-      String dartPath, String jsPath, SuiteConfiguration suiteConfig) async {
-    var url = _config.pubServeUrl.resolveUri(
-        p.toUri(p.relative(dartPath, from: 'test') + '.node_test.dart.js'));
-
-    var js = await _get(url, dartPath);
-    await new File(jsPath)
-        .writeAsString(preamble.getPreamble(minified: true) + js);
-    if (suiteConfig.jsTrace) return null;
-
-    var mapUrl = url.replace(path: url.path + '.map');
-    return new StackTraceMapper(await _get(mapUrl, dartPath),
-        mapUrl: mapUrl,
-        packageResolver: new SyncPackageResolver.root('packages'),
-        sdkRoot: p.toUri('packages/\$sdk'));
-  }
-
   /// Starts the Node.js process for [platform] with [jsPath].
   Future<Process> _startProcess(
       TestPlatform platform, String jsPath, int socketPort) async {
@@ -216,6 +281,23 @@
     }
   }
 
+  /// Compiles "package:test/src/bootstrap/node.dart" to JS using DDC and
+  /// returns the path to the compiled result.
+  Future<String> _compileBootstrap() async {
+    // Pass the error through a result to avoid cross-zone issues.
+    var result = await _compileBootstrapMemo.runOnce(() {
+      return Result.capture(new Future(() async {
+        var js = await build.compile("package:test/src/bootstrap/node.dart");
+        var jsPath = p.join(_compiledDir, 'bootstrap.dart.js');
+        new File(jsPath).writeAsStringSync(js);
+        return jsPath;
+      }));
+    });
+    return await result.asFuture;
+  }
+
+  final _compileBootstrapMemo = new AsyncMemoizer<Result<String>>();
+
   /// Runs an HTTP GET on [url].
   ///
   /// If this fails, throws a [LoadException] for [suitePath].
diff --git a/lib/src/runner/node/vendor/r.js b/lib/src/runner/node/vendor/r.js
new file mode 100644
index 0000000..d8c8dc4
--- /dev/null
+++ b/lib/src/runner/node/vendor/r.js
@@ -0,0 +1,30419 @@
+/**
+ * @license r.js 2.3.5 Copyright jQuery Foundation and other contributors.
+ * Released under MIT license, http://github.com/requirejs/r.js/LICENSE
+ */
+
+/*
+ * This is a bootstrap script to allow running RequireJS in the command line
+ * in either a Java/Rhino or Node environment. It is modified by the top-level
+ * dist.js file to inject other files to completely enable this file. It is
+ * the shell of the r.js file.
+ */
+
+/*jslint evil: true, nomen: true, sloppy: true */
+/*global readFile: true, process: false, Packages: false, print: false,
+console: false, java: false, module: false, requirejsVars, navigator,
+document, importScripts, self, location, Components, FileUtils */
+
+var requirejs, require, define, xpcUtil;
+(function (console, args, readFileFunc) {
+    var fileName, env, fs, vm, path, exec, rhinoContext, dir, nodeRequire,
+        nodeDefine, exists, reqMain, loadedOptimizedLib, existsForNode, Cc, Ci,
+        version = '2.3.5',
+        jsSuffixRegExp = /\.js$/,
+        commandOption = '',
+        useLibLoaded = {},
+        //Used by jslib/rhino/args.js
+        rhinoArgs = args,
+        //Used by jslib/xpconnect/args.js
+        xpconnectArgs = args,
+        readFile = typeof readFileFunc !== 'undefined' ? readFileFunc : null;
+
+    function showHelp() {
+        console.log('See https://github.com/requirejs/r.js for usage.');
+    }
+
+    if (typeof process !== 'undefined' && process.versions && !!process.versions.node) {
+        env = 'node';
+
+        //Get the fs module via Node's require before it
+        //gets replaced. Used in require/node.js
+        fs = require('fs');
+        vm = require('vm');
+        path = require('path');
+        //In Node 0.7+ existsSync is on fs.
+        existsForNode = fs.existsSync || path.existsSync;
+
+        nodeRequire = require;
+        nodeDefine = define;
+        reqMain = require.main;
+
+        //Temporarily hide require and define to allow require.js to define
+        //them.
+        require = undefined;
+        define = undefined;
+
+        readFile = function (path) {
+            return fs.readFileSync(path, 'utf8');
+        };
+
+        exec = function (string, name) {
+            return vm.runInThisContext(this.requirejsVars.require.makeNodeWrapper(string),
+                                       name ? fs.realpathSync(name) : '');
+        };
+
+        exists = function (fileName) {
+            return existsForNode(fileName);
+        };
+
+
+        fileName = process.argv[2];
+
+        if (fileName && fileName.indexOf('-') === 0) {
+            commandOption = fileName.substring(1);
+            fileName = process.argv[3];
+        }
+    } else if (typeof Packages !== 'undefined') {
+        env = 'rhino';
+
+        fileName = args[0];
+
+        if (fileName && fileName.indexOf('-') === 0) {
+            commandOption = fileName.substring(1);
+            fileName = args[1];
+        }
+
+        //Exec/readFile differs between Rhino and Nashorn. Rhino has an
+        //importPackage where Nashorn does not, so branch on that. This is a
+        //coarser check -- detecting readFile existence might also be enough for
+        //this spot. However, sticking with importPackage to keep it the same
+        //as other Rhino/Nashorn detection branches.
+        if (typeof importPackage !== 'undefined') {
+            rhinoContext = Packages.org.mozilla.javascript.ContextFactory.getGlobal().enterContext();
+
+            exec = function (string, name) {
+                return rhinoContext.evaluateString(this, string, name, 0, null);
+            };
+        } else {
+            exec = function (string, name) {
+                load({ script: string, name: name});
+            };
+            readFile = readFully;
+        }
+
+        exists = function (fileName) {
+            return (new java.io.File(fileName)).exists();
+        };
+
+        //Define a console.log for easier logging. Don't
+        //get fancy though.
+        if (typeof console === 'undefined') {
+            console = {
+                log: function () {
+                    print.apply(undefined, arguments);
+                }
+            };
+        }
+    } else if ((typeof navigator !== 'undefined' && typeof document !== 'undefined') ||
+            (typeof importScripts !== 'undefined' && typeof self !== 'undefined')) {
+        env = 'browser';
+
+        readFile = function (path) {
+            return fs.readFileSync(path, 'utf8');
+        };
+
+        exec = function (string) {
+            return eval(string);
+        };
+
+        exists = function () {
+            console.log('x.js exists not applicable in browser env');
+            return false;
+        };
+
+    } else if (typeof Components !== 'undefined' && Components.classes && Components.interfaces) {
+        env = 'xpconnect';
+
+        Components.utils['import']('resource://gre/modules/FileUtils.jsm');
+        Cc = Components.classes;
+        Ci = Components.interfaces;
+
+        fileName = args[0];
+
+        if (fileName && fileName.indexOf('-') === 0) {
+            commandOption = fileName.substring(1);
+            fileName = args[1];
+        }
+
+        xpcUtil = {
+            isWindows: ('@mozilla.org/windows-registry-key;1' in Cc),
+            cwd: function () {
+                return FileUtils.getFile("CurWorkD", []).path;
+            },
+
+            //Remove . and .. from paths, normalize on front slashes
+            normalize: function (path) {
+                //There has to be an easier way to do this.
+                var i, part, ary,
+                    firstChar = path.charAt(0);
+
+                if (firstChar !== '/' &&
+                        firstChar !== '\\' &&
+                        path.indexOf(':') === -1) {
+                    //A relative path. Use the current working directory.
+                    path = xpcUtil.cwd() + '/' + path;
+                }
+
+                ary = path.replace(/\\/g, '/').split('/');
+
+                for (i = 0; i < ary.length; i += 1) {
+                    part = ary[i];
+                    if (part === '.') {
+                        ary.splice(i, 1);
+                        i -= 1;
+                    } else if (part === '..') {
+                        ary.splice(i - 1, 2);
+                        i -= 2;
+                    }
+                }
+                return ary.join('/');
+            },
+
+            xpfile: function (path) {
+                var fullPath;
+                try {
+                    fullPath = xpcUtil.normalize(path);
+                    if (xpcUtil.isWindows) {
+                        fullPath = fullPath.replace(/\//g, '\\');
+                    }
+                    return new FileUtils.File(fullPath);
+                } catch (e) {
+                    throw new Error((fullPath || path) + ' failed: ' + e);
+                }
+            },
+
+            readFile: function (/*String*/path, /*String?*/encoding) {
+                //A file read function that can deal with BOMs
+                encoding = encoding || "utf-8";
+
+                var inStream, convertStream,
+                    readData = {},
+                    fileObj = xpcUtil.xpfile(path);
+
+                //XPCOM, you so crazy
+                try {
+                    inStream = Cc['@mozilla.org/network/file-input-stream;1']
+                               .createInstance(Ci.nsIFileInputStream);
+                    inStream.init(fileObj, 1, 0, false);
+
+                    convertStream = Cc['@mozilla.org/intl/converter-input-stream;1']
+                                    .createInstance(Ci.nsIConverterInputStream);
+                    convertStream.init(inStream, encoding, inStream.available(),
+                    Ci.nsIConverterInputStream.DEFAULT_REPLACEMENT_CHARACTER);
+
+                    convertStream.readString(inStream.available(), readData);
+                    return readData.value;
+                } catch (e) {
+                    throw new Error((fileObj && fileObj.path || '') + ': ' + e);
+                } finally {
+                    if (convertStream) {
+                        convertStream.close();
+                    }
+                    if (inStream) {
+                        inStream.close();
+                    }
+                }
+            }
+        };
+
+        readFile = xpcUtil.readFile;
+
+        exec = function (string) {
+            return eval(string);
+        };
+
+        exists = function (fileName) {
+            return xpcUtil.xpfile(fileName).exists();
+        };
+
+        //Define a console.log for easier logging. Don't
+        //get fancy though.
+        if (typeof console === 'undefined') {
+            console = {
+                log: function () {
+                    print.apply(undefined, arguments);
+                }
+            };
+        }
+    }
+
+    /** vim: et:ts=4:sw=4:sts=4
+ * @license RequireJS 2.3.5 Copyright jQuery Foundation and other contributors.
+ * Released under MIT license, https://github.com/requirejs/requirejs/blob/master/LICENSE
+ */
+//Not using strict: uneven strict support in browsers, #392, and causes
+//problems with requirejs.exec()/transpiler plugins that may not be strict.
+/*jslint regexp: true, nomen: true, sloppy: true */
+/*global window, navigator, document, importScripts, setTimeout, opera */
+
+
+(function (global, setTimeout) {
+    var req, s, head, baseElement, dataMain, src,
+        interactiveScript, currentlyAddingScript, mainScript, subPath,
+        version = '2.3.5',
+        commentRegExp = /\/\*[\s\S]*?\*\/|([^:"'=]|^)\/\/.*$/mg,
+        cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,
+        jsSuffixRegExp = /\.js$/,
+        currDirRegExp = /^\.\//,
+        op = Object.prototype,
+        ostring = op.toString,
+        hasOwn = op.hasOwnProperty,
+        isBrowser = !!(typeof window !== 'undefined' && typeof navigator !== 'undefined' && window.document),
+        isWebWorker = !isBrowser && typeof importScripts !== 'undefined',
+        //PS3 indicates loaded and complete, but need to wait for complete
+        //specifically. Sequence is 'loading', 'loaded', execution,
+        // then 'complete'. The UA check is unfortunate, but not sure how
+        //to feature test w/o causing perf issues.
+        readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ?
+                      /^complete$/ : /^(complete|loaded)$/,
+        defContextName = '_',
+        //Oh the tragedy, detecting opera. See the usage of isOpera for reason.
+        isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]',
+        contexts = {},
+        cfg = {},
+        globalDefQueue = [],
+        useInteractive = false;
+
+    //Could match something like ')//comment', do not lose the prefix to comment.
+    function commentReplace(match, singlePrefix) {
+        return singlePrefix || '';
+    }
+
+    function isFunction(it) {
+        return ostring.call(it) === '[object Function]';
+    }
+
+    function isArray(it) {
+        return ostring.call(it) === '[object Array]';
+    }
+
+    /**
+     * Helper function for iterating over an array. If the func returns
+     * a true value, it will break out of the loop.
+     */
+    function each(ary, func) {
+        if (ary) {
+            var i;
+            for (i = 0; i < ary.length; i += 1) {
+                if (ary[i] && func(ary[i], i, ary)) {
+                    break;
+                }
+            }
+        }
+    }
+
+    /**
+     * Helper function for iterating over an array backwards. If the func
+     * returns a true value, it will break out of the loop.
+     */
+    function eachReverse(ary, func) {
+        if (ary) {
+            var i;
+            for (i = ary.length - 1; i > -1; i -= 1) {
+                if (ary[i] && func(ary[i], i, ary)) {
+                    break;
+                }
+            }
+        }
+    }
+
+    function hasProp(obj, prop) {
+        return hasOwn.call(obj, prop);
+    }
+
+    function getOwn(obj, prop) {
+        return hasProp(obj, prop) && obj[prop];
+    }
+
+    /**
+     * Cycles over properties in an object and calls a function for each
+     * property value. If the function returns a truthy value, then the
+     * iteration is stopped.
+     */
+    function eachProp(obj, func) {
+        var prop;
+        for (prop in obj) {
+            if (hasProp(obj, prop)) {
+                if (func(obj[prop], prop)) {
+                    break;
+                }
+            }
+        }
+    }
+
+    /**
+     * Simple function to mix in properties from source into target,
+     * but only if target does not already have a property of the same name.
+     */
+    function mixin(target, source, force, deepStringMixin) {
+        if (source) {
+            eachProp(source, function (value, prop) {
+                if (force || !hasProp(target, prop)) {
+                    if (deepStringMixin && typeof value === 'object' && value &&
+                        !isArray(value) && !isFunction(value) &&
+                        !(value instanceof RegExp)) {
+
+                        if (!target[prop]) {
+                            target[prop] = {};
+                        }
+                        mixin(target[prop], value, force, deepStringMixin);
+                    } else {
+                        target[prop] = value;
+                    }
+                }
+            });
+        }
+        return target;
+    }
+
+    //Similar to Function.prototype.bind, but the 'this' object is specified
+    //first, since it is easier to read/figure out what 'this' will be.
+    function bind(obj, fn) {
+        return function () {
+            return fn.apply(obj, arguments);
+        };
+    }
+
+    function scripts() {
+        return document.getElementsByTagName('script');
+    }
+
+    function defaultOnError(err) {
+        throw err;
+    }
+
+    //Allow getting a global that is expressed in
+    //dot notation, like 'a.b.c'.
+    function getGlobal(value) {
+        if (!value) {
+            return value;
+        }
+        var g = global;
+        each(value.split('.'), function (part) {
+            g = g[part];
+        });
+        return g;
+    }
+
+    /**
+     * Constructs an error with a pointer to an URL with more information.
+     * @param {String} id the error ID that maps to an ID on a web page.
+     * @param {String} message human readable error.
+     * @param {Error} [err] the original error, if there is one.
+     *
+     * @returns {Error}
+     */
+    function makeError(id, msg, err, requireModules) {
+        var e = new Error(msg + '\nhttp://requirejs.org/docs/errors.html#' + id);
+        e.requireType = id;
+        e.requireModules = requireModules;
+        if (err) {
+            e.originalError = err;
+        }
+        return e;
+    }
+
+    if (typeof define !== 'undefined') {
+        //If a define is already in play via another AMD loader,
+        //do not overwrite.
+        return;
+    }
+
+    if (typeof requirejs !== 'undefined') {
+        if (isFunction(requirejs)) {
+            //Do not overwrite an existing requirejs instance.
+            return;
+        }
+        cfg = requirejs;
+        requirejs = undefined;
+    }
+
+    //Allow for a require config object
+    if (typeof require !== 'undefined' && !isFunction(require)) {
+        //assume it is a config object.
+        cfg = require;
+        require = undefined;
+    }
+
+    function newContext(contextName) {
+        var inCheckLoaded, Module, context, handlers,
+            checkLoadedTimeoutId,
+            config = {
+                //Defaults. Do not set a default for map
+                //config to speed up normalize(), which
+                //will run faster if there is no default.
+                waitSeconds: 7,
+                baseUrl: './',
+                paths: {},
+                bundles: {},
+                pkgs: {},
+                shim: {},
+                config: {}
+            },
+            registry = {},
+            //registry of just enabled modules, to speed
+            //cycle breaking code when lots of modules
+            //are registered, but not activated.
+            enabledRegistry = {},
+            undefEvents = {},
+            defQueue = [],
+            defined = {},
+            urlFetched = {},
+            bundlesMap = {},
+            requireCounter = 1,
+            unnormalizedCounter = 1;
+
+        /**
+         * Trims the . and .. from an array of path segments.
+         * It will keep a leading path segment if a .. will become
+         * the first path segment, to help with module name lookups,
+         * which act like paths, but can be remapped. But the end result,
+         * all paths that use this function should look normalized.
+         * NOTE: this method MODIFIES the input array.
+         * @param {Array} ary the array of path segments.
+         */
+        function trimDots(ary) {
+            var i, part;
+            for (i = 0; i < ary.length; i++) {
+                part = ary[i];
+                if (part === '.') {
+                    ary.splice(i, 1);
+                    i -= 1;
+                } else if (part === '..') {
+                    // If at the start, or previous value is still ..,
+                    // keep them so that when converted to a path it may
+                    // still work when converted to a path, even though
+                    // as an ID it is less than ideal. In larger point
+                    // releases, may be better to just kick out an error.
+                    if (i === 0 || (i === 1 && ary[2] === '..') || ary[i - 1] === '..') {
+                        continue;
+                    } else if (i > 0) {
+                        ary.splice(i - 1, 2);
+                        i -= 2;
+                    }
+                }
+            }
+        }
+
+        /**
+         * Given a relative module name, like ./something, normalize it to
+         * a real name that can be mapped to a path.
+         * @param {String} name the relative name
+         * @param {String} baseName a real name that the name arg is relative
+         * to.
+         * @param {Boolean} applyMap apply the map config to the value. Should
+         * only be done if this normalization is for a dependency ID.
+         * @returns {String} normalized name
+         */
+        function normalize(name, baseName, applyMap) {
+            var pkgMain, mapValue, nameParts, i, j, nameSegment, lastIndex,
+                foundMap, foundI, foundStarMap, starI, normalizedBaseParts,
+                baseParts = (baseName && baseName.split('/')),
+                map = config.map,
+                starMap = map && map['*'];
+
+            //Adjust any relative paths.
+            if (name) {
+                name = name.split('/');
+                lastIndex = name.length - 1;
+
+                // If wanting node ID compatibility, strip .js from end
+                // of IDs. Have to do this here, and not in nameToUrl
+                // because node allows either .js or non .js to map
+                // to same file.
+                if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
+                    name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
+                }
+
+                // Starts with a '.' so need the baseName
+                if (name[0].charAt(0) === '.' && baseParts) {
+                    //Convert baseName to array, and lop off the last part,
+                    //so that . matches that 'directory' and not name of the baseName's
+                    //module. For instance, baseName of 'one/two/three', maps to
+                    //'one/two/three.js', but we want the directory, 'one/two' for
+                    //this normalization.
+                    normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
+                    name = normalizedBaseParts.concat(name);
+                }
+
+                trimDots(name);
+                name = name.join('/');
+            }
+
+            //Apply map config if available.
+            if (applyMap && map && (baseParts || starMap)) {
+                nameParts = name.split('/');
+
+                outerLoop: for (i = nameParts.length; i > 0; i -= 1) {
+                    nameSegment = nameParts.slice(0, i).join('/');
+
+                    if (baseParts) {
+                        //Find the longest baseName segment match in the config.
+                        //So, do joins on the biggest to smallest lengths of baseParts.
+                        for (j = baseParts.length; j > 0; j -= 1) {
+                            mapValue = getOwn(map, baseParts.slice(0, j).join('/'));
+
+                            //baseName segment has config, find if it has one for
+                            //this name.
+                            if (mapValue) {
+                                mapValue = getOwn(mapValue, nameSegment);
+                                if (mapValue) {
+                                    //Match, update name to the new value.
+                                    foundMap = mapValue;
+                                    foundI = i;
+                                    break outerLoop;
+                                }
+                            }
+                        }
+                    }
+
+                    //Check for a star map match, but just hold on to it,
+                    //if there is a shorter segment match later in a matching
+                    //config, then favor over this star map.
+                    if (!foundStarMap && starMap && getOwn(starMap, nameSegment)) {
+                        foundStarMap = getOwn(starMap, nameSegment);
+                        starI = i;
+                    }
+                }
+
+                if (!foundMap && foundStarMap) {
+                    foundMap = foundStarMap;
+                    foundI = starI;
+                }
+
+                if (foundMap) {
+                    nameParts.splice(0, foundI, foundMap);
+                    name = nameParts.join('/');
+                }
+            }
+
+            // If the name points to a package's name, use
+            // the package main instead.
+            pkgMain = getOwn(config.pkgs, name);
+
+            return pkgMain ? pkgMain : name;
+        }
+
+        function removeScript(name) {
+            if (isBrowser) {
+                each(scripts(), function (scriptNode) {
+                    if (scriptNode.getAttribute('data-requiremodule') === name &&
+                            scriptNode.getAttribute('data-requirecontext') === context.contextName) {
+                        scriptNode.parentNode.removeChild(scriptNode);
+                        return true;
+                    }
+                });
+            }
+        }
+
+        function hasPathFallback(id) {
+            var pathConfig = getOwn(config.paths, id);
+            if (pathConfig && isArray(pathConfig) && pathConfig.length > 1) {
+                //Pop off the first array value, since it failed, and
+                //retry
+                pathConfig.shift();
+                context.require.undef(id);
+
+                //Custom require that does not do map translation, since
+                //ID is "absolute", already mapped/resolved.
+                context.makeRequire(null, {
+                    skipMap: true
+                })([id]);
+
+                return true;
+            }
+        }
+
+        //Turns a plugin!resource to [plugin, resource]
+        //with the plugin being undefined if the name
+        //did not have a plugin prefix.
+        function splitPrefix(name) {
+            var prefix,
+                index = name ? name.indexOf('!') : -1;
+            if (index > -1) {
+                prefix = name.substring(0, index);
+                name = name.substring(index + 1, name.length);
+            }
+            return [prefix, name];
+        }
+
+        /**
+         * Creates a module mapping that includes plugin prefix, module
+         * name, and path. If parentModuleMap is provided it will
+         * also normalize the name via require.normalize()
+         *
+         * @param {String} name the module name
+         * @param {String} [parentModuleMap] parent module map
+         * for the module name, used to resolve relative names.
+         * @param {Boolean} isNormalized: is the ID already normalized.
+         * This is true if this call is done for a define() module ID.
+         * @param {Boolean} applyMap: apply the map config to the ID.
+         * Should only be true if this map is for a dependency.
+         *
+         * @returns {Object}
+         */
+        function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {
+            var url, pluginModule, suffix, nameParts,
+                prefix = null,
+                parentName = parentModuleMap ? parentModuleMap.name : null,
+                originalName = name,
+                isDefine = true,
+                normalizedName = '';
+
+            //If no name, then it means it is a require call, generate an
+            //internal name.
+            if (!name) {
+                isDefine = false;
+                name = '_@r' + (requireCounter += 1);
+            }
+
+            nameParts = splitPrefix(name);
+            prefix = nameParts[0];
+            name = nameParts[1];
+
+            if (prefix) {
+                prefix = normalize(prefix, parentName, applyMap);
+                pluginModule = getOwn(defined, prefix);
+            }
+
+            //Account for relative paths if there is a base name.
+            if (name) {
+                if (prefix) {
+                    if (isNormalized) {
+                        normalizedName = name;
+                    } else if (pluginModule && pluginModule.normalize) {
+                        //Plugin is loaded, use its normalize method.
+                        normalizedName = pluginModule.normalize(name, function (name) {
+                            return normalize(name, parentName, applyMap);
+                        });
+                    } else {
+                        // If nested plugin references, then do not try to
+                        // normalize, as it will not normalize correctly. This
+                        // places a restriction on resourceIds, and the longer
+                        // term solution is not to normalize until plugins are
+                        // loaded and all normalizations to allow for async
+                        // loading of a loader plugin. But for now, fixes the
+                        // common uses. Details in #1131
+                        normalizedName = name.indexOf('!') === -1 ?
+                                         normalize(name, parentName, applyMap) :
+                                         name;
+                    }
+                } else {
+                    //A regular module.
+                    normalizedName = normalize(name, parentName, applyMap);
+
+                    //Normalized name may be a plugin ID due to map config
+                    //application in normalize. The map config values must
+                    //already be normalized, so do not need to redo that part.
+                    nameParts = splitPrefix(normalizedName);
+                    prefix = nameParts[0];
+                    normalizedName = nameParts[1];
+                    isNormalized = true;
+
+                    url = context.nameToUrl(normalizedName);
+                }
+            }
+
+            //If the id is a plugin id that cannot be determined if it needs
+            //normalization, stamp it with a unique ID so two matching relative
+            //ids that may conflict can be separate.
+            suffix = prefix && !pluginModule && !isNormalized ?
+                     '_unnormalized' + (unnormalizedCounter += 1) :
+                     '';
+
+            return {
+                prefix: prefix,
+                name: normalizedName,
+                parentMap: parentModuleMap,
+                unnormalized: !!suffix,
+                url: url,
+                originalName: originalName,
+                isDefine: isDefine,
+                id: (prefix ?
+                        prefix + '!' + normalizedName :
+                        normalizedName) + suffix
+            };
+        }
+
+        function getModule(depMap) {
+            var id = depMap.id,
+                mod = getOwn(registry, id);
+
+            if (!mod) {
+                mod = registry[id] = new context.Module(depMap);
+            }
+
+            return mod;
+        }
+
+        function on(depMap, name, fn) {
+            var id = depMap.id,
+                mod = getOwn(registry, id);
+
+            if (hasProp(defined, id) &&
+                    (!mod || mod.defineEmitComplete)) {
+                if (name === 'defined') {
+                    fn(defined[id]);
+                }
+            } else {
+                mod = getModule(depMap);
+                if (mod.error && name === 'error') {
+                    fn(mod.error);
+                } else {
+                    mod.on(name, fn);
+                }
+            }
+        }
+
+        function onError(err, errback) {
+            var ids = err.requireModules,
+                notified = false;
+
+            if (errback) {
+                errback(err);
+            } else {
+                each(ids, function (id) {
+                    var mod = getOwn(registry, id);
+                    if (mod) {
+                        //Set error on module, so it skips timeout checks.
+                        mod.error = err;
+                        if (mod.events.error) {
+                            notified = true;
+                            mod.emit('error', err);
+                        }
+                    }
+                });
+
+                if (!notified) {
+                    req.onError(err);
+                }
+            }
+        }
+
+        /**
+         * Internal method to transfer globalQueue items to this context's
+         * defQueue.
+         */
+        function takeGlobalQueue() {
+            //Push all the globalDefQueue items into the context's defQueue
+            if (globalDefQueue.length) {
+                each(globalDefQueue, function(queueItem) {
+                    var id = queueItem[0];
+                    if (typeof id === 'string') {
+                        context.defQueueMap[id] = true;
+                    }
+                    defQueue.push(queueItem);
+                });
+                globalDefQueue = [];
+            }
+        }
+
+        handlers = {
+            'require': function (mod) {
+                if (mod.require) {
+                    return mod.require;
+                } else {
+                    return (mod.require = context.makeRequire(mod.map));
+                }
+            },
+            'exports': function (mod) {
+                mod.usingExports = true;
+                if (mod.map.isDefine) {
+                    if (mod.exports) {
+                        return (defined[mod.map.id] = mod.exports);
+                    } else {
+                        return (mod.exports = defined[mod.map.id] = {});
+                    }
+                }
+            },
+            'module': function (mod) {
+                if (mod.module) {
+                    return mod.module;
+                } else {
+                    return (mod.module = {
+                        id: mod.map.id,
+                        uri: mod.map.url,
+                        config: function () {
+                            return getOwn(config.config, mod.map.id) || {};
+                        },
+                        exports: mod.exports || (mod.exports = {})
+                    });
+                }
+            }
+        };
+
+        function cleanRegistry(id) {
+            //Clean up machinery used for waiting modules.
+            delete registry[id];
+            delete enabledRegistry[id];
+        }
+
+        function breakCycle(mod, traced, processed) {
+            var id = mod.map.id;
+
+            if (mod.error) {
+                mod.emit('error', mod.error);
+            } else {
+                traced[id] = true;
+                each(mod.depMaps, function (depMap, i) {
+                    var depId = depMap.id,
+                        dep = getOwn(registry, depId);
+
+                    //Only force things that have not completed
+                    //being defined, so still in the registry,
+                    //and only if it has not been matched up
+                    //in the module already.
+                    if (dep && !mod.depMatched[i] && !processed[depId]) {
+                        if (getOwn(traced, depId)) {
+                            mod.defineDep(i, defined[depId]);
+                            mod.check(); //pass false?
+                        } else {
+                            breakCycle(dep, traced, processed);
+                        }
+                    }
+                });
+                processed[id] = true;
+            }
+        }
+
+        function checkLoaded() {
+            var err, usingPathFallback,
+                waitInterval = config.waitSeconds * 1000,
+                //It is possible to disable the wait interval by using waitSeconds of 0.
+                expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
+                noLoads = [],
+                reqCalls = [],
+                stillLoading = false,
+                needCycleCheck = true;
+
+            //Do not bother if this call was a result of a cycle break.
+            if (inCheckLoaded) {
+                return;
+            }
+
+            inCheckLoaded = true;
+
+            //Figure out the state of all the modules.
+            eachProp(enabledRegistry, function (mod) {
+                var map = mod.map,
+                    modId = map.id;
+
+                //Skip things that are not enabled or in error state.
+                if (!mod.enabled) {
+                    return;
+                }
+
+                if (!map.isDefine) {
+                    reqCalls.push(mod);
+                }
+
+                if (!mod.error) {
+                    //If the module should be executed, and it has not
+                    //been inited and time is up, remember it.
+                    if (!mod.inited && expired) {
+                        if (hasPathFallback(modId)) {
+                            usingPathFallback = true;
+                            stillLoading = true;
+                        } else {
+                            noLoads.push(modId);
+                            removeScript(modId);
+                        }
+                    } else if (!mod.inited && mod.fetched && map.isDefine) {
+                        stillLoading = true;
+                        if (!map.prefix) {
+                            //No reason to keep looking for unfinished
+                            //loading. If the only stillLoading is a
+                            //plugin resource though, keep going,
+                            //because it may be that a plugin resource
+                            //is waiting on a non-plugin cycle.
+                            return (needCycleCheck = false);
+                        }
+                    }
+                }
+            });
+
+            if (expired && noLoads.length) {
+                //If wait time expired, throw error of unloaded modules.
+                err = makeError('timeout', 'Load timeout for modules: ' + noLoads, null, noLoads);
+                err.contextName = context.contextName;
+                return onError(err);
+            }
+
+            //Not expired, check for a cycle.
+            if (needCycleCheck) {
+                each(reqCalls, function (mod) {
+                    breakCycle(mod, {}, {});
+                });
+            }
+
+            //If still waiting on loads, and the waiting load is something
+            //other than a plugin resource, or there are still outstanding
+            //scripts, then just try back later.
+            if ((!expired || usingPathFallback) && stillLoading) {
+                //Something is still waiting to load. Wait for it, but only
+                //if a timeout is not already in effect.
+                if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {
+                    checkLoadedTimeoutId = setTimeout(function () {
+                        checkLoadedTimeoutId = 0;
+                        checkLoaded();
+                    }, 50);
+                }
+            }
+
+            inCheckLoaded = false;
+        }
+
+        Module = function (map) {
+            this.events = getOwn(undefEvents, map.id) || {};
+            this.map = map;
+            this.shim = getOwn(config.shim, map.id);
+            this.depExports = [];
+            this.depMaps = [];
+            this.depMatched = [];
+            this.pluginMaps = {};
+            this.depCount = 0;
+
+            /* this.exports this.factory
+               this.depMaps = [],
+               this.enabled, this.fetched
+            */
+        };
+
+        Module.prototype = {
+            init: function (depMaps, factory, errback, options) {
+                options = options || {};
+
+                //Do not do more inits if already done. Can happen if there
+                //are multiple define calls for the same module. That is not
+                //a normal, common case, but it is also not unexpected.
+                if (this.inited) {
+                    return;
+                }
+
+                this.factory = factory;
+
+                if (errback) {
+                    //Register for errors on this module.
+                    this.on('error', errback);
+                } else if (this.events.error) {
+                    //If no errback already, but there are error listeners
+                    //on this module, set up an errback to pass to the deps.
+                    errback = bind(this, function (err) {
+                        this.emit('error', err);
+                    });
+                }
+
+                //Do a copy of the dependency array, so that
+                //source inputs are not modified. For example
+                //"shim" deps are passed in here directly, and
+                //doing a direct modification of the depMaps array
+                //would affect that config.
+                this.depMaps = depMaps && depMaps.slice(0);
+
+                this.errback = errback;
+
+                //Indicate this module has be initialized
+                this.inited = true;
+
+                this.ignore = options.ignore;
+
+                //Could have option to init this module in enabled mode,
+                //or could have been previously marked as enabled. However,
+                //the dependencies are not known until init is called. So
+                //if enabled previously, now trigger dependencies as enabled.
+                if (options.enabled || this.enabled) {
+                    //Enable this module and dependencies.
+                    //Will call this.check()
+                    this.enable();
+                } else {
+                    this.check();
+                }
+            },
+
+            defineDep: function (i, depExports) {
+                //Because of cycles, defined callback for a given
+                //export can be called more than once.
+                if (!this.depMatched[i]) {
+                    this.depMatched[i] = true;
+                    this.depCount -= 1;
+                    this.depExports[i] = depExports;
+                }
+            },
+
+            fetch: function () {
+                if (this.fetched) {
+                    return;
+                }
+                this.fetched = true;
+
+                context.startTime = (new Date()).getTime();
+
+                var map = this.map;
+
+                //If the manager is for a plugin managed resource,
+                //ask the plugin to load it now.
+                if (this.shim) {
+                    context.makeRequire(this.map, {
+                        enableBuildCallback: true
+                    })(this.shim.deps || [], bind(this, function () {
+                        return map.prefix ? this.callPlugin() : this.load();
+                    }));
+                } else {
+                    //Regular dependency.
+                    return map.prefix ? this.callPlugin() : this.load();
+                }
+            },
+
+            load: function () {
+                var url = this.map.url;
+
+                //Regular dependency.
+                if (!urlFetched[url]) {
+                    urlFetched[url] = true;
+                    context.load(this.map.id, url);
+                }
+            },
+
+            /**
+             * Checks if the module is ready to define itself, and if so,
+             * define it.
+             */
+            check: function () {
+                if (!this.enabled || this.enabling) {
+                    return;
+                }
+
+                var err, cjsModule,
+                    id = this.map.id,
+                    depExports = this.depExports,
+                    exports = this.exports,
+                    factory = this.factory;
+
+                if (!this.inited) {
+                    // Only fetch if not already in the defQueue.
+                    if (!hasProp(context.defQueueMap, id)) {
+                        this.fetch();
+                    }
+                } else if (this.error) {
+                    this.emit('error', this.error);
+                } else if (!this.defining) {
+                    //The factory could trigger another require call
+                    //that would result in checking this module to
+                    //define itself again. If already in the process
+                    //of doing that, skip this work.
+                    this.defining = true;
+
+                    if (this.depCount < 1 && !this.defined) {
+                        if (isFunction(factory)) {
+                            //If there is an error listener, favor passing
+                            //to that instead of throwing an error. However,
+                            //only do it for define()'d  modules. require
+                            //errbacks should not be called for failures in
+                            //their callbacks (#699). However if a global
+                            //onError is set, use that.
+                            if ((this.events.error && this.map.isDefine) ||
+                                req.onError !== defaultOnError) {
+                                try {
+                                    exports = context.execCb(id, factory, depExports, exports);
+                                } catch (e) {
+                                    err = e;
+                                }
+                            } else {
+                                exports = context.execCb(id, factory, depExports, exports);
+                            }
+
+                            // Favor return value over exports. If node/cjs in play,
+                            // then will not have a return value anyway. Favor
+                            // module.exports assignment over exports object.
+                            if (this.map.isDefine && exports === undefined) {
+                                cjsModule = this.module;
+                                if (cjsModule) {
+                                    exports = cjsModule.exports;
+                                } else if (this.usingExports) {
+                                    //exports already set the defined value.
+                                    exports = this.exports;
+                                }
+                            }
+
+                            if (err) {
+                                err.requireMap = this.map;
+                                err.requireModules = this.map.isDefine ? [this.map.id] : null;
+                                err.requireType = this.map.isDefine ? 'define' : 'require';
+                                return onError((this.error = err));
+                            }
+
+                        } else {
+                            //Just a literal value
+                            exports = factory;
+                        }
+
+                        this.exports = exports;
+
+                        if (this.map.isDefine && !this.ignore) {
+                            defined[id] = exports;
+
+                            if (req.onResourceLoad) {
+                                var resLoadMaps = [];
+                                each(this.depMaps, function (depMap) {
+                                    resLoadMaps.push(depMap.normalizedMap || depMap);
+                                });
+                                req.onResourceLoad(context, this.map, resLoadMaps);
+                            }
+                        }
+
+                        //Clean up
+                        cleanRegistry(id);
+
+                        this.defined = true;
+                    }
+
+                    //Finished the define stage. Allow calling check again
+                    //to allow define notifications below in the case of a
+                    //cycle.
+                    this.defining = false;
+
+                    if (this.defined && !this.defineEmitted) {
+                        this.defineEmitted = true;
+                        this.emit('defined', this.exports);
+                        this.defineEmitComplete = true;
+                    }
+
+                }
+            },
+
+            callPlugin: function () {
+                var map = this.map,
+                    id = map.id,
+                    //Map already normalized the prefix.
+                    pluginMap = makeModuleMap(map.prefix);
+
+                //Mark this as a dependency for this plugin, so it
+                //can be traced for cycles.
+                this.depMaps.push(pluginMap);
+
+                on(pluginMap, 'defined', bind(this, function (plugin) {
+                    var load, normalizedMap, normalizedMod,
+                        bundleId = getOwn(bundlesMap, this.map.id),
+                        name = this.map.name,
+                        parentName = this.map.parentMap ? this.map.parentMap.name : null,
+                        localRequire = context.makeRequire(map.parentMap, {
+                            enableBuildCallback: true
+                        });
+
+                    //If current map is not normalized, wait for that
+                    //normalized name to load instead of continuing.
+                    if (this.map.unnormalized) {
+                        //Normalize the ID if the plugin allows it.
+                        if (plugin.normalize) {
+                            name = plugin.normalize(name, function (name) {
+                                return normalize(name, parentName, true);
+                            }) || '';
+                        }
+
+                        //prefix and name should already be normalized, no need
+                        //for applying map config again either.
+                        normalizedMap = makeModuleMap(map.prefix + '!' + name,
+                                                      this.map.parentMap,
+                                                      true);
+                        on(normalizedMap,
+                            'defined', bind(this, function (value) {
+                                this.map.normalizedMap = normalizedMap;
+                                this.init([], function () { return value; }, null, {
+                                    enabled: true,
+                                    ignore: true
+                                });
+                            }));
+
+                        normalizedMod = getOwn(registry, normalizedMap.id);
+                        if (normalizedMod) {
+                            //Mark this as a dependency for this plugin, so it
+                            //can be traced for cycles.
+                            this.depMaps.push(normalizedMap);
+
+                            if (this.events.error) {
+                                normalizedMod.on('error', bind(this, function (err) {
+                                    this.emit('error', err);
+                                }));
+                            }
+                            normalizedMod.enable();
+                        }
+
+                        return;
+                    }
+
+                    //If a paths config, then just load that file instead to
+                    //resolve the plugin, as it is built into that paths layer.
+                    if (bundleId) {
+                        this.map.url = context.nameToUrl(bundleId);
+                        this.load();
+                        return;
+                    }
+
+                    load = bind(this, function (value) {
+                        this.init([], function () { return value; }, null, {
+                            enabled: true
+                        });
+                    });
+
+                    load.error = bind(this, function (err) {
+                        this.inited = true;
+                        this.error = err;
+                        err.requireModules = [id];
+
+                        //Remove temp unnormalized modules for this module,
+                        //since they will never be resolved otherwise now.
+                        eachProp(registry, function (mod) {
+                            if (mod.map.id.indexOf(id + '_unnormalized') === 0) {
+                                cleanRegistry(mod.map.id);
+                            }
+                        });
+
+                        onError(err);
+                    });
+
+                    //Allow plugins to load other code without having to know the
+                    //context or how to 'complete' the load.
+                    load.fromText = bind(this, function (text, textAlt) {
+                        /*jslint evil: true */
+                        var moduleName = map.name,
+                            moduleMap = makeModuleMap(moduleName),
+                            hasInteractive = useInteractive;
+
+                        //As of 2.1.0, support just passing the text, to reinforce
+                        //fromText only being called once per resource. Still
+                        //support old style of passing moduleName but discard
+                        //that moduleName in favor of the internal ref.
+                        if (textAlt) {
+                            text = textAlt;
+                        }
+
+                        //Turn off interactive script matching for IE for any define
+                        //calls in the text, then turn it back on at the end.
+                        if (hasInteractive) {
+                            useInteractive = false;
+                        }
+
+                        //Prime the system by creating a module instance for
+                        //it.
+                        getModule(moduleMap);
+
+                        //Transfer any config to this other module.
+                        if (hasProp(config.config, id)) {
+                            config.config[moduleName] = config.config[id];
+                        }
+
+                        try {
+                            req.exec(text);
+                        } catch (e) {
+                            return onError(makeError('fromtexteval',
+                                             'fromText eval for ' + id +
+                                            ' failed: ' + e,
+                                             e,
+                                             [id]));
+                        }
+
+                        if (hasInteractive) {
+                            useInteractive = true;
+                        }
+
+                        //Mark this as a dependency for the plugin
+                        //resource
+                        this.depMaps.push(moduleMap);
+
+                        //Support anonymous modules.
+                        context.completeLoad(moduleName);
+
+                        //Bind the value of that module to the value for this
+                        //resource ID.
+                        localRequire([moduleName], load);
+                    });
+
+                    //Use parentName here since the plugin's name is not reliable,
+                    //could be some weird string with no path that actually wants to
+                    //reference the parentName's path.
+                    plugin.load(map.name, localRequire, load, config);
+                }));
+
+                context.enable(pluginMap, this);
+                this.pluginMaps[pluginMap.id] = pluginMap;
+            },
+
+            enable: function () {
+                enabledRegistry[this.map.id] = this;
+                this.enabled = true;
+
+                //Set flag mentioning that the module is enabling,
+                //so that immediate calls to the defined callbacks
+                //for dependencies do not trigger inadvertent load
+                //with the depCount still being zero.
+                this.enabling = true;
+
+                //Enable each dependency
+                each(this.depMaps, bind(this, function (depMap, i) {
+                    var id, mod, handler;
+
+                    if (typeof depMap === 'string') {
+                        //Dependency needs to be converted to a depMap
+                        //and wired up to this module.
+                        depMap = makeModuleMap(depMap,
+                                               (this.map.isDefine ? this.map : this.map.parentMap),
+                                               false,
+                                               !this.skipMap);
+                        this.depMaps[i] = depMap;
+
+                        handler = getOwn(handlers, depMap.id);
+
+                        if (handler) {
+                            this.depExports[i] = handler(this);
+                            return;
+                        }
+
+                        this.depCount += 1;
+
+                        on(depMap, 'defined', bind(this, function (depExports) {
+                            if (this.undefed) {
+                                return;
+                            }
+                            this.defineDep(i, depExports);
+                            this.check();
+                        }));
+
+                        if (this.errback) {
+                            on(depMap, 'error', bind(this, this.errback));
+                        } else if (this.events.error) {
+                            // No direct errback on this module, but something
+                            // else is listening for errors, so be sure to
+                            // propagate the error correctly.
+                            on(depMap, 'error', bind(this, function(err) {
+                                this.emit('error', err);
+                            }));
+                        }
+                    }
+
+                    id = depMap.id;
+                    mod = registry[id];
+
+                    //Skip special modules like 'require', 'exports', 'module'
+                    //Also, don't call enable if it is already enabled,
+                    //important in circular dependency cases.
+                    if (!hasProp(handlers, id) && mod && !mod.enabled) {
+                        context.enable(depMap, this);
+                    }
+                }));
+
+                //Enable each plugin that is used in
+                //a dependency
+                eachProp(this.pluginMaps, bind(this, function (pluginMap) {
+                    var mod = getOwn(registry, pluginMap.id);
+                    if (mod && !mod.enabled) {
+                        context.enable(pluginMap, this);
+                    }
+                }));
+
+                this.enabling = false;
+
+                this.check();
+            },
+
+            on: function (name, cb) {
+                var cbs = this.events[name];
+                if (!cbs) {
+                    cbs = this.events[name] = [];
+                }
+                cbs.push(cb);
+            },
+
+            emit: function (name, evt) {
+                each(this.events[name], function (cb) {
+                    cb(evt);
+                });
+                if (name === 'error') {
+                    //Now that the error handler was triggered, remove
+                    //the listeners, since this broken Module instance
+                    //can stay around for a while in the registry.
+                    delete this.events[name];
+                }
+            }
+        };
+
+        function callGetModule(args) {
+            //Skip modules already defined.
+            if (!hasProp(defined, args[0])) {
+                getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2]);
+            }
+        }
+
+        function removeListener(node, func, name, ieName) {
+            //Favor detachEvent because of IE9
+            //issue, see attachEvent/addEventListener comment elsewhere
+            //in this file.
+            if (node.detachEvent && !isOpera) {
+                //Probably IE. If not it will throw an error, which will be
+                //useful to know.
+                if (ieName) {
+                    node.detachEvent(ieName, func);
+                }
+            } else {
+                node.removeEventListener(name, func, false);
+            }
+        }
+
+        /**
+         * Given an event from a script node, get the requirejs info from it,
+         * and then removes the event listeners on the node.
+         * @param {Event} evt
+         * @returns {Object}
+         */
+        function getScriptData(evt) {
+            //Using currentTarget instead of target for Firefox 2.0's sake. Not
+            //all old browsers will be supported, but this one was easy enough
+            //to support and still makes sense.
+            var node = evt.currentTarget || evt.srcElement;
+
+            //Remove the listeners once here.
+            removeListener(node, context.onScriptLoad, 'load', 'onreadystatechange');
+            removeListener(node, context.onScriptError, 'error');
+
+            return {
+                node: node,
+                id: node && node.getAttribute('data-requiremodule')
+            };
+        }
+
+        function intakeDefines() {
+            var args;
+
+            //Any defined modules in the global queue, intake them now.
+            takeGlobalQueue();
+
+            //Make sure any remaining defQueue items get properly processed.
+            while (defQueue.length) {
+                args = defQueue.shift();
+                if (args[0] === null) {
+                    return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' +
+                        args[args.length - 1]));
+                } else {
+                    //args are id, deps, factory. Should be normalized by the
+                    //define() function.
+                    callGetModule(args);
+                }
+            }
+            context.defQueueMap = {};
+        }
+
+        context = {
+            config: config,
+            contextName: contextName,
+            registry: registry,
+            defined: defined,
+            urlFetched: urlFetched,
+            defQueue: defQueue,
+            defQueueMap: {},
+            Module: Module,
+            makeModuleMap: makeModuleMap,
+            nextTick: req.nextTick,
+            onError: onError,
+
+            /**
+             * Set a configuration for the context.
+             * @param {Object} cfg config object to integrate.
+             */
+            configure: function (cfg) {
+                //Make sure the baseUrl ends in a slash.
+                if (cfg.baseUrl) {
+                    if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {
+                        cfg.baseUrl += '/';
+                    }
+                }
+
+                // Convert old style urlArgs string to a function.
+                if (typeof cfg.urlArgs === 'string') {
+                    var urlArgs = cfg.urlArgs;
+                    cfg.urlArgs = function(id, url) {
+                        return (url.indexOf('?') === -1 ? '?' : '&') + urlArgs;
+                    };
+                }
+
+                //Save off the paths since they require special processing,
+                //they are additive.
+                var shim = config.shim,
+                    objs = {
+                        paths: true,
+                        bundles: true,
+                        config: true,
+                        map: true
+                    };
+
+                eachProp(cfg, function (value, prop) {
+                    if (objs[prop]) {
+                        if (!config[prop]) {
+                            config[prop] = {};
+                        }
+                        mixin(config[prop], value, true, true);
+                    } else {
+                        config[prop] = value;
+                    }
+                });
+
+                //Reverse map the bundles
+                if (cfg.bundles) {
+                    eachProp(cfg.bundles, function (value, prop) {
+                        each(value, function (v) {
+                            if (v !== prop) {
+                                bundlesMap[v] = prop;
+                            }
+                        });
+                    });
+                }
+
+                //Merge shim
+                if (cfg.shim) {
+                    eachProp(cfg.shim, function (value, id) {
+                        //Normalize the structure
+                        if (isArray(value)) {
+                            value = {
+                                deps: value
+                            };
+                        }
+                        if ((value.exports || value.init) && !value.exportsFn) {
+                            value.exportsFn = context.makeShimExports(value);
+                        }
+                        shim[id] = value;
+                    });
+                    config.shim = shim;
+                }
+
+                //Adjust packages if necessary.
+                if (cfg.packages) {
+                    each(cfg.packages, function (pkgObj) {
+                        var location, name;
+
+                        pkgObj = typeof pkgObj === 'string' ? {name: pkgObj} : pkgObj;
+
+                        name = pkgObj.name;
+                        location = pkgObj.location;
+                        if (location) {
+                            config.paths[name] = pkgObj.location;
+                        }
+
+                        //Save pointer to main module ID for pkg name.
+                        //Remove leading dot in main, so main paths are normalized,
+                        //and remove any trailing .js, since different package
+                        //envs have different conventions: some use a module name,
+                        //some use a file name.
+                        config.pkgs[name] = pkgObj.name + '/' + (pkgObj.main || 'main')
+                                     .replace(currDirRegExp, '')
+                                     .replace(jsSuffixRegExp, '');
+                    });
+                }
+
+                //If there are any "waiting to execute" modules in the registry,
+                //update the maps for them, since their info, like URLs to load,
+                //may have changed.
+                eachProp(registry, function (mod, id) {
+                    //If module already has init called, since it is too
+                    //late to modify them, and ignore unnormalized ones
+                    //since they are transient.
+                    if (!mod.inited && !mod.map.unnormalized) {
+                        mod.map = makeModuleMap(id, null, true);
+                    }
+                });
+
+                //If a deps array or a config callback is specified, then call
+                //require with those args. This is useful when require is defined as a
+                //config object before require.js is loaded.
+                if (cfg.deps || cfg.callback) {
+                    context.require(cfg.deps || [], cfg.callback);
+                }
+            },
+
+            makeShimExports: function (value) {
+                function fn() {
+                    var ret;
+                    if (value.init) {
+                        ret = value.init.apply(global, arguments);
+                    }
+                    return ret || (value.exports && getGlobal(value.exports));
+                }
+                return fn;
+            },
+
+            makeRequire: function (relMap, options) {
+                options = options || {};
+
+                function localRequire(deps, callback, errback) {
+                    var id, map, requireMod;
+
+                    if (options.enableBuildCallback && callback && isFunction(callback)) {
+                        callback.__requireJsBuild = true;
+                    }
+
+                    if (typeof deps === 'string') {
+                        if (isFunction(callback)) {
+                            //Invalid call
+                            return onError(makeError('requireargs', 'Invalid require call'), errback);
+                        }
+
+                        //If require|exports|module are requested, get the
+                        //value for them from the special handlers. Caveat:
+                        //this only works while module is being defined.
+                        if (relMap && hasProp(handlers, deps)) {
+                            return handlers[deps](registry[relMap.id]);
+                        }
+
+                        //Synchronous access to one module. If require.get is
+                        //available (as in the Node adapter), prefer that.
+                        if (req.get) {
+                            return req.get(context, deps, relMap, localRequire);
+                        }
+
+                        //Normalize module name, if it contains . or ..
+                        map = makeModuleMap(deps, relMap, false, true);
+                        id = map.id;
+
+                        if (!hasProp(defined, id)) {
+                            return onError(makeError('notloaded', 'Module name "' +
+                                        id +
+                                        '" has not been loaded yet for context: ' +
+                                        contextName +
+                                        (relMap ? '' : '. Use require([])')));
+                        }
+                        return defined[id];
+                    }
+
+                    //Grab defines waiting in the global queue.
+                    intakeDefines();
+
+                    //Mark all the dependencies as needing to be loaded.
+                    context.nextTick(function () {
+                        //Some defines could have been added since the
+                        //require call, collect them.
+                        intakeDefines();
+
+                        requireMod = getModule(makeModuleMap(null, relMap));
+
+                        //Store if map config should be applied to this require
+                        //call for dependencies.
+                        requireMod.skipMap = options.skipMap;
+
+                        requireMod.init(deps, callback, errback, {
+                            enabled: true
+                        });
+
+                        checkLoaded();
+                    });
+
+                    return localRequire;
+                }
+
+                mixin(localRequire, {
+                    isBrowser: isBrowser,
+
+                    /**
+                     * Converts a module name + .extension into an URL path.
+                     * *Requires* the use of a module name. It does not support using
+                     * plain URLs like nameToUrl.
+                     */
+                    toUrl: function (moduleNamePlusExt) {
+                        var ext,
+                            index = moduleNamePlusExt.lastIndexOf('.'),
+                            segment = moduleNamePlusExt.split('/')[0],
+                            isRelative = segment === '.' || segment === '..';
+
+                        //Have a file extension alias, and it is not the
+                        //dots from a relative path.
+                        if (index !== -1 && (!isRelative || index > 1)) {
+                            ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
+                            moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
+                        }
+
+                        return context.nameToUrl(normalize(moduleNamePlusExt,
+                                                relMap && relMap.id, true), ext,  true);
+                    },
+
+                    defined: function (id) {
+                        return hasProp(defined, makeModuleMap(id, relMap, false, true).id);
+                    },
+
+                    specified: function (id) {
+                        id = makeModuleMap(id, relMap, false, true).id;
+                        return hasProp(defined, id) || hasProp(registry, id);
+                    }
+                });
+
+                //Only allow undef on top level require calls
+                if (!relMap) {
+                    localRequire.undef = function (id) {
+                        //Bind any waiting define() calls to this context,
+                        //fix for #408
+                        takeGlobalQueue();
+
+                        var map = makeModuleMap(id, relMap, true),
+                            mod = getOwn(registry, id);
+
+                        mod.undefed = true;
+                        removeScript(id);
+
+                        delete defined[id];
+                        delete urlFetched[map.url];
+                        delete undefEvents[id];
+
+                        //Clean queued defines too. Go backwards
+                        //in array so that the splices do not
+                        //mess up the iteration.
+                        eachReverse(defQueue, function(args, i) {
+                            if (args[0] === id) {
+                                defQueue.splice(i, 1);
+                            }
+                        });
+                        delete context.defQueueMap[id];
+
+                        if (mod) {
+                            //Hold on to listeners in case the
+                            //module will be attempted to be reloaded
+                            //using a different config.
+                            if (mod.events.defined) {
+                                undefEvents[id] = mod.events;
+                            }
+
+                            cleanRegistry(id);
+                        }
+                    };
+                }
+
+                return localRequire;
+            },
+
+            /**
+             * Called to enable a module if it is still in the registry
+             * awaiting enablement. A second arg, parent, the parent module,
+             * is passed in for context, when this method is overridden by
+             * the optimizer. Not shown here to keep code compact.
+             */
+            enable: function (depMap) {
+                var mod = getOwn(registry, depMap.id);
+                if (mod) {
+                    getModule(depMap).enable();
+                }
+            },
+
+            /**
+             * Internal method used by environment adapters to complete a load event.
+             * A load event could be a script load or just a load pass from a synchronous
+             * load call.
+             * @param {String} moduleName the name of the module to potentially complete.
+             */
+            completeLoad: function (moduleName) {
+                var found, args, mod,
+                    shim = getOwn(config.shim, moduleName) || {},
+                    shExports = shim.exports;
+
+                takeGlobalQueue();
+
+                while (defQueue.length) {
+                    args = defQueue.shift();
+                    if (args[0] === null) {
+                        args[0] = moduleName;
+                        //If already found an anonymous module and bound it
+                        //to this name, then this is some other anon module
+                        //waiting for its completeLoad to fire.
+                        if (found) {
+                            break;
+                        }
+                        found = true;
+                    } else if (args[0] === moduleName) {
+                        //Found matching define call for this script!
+                        found = true;
+                    }
+
+                    callGetModule(args);
+                }
+                context.defQueueMap = {};
+
+                //Do this after the cycle of callGetModule in case the result
+                //of those calls/init calls changes the registry.
+                mod = getOwn(registry, moduleName);
+
+                if (!found && !hasProp(defined, moduleName) && mod && !mod.inited) {
+                    if (config.enforceDefine && (!shExports || !getGlobal(shExports))) {
+                        if (hasPathFallback(moduleName)) {
+                            return;
+                        } else {
+                            return onError(makeError('nodefine',
+                                             'No define call for ' + moduleName,
+                                             null,
+                                             [moduleName]));
+                        }
+                    } else {
+                        //A script that does not call define(), so just simulate
+                        //the call for it.
+                        callGetModule([moduleName, (shim.deps || []), shim.exportsFn]);
+                    }
+                }
+
+                checkLoaded();
+            },
+
+            /**
+             * Converts a module name to a file path. Supports cases where
+             * moduleName may actually be just an URL.
+             * Note that it **does not** call normalize on the moduleName,
+             * it is assumed to have already been normalized. This is an
+             * internal API, not a public one. Use toUrl for the public API.
+             */
+            nameToUrl: function (moduleName, ext, skipExt) {
+                var paths, syms, i, parentModule, url,
+                    parentPath, bundleId,
+                    pkgMain = getOwn(config.pkgs, moduleName);
+
+                if (pkgMain) {
+                    moduleName = pkgMain;
+                }
+
+                bundleId = getOwn(bundlesMap, moduleName);
+
+                if (bundleId) {
+                    return context.nameToUrl(bundleId, ext, skipExt);
+                }
+
+                //If a colon is in the URL, it indicates a protocol is used and it is just
+                //an URL to a file, or if it starts with a slash, contains a query arg (i.e. ?)
+                //or ends with .js, then assume the user meant to use an url and not a module id.
+                //The slash is important for protocol-less URLs as well as full paths.
+                if (req.jsExtRegExp.test(moduleName)) {
+                    //Just a plain path, not module name lookup, so just return it.
+                    //Add extension if it is included. This is a bit wonky, only non-.js things pass
+                    //an extension, this method probably needs to be reworked.
+                    url = moduleName + (ext || '');
+                } else {
+                    //A module that needs to be converted to a path.
+                    paths = config.paths;
+
+                    syms = moduleName.split('/');
+                    //For each module name segment, see if there is a path
+                    //registered for it. Start with most specific name
+                    //and work up from it.
+                    for (i = syms.length; i > 0; i -= 1) {
+                        parentModule = syms.slice(0, i).join('/');
+
+                        parentPath = getOwn(paths, parentModule);
+                        if (parentPath) {
+                            //If an array, it means there are a few choices,
+                            //Choose the one that is desired
+                            if (isArray(parentPath)) {
+                                parentPath = parentPath[0];
+                            }
+                            syms.splice(0, i, parentPath);
+                            break;
+                        }
+                    }
+
+                    //Join the path parts together, then figure out if baseUrl is needed.
+                    url = syms.join('/');
+                    url += (ext || (/^data\:|^blob\:|\?/.test(url) || skipExt ? '' : '.js'));
+                    url = (url.charAt(0) === '/' || url.match(/^[\w\+\.\-]+:/) ? '' : config.baseUrl) + url;
+                }
+
+                return config.urlArgs && !/^blob\:/.test(url) ?
+                       url + config.urlArgs(moduleName, url) : url;
+            },
+
+            //Delegates to req.load. Broken out as a separate function to
+            //allow overriding in the optimizer.
+            load: function (id, url) {
+                req.load(context, id, url);
+            },
+
+            /**
+             * Executes a module callback function. Broken out as a separate function
+             * solely to allow the build system to sequence the files in the built
+             * layer in the right sequence.
+             *
+             * @private
+             */
+            execCb: function (name, callback, args, exports) {
+                return callback.apply(exports, args);
+            },
+
+            /**
+             * callback for script loads, used to check status of loading.
+             *
+             * @param {Event} evt the event from the browser for the script
+             * that was loaded.
+             */
+            onScriptLoad: function (evt) {
+                //Using currentTarget instead of target for Firefox 2.0's sake. Not
+                //all old browsers will be supported, but this one was easy enough
+                //to support and still makes sense.
+                if (evt.type === 'load' ||
+                        (readyRegExp.test((evt.currentTarget || evt.srcElement).readyState))) {
+                    //Reset interactive script so a script node is not held onto for
+                    //to long.
+                    interactiveScript = null;
+
+                    //Pull out the name of the module and the context.
+                    var data = getScriptData(evt);
+                    context.completeLoad(data.id);
+                }
+            },
+
+            /**
+             * Callback for script errors.
+             */
+            onScriptError: function (evt) {
+                var data = getScriptData(evt);
+                if (!hasPathFallback(data.id)) {
+                    var parents = [];
+                    eachProp(registry, function(value, key) {
+                        if (key.indexOf('_@r') !== 0) {
+                            each(value.depMaps, function(depMap) {
+                                if (depMap.id === data.id) {
+                                    parents.push(key);
+                                    return true;
+                                }
+                            });
+                        }
+                    });
+                    return onError(makeError('scripterror', 'Script error for "' + data.id +
+                                             (parents.length ?
+                                             '", needed by: ' + parents.join(', ') :
+                                             '"'), evt, [data.id]));
+                }
+            }
+        };
+
+        context.require = context.makeRequire();
+        return context;
+    }
+
+    /**
+     * Main entry point.
+     *
+     * If the only argument to require is a string, then the module that
+     * is represented by that string is fetched for the appropriate context.
+     *
+     * If the first argument is an array, then it will be treated as an array
+     * of dependency string names to fetch. An optional function callback can
+     * be specified to execute when all of those dependencies are available.
+     *
+     * Make a local req variable to help Caja compliance (it assumes things
+     * on a require that are not standardized), and to give a short
+     * name for minification/local scope use.
+     */
+    req = requirejs = function (deps, callback, errback, optional) {
+
+        //Find the right context, use default
+        var context, config,
+            contextName = defContextName;
+
+        // Determine if have config object in the call.
+        if (!isArray(deps) && typeof deps !== 'string') {
+            // deps is a config object
+            config = deps;
+            if (isArray(callback)) {
+                // Adjust args if there are dependencies
+                deps = callback;
+                callback = errback;
+                errback = optional;
+            } else {
+                deps = [];
+            }
+        }
+
+        if (config && config.context) {
+            contextName = config.context;
+        }
+
+        context = getOwn(contexts, contextName);
+        if (!context) {
+            context = contexts[contextName] = req.s.newContext(contextName);
+        }
+
+        if (config) {
+            context.configure(config);
+        }
+
+        return context.require(deps, callback, errback);
+    };
+
+    /**
+     * Support require.config() to make it easier to cooperate with other
+     * AMD loaders on globally agreed names.
+     */
+    req.config = function (config) {
+        return req(config);
+    };
+
+    /**
+     * Execute something after the current tick
+     * of the event loop. Override for other envs
+     * that have a better solution than setTimeout.
+     * @param  {Function} fn function to execute later.
+     */
+    req.nextTick = typeof setTimeout !== 'undefined' ? function (fn) {
+        setTimeout(fn, 4);
+    } : function (fn) { fn(); };
+
+    /**
+     * Export require as a global, but only if it does not already exist.
+     */
+    if (!require) {
+        require = req;
+    }
+
+    req.version = version;
+
+    //Used to filter out dependencies that are already paths.
+    req.jsExtRegExp = /^\/|:|\?|\.js$/;
+    req.isBrowser = isBrowser;
+    s = req.s = {
+        contexts: contexts,
+        newContext: newContext
+    };
+
+    //Create default context.
+    req({});
+
+    //Exports some context-sensitive methods on global require.
+    each([
+        'toUrl',
+        'undef',
+        'defined',
+        'specified'
+    ], function (prop) {
+        //Reference from contexts instead of early binding to default context,
+        //so that during builds, the latest instance of the default context
+        //with its config gets used.
+        req[prop] = function () {
+            var ctx = contexts[defContextName];
+            return ctx.require[prop].apply(ctx, arguments);
+        };
+    });
+
+    if (isBrowser) {
+        head = s.head = document.getElementsByTagName('head')[0];
+        //If BASE tag is in play, using appendChild is a problem for IE6.
+        //When that browser dies, this can be removed. Details in this jQuery bug:
+        //http://dev.jquery.com/ticket/2709
+        baseElement = document.getElementsByTagName('base')[0];
+        if (baseElement) {
+            head = s.head = baseElement.parentNode;
+        }
+    }
+
+    /**
+     * Any errors that require explicitly generates will be passed to this
+     * function. Intercept/override it if you want custom error handling.
+     * @param {Error} err the error object.
+     */
+    req.onError = defaultOnError;
+
+    /**
+     * Creates the node for the load command. Only used in browser envs.
+     */
+    req.createNode = function (config, moduleName, url) {
+        var node = config.xhtml ?
+                document.createElementNS('http://www.w3.org/1999/xhtml', 'html:script') :
+                document.createElement('script');
+        node.type = config.scriptType || 'text/javascript';
+        node.charset = 'utf-8';
+        node.async = true;
+        return node;
+    };
+
+    /**
+     * Does the request to load a module for the browser case.
+     * Make this a separate function to allow other environments
+     * to override it.
+     *
+     * @param {Object} context the require context to find state.
+     * @param {String} moduleName the name of the module.
+     * @param {Object} url the URL to the module.
+     */
+    req.load = function (context, moduleName, url) {
+        var config = (context && context.config) || {},
+            node;
+        if (isBrowser) {
+            //In the browser so use a script tag
+            node = req.createNode(config, moduleName, url);
+
+            node.setAttribute('data-requirecontext', context.contextName);
+            node.setAttribute('data-requiremodule', moduleName);
+
+            //Set up load listener. Test attachEvent first because IE9 has
+            //a subtle issue in its addEventListener and script onload firings
+            //that do not match the behavior of all other browsers with
+            //addEventListener support, which fire the onload event for a
+            //script right after the script execution. See:
+            //https://connect.microsoft.com/IE/feedback/details/648057/script-onload-event-is-not-fired-immediately-after-script-execution
+            //UNFORTUNATELY Opera implements attachEvent but does not follow the script
+            //script execution mode.
+            if (node.attachEvent &&
+                    //Check if node.attachEvent is artificially added by custom script or
+                    //natively supported by browser
+                    //read https://github.com/requirejs/requirejs/issues/187
+                    //if we can NOT find [native code] then it must NOT natively supported.
+                    //in IE8, node.attachEvent does not have toString()
+                    //Note the test for "[native code" with no closing brace, see:
+                    //https://github.com/requirejs/requirejs/issues/273
+                    !(node.attachEvent.toString && node.attachEvent.toString().indexOf('[native code') < 0) &&
+                    !isOpera) {
+                //Probably IE. IE (at least 6-8) do not fire
+                //script onload right after executing the script, so
+                //we cannot tie the anonymous define call to a name.
+                //However, IE reports the script as being in 'interactive'
+                //readyState at the time of the define call.
+                useInteractive = true;
+
+                node.attachEvent('onreadystatechange', context.onScriptLoad);
+                //It would be great to add an error handler here to catch
+                //404s in IE9+. However, onreadystatechange will fire before
+                //the error handler, so that does not help. If addEventListener
+                //is used, then IE will fire error before load, but we cannot
+                //use that pathway given the connect.microsoft.com issue
+                //mentioned above about not doing the 'script execute,
+                //then fire the script load event listener before execute
+                //next script' that other browsers do.
+                //Best hope: IE10 fixes the issues,
+                //and then destroys all installs of IE 6-9.
+                //node.attachEvent('onerror', context.onScriptError);
+            } else {
+                node.addEventListener('load', context.onScriptLoad, false);
+                node.addEventListener('error', context.onScriptError, false);
+            }
+            node.src = url;
+
+            //Calling onNodeCreated after all properties on the node have been
+            //set, but before it is placed in the DOM.
+            if (config.onNodeCreated) {
+                config.onNodeCreated(node, config, moduleName, url);
+            }
+
+            //For some cache cases in IE 6-8, the script executes before the end
+            //of the appendChild execution, so to tie an anonymous define
+            //call to the module name (which is stored on the node), hold on
+            //to a reference to this node, but clear after the DOM insertion.
+            currentlyAddingScript = node;
+            if (baseElement) {
+                head.insertBefore(node, baseElement);
+            } else {
+                head.appendChild(node);
+            }
+            currentlyAddingScript = null;
+
+            return node;
+        } else if (isWebWorker) {
+            try {
+                //In a web worker, use importScripts. This is not a very
+                //efficient use of importScripts, importScripts will block until
+                //its script is downloaded and evaluated. However, if web workers
+                //are in play, the expectation is that a build has been done so
+                //that only one script needs to be loaded anyway. This may need
+                //to be reevaluated if other use cases become common.
+
+                // Post a task to the event loop to work around a bug in WebKit
+                // where the worker gets garbage-collected after calling
+                // importScripts(): https://webkit.org/b/153317
+                setTimeout(function() {}, 0);
+                importScripts(url);
+
+                //Account for anonymous modules
+                context.completeLoad(moduleName);
+            } catch (e) {
+                context.onError(makeError('importscripts',
+                                'importScripts failed for ' +
+                                    moduleName + ' at ' + url,
+                                e,
+                                [moduleName]));
+            }
+        }
+    };
+
+    function getInteractiveScript() {
+        if (interactiveScript && interactiveScript.readyState === 'interactive') {
+            return interactiveScript;
+        }
+
+        eachReverse(scripts(), function (script) {
+            if (script.readyState === 'interactive') {
+                return (interactiveScript = script);
+            }
+        });
+        return interactiveScript;
+    }
+
+    //Look for a data-main script attribute, which could also adjust the baseUrl.
+    if (isBrowser && !cfg.skipDataMain) {
+        //Figure out baseUrl. Get it from the script tag with require.js in it.
+        eachReverse(scripts(), function (script) {
+            //Set the 'head' where we can append children by
+            //using the script's parent.
+            if (!head) {
+                head = script.parentNode;
+            }
+
+            //Look for a data-main attribute to set main script for the page
+            //to load. If it is there, the path to data main becomes the
+            //baseUrl, if it is not already set.
+            dataMain = script.getAttribute('data-main');
+            if (dataMain) {
+                //Preserve dataMain in case it is a path (i.e. contains '?')
+                mainScript = dataMain;
+
+                //Set final baseUrl if there is not already an explicit one,
+                //but only do so if the data-main value is not a loader plugin
+                //module ID.
+                if (!cfg.baseUrl && mainScript.indexOf('!') === -1) {
+                    //Pull off the directory of data-main for use as the
+                    //baseUrl.
+                    src = mainScript.split('/');
+                    mainScript = src.pop();
+                    subPath = src.length ? src.join('/')  + '/' : './';
+
+                    cfg.baseUrl = subPath;
+                }
+
+                //Strip off any trailing .js since mainScript is now
+                //like a module name.
+                mainScript = mainScript.replace(jsSuffixRegExp, '');
+
+                //If mainScript is still a path, fall back to dataMain
+                if (req.jsExtRegExp.test(mainScript)) {
+                    mainScript = dataMain;
+                }
+
+                //Put the data-main script in the files to load.
+                cfg.deps = cfg.deps ? cfg.deps.concat(mainScript) : [mainScript];
+
+                return true;
+            }
+        });
+    }
+
+    /**
+     * The function that handles definitions of modules. Differs from
+     * require() in that a string for the module should be the first argument,
+     * and the function to execute after dependencies are loaded should
+     * return a value to define the module corresponding to the first argument's
+     * name.
+     */
+    define = function (name, deps, callback) {
+        var node, context;
+
+        //Allow for anonymous modules
+        if (typeof name !== 'string') {
+            //Adjust args appropriately
+            callback = deps;
+            deps = name;
+            name = null;
+        }
+
+        //This module may not have dependencies
+        if (!isArray(deps)) {
+            callback = deps;
+            deps = null;
+        }
+
+        //If no name, and callback is a function, then figure out if it a
+        //CommonJS thing with dependencies.
+        if (!deps && isFunction(callback)) {
+            deps = [];
+            //Remove comments from the callback string,
+            //look for require calls, and pull them into the dependencies,
+            //but only if there are function args.
+            if (callback.length) {
+                callback
+                    .toString()
+                    .replace(commentRegExp, commentReplace)
+                    .replace(cjsRequireRegExp, function (match, dep) {
+                        deps.push(dep);
+                    });
+
+                //May be a CommonJS thing even without require calls, but still
+                //could use exports, and module. Avoid doing exports and module
+                //work though if it just needs require.
+                //REQUIRES the function to expect the CommonJS variables in the
+                //order listed below.
+                deps = (callback.length === 1 ? ['require'] : ['require', 'exports', 'module']).concat(deps);
+            }
+        }
+
+        //If in IE 6-8 and hit an anonymous define() call, do the interactive
+        //work.
+        if (useInteractive) {
+            node = currentlyAddingScript || getInteractiveScript();
+            if (node) {
+                if (!name) {
+                    name = node.getAttribute('data-requiremodule');
+                }
+                context = contexts[node.getAttribute('data-requirecontext')];
+            }
+        }
+
+        //Always save off evaluating the def call until the script onload handler.
+        //This allows multiple modules to be in a file without prematurely
+        //tracing dependencies, and allows for anonymous module support,
+        //where the module name is not known until the script onload event
+        //occurs. If no context, use the global queue, and get it processed
+        //in the onscript load callback.
+        if (context) {
+            context.defQueue.push([name, deps, callback]);
+            context.defQueueMap[name] = true;
+        } else {
+            globalDefQueue.push([name, deps, callback]);
+        }
+    };
+
+    define.amd = {
+        jQuery: true
+    };
+
+    /**
+     * Executes the text. Normally just uses eval, but can be modified
+     * to use a better, environment-specific call. Only used for transpiling
+     * loader plugins, not for plain JS modules.
+     * @param {String} text the text to execute/evaluate.
+     */
+    req.exec = function (text) {
+        /*jslint evil: true */
+        return eval(text);
+    };
+
+    //Set up with config info.
+    req(cfg);
+}(this, (typeof setTimeout === 'undefined' ? undefined : setTimeout)));
+
+
+
+    this.requirejsVars = {
+        require: require,
+        requirejs: require,
+        define: define
+    };
+
+    if (env === 'browser') {
+        //sloppy since eval enclosed with use strict causes problems if the source
+//text is not strict-compliant.
+/*jslint sloppy: true, evil: true */
+/*global require, XMLHttpRequest */
+
+(function () {
+    // Separate function to avoid eval pollution, same with arguments use.
+    function exec() {
+        eval(arguments[0]);
+    }
+
+    require.load = function (context, moduleName, url) {
+        var xhr = new XMLHttpRequest();
+
+        xhr.open('GET', url, true);
+        xhr.send();
+
+        xhr.onreadystatechange = function () {
+            if (xhr.readyState === 4) {
+                exec(xhr.responseText);
+
+                //Support anonymous modules.
+                context.completeLoad(moduleName);
+            }
+        };
+    };
+}());
+    } else if (env === 'rhino') {
+        /*global require: false, java: false, load: false */
+
+(function () {
+    'use strict';
+    require.load = function (context, moduleName, url) {
+
+        load(url);
+
+        //Support anonymous modules.
+        context.completeLoad(moduleName);
+    };
+
+}());
+    } else if (env === 'node') {
+        this.requirejsVars.nodeRequire = nodeRequire;
+        require.nodeRequire = nodeRequire;
+
+        //Explicity not strict since this file contains an eval call, and do not want
+//to enforce strict on code evaluated that way. See
+//https://github.com/requirejs/r.js/issues/774
+/*jslint regexp: false, sloppy: true*/
+/*global require: false, define: false, requirejsVars: false, process: false */
+
+/**
+ * This adapter assumes that x.js has loaded it and set up
+ * some variables. This adapter just allows limited RequireJS
+ * usage from within the requirejs directory. The general
+ * node adapater is r.js.
+ */
+
+(function () {
+    var nodeReq = requirejsVars.nodeRequire,
+        req = requirejsVars.require,
+        def = requirejsVars.define,
+        fs = nodeReq('fs'),
+        path = nodeReq('path'),
+        vm = nodeReq('vm'),
+        //In Node 0.7+ existsSync is on fs.
+        exists = fs.existsSync || path.existsSync,
+        hasOwn = Object.prototype.hasOwnProperty;
+
+    function hasProp(obj, prop) {
+        return hasOwn.call(obj, prop);
+    }
+
+    function syncTick(fn) {
+        fn();
+    }
+
+    function makeError(message, moduleName) {
+        var err = new Error(message);
+        err.requireModules = [moduleName];
+        return err;
+    }
+
+    //Supply an implementation that allows synchronous get of a module.
+    req.get = function (context, moduleName, relModuleMap, localRequire) {
+        if (moduleName === "require" || moduleName === "exports" || moduleName === "module") {
+            context.onError(makeError("Explicit require of " + moduleName + " is not allowed.", moduleName));
+        }
+
+        var ret, oldTick,
+            moduleMap = context.makeModuleMap(moduleName, relModuleMap, false, true);
+
+        //Normalize module name, if it contains . or ..
+        moduleName = moduleMap.id;
+
+        if (hasProp(context.defined, moduleName)) {
+            ret = context.defined[moduleName];
+        } else {
+            if (ret === undefined) {
+                //Make sure nextTick for this type of call is sync-based.
+                oldTick = context.nextTick;
+                context.nextTick = syncTick;
+                try {
+                    if (moduleMap.prefix) {
+                        //A plugin, call requirejs to handle it. Now that
+                        //nextTick is syncTick, the require will complete
+                        //synchronously.
+                        localRequire([moduleMap.originalName]);
+
+                        //Now that plugin is loaded, can regenerate the moduleMap
+                        //to get the final, normalized ID.
+                        moduleMap = context.makeModuleMap(moduleMap.originalName, relModuleMap, false, true);
+                        moduleName = moduleMap.id;
+                    } else {
+                        //Try to dynamically fetch it.
+                        req.load(context, moduleName, moduleMap.url);
+
+                        //Enable the module
+                        context.enable(moduleMap, relModuleMap);
+                    }
+
+                    //Break any cycles by requiring it normally, but this will
+                    //finish synchronously
+                    context.require([moduleName]);
+
+                    //The above calls are sync, so can do the next thing safely.
+                    ret = context.defined[moduleName];
+                } finally {
+                    context.nextTick = oldTick;
+                }
+            }
+        }
+
+        return ret;
+    };
+
+    req.nextTick = function (fn) {
+        process.nextTick(fn);
+    };
+
+    //Add wrapper around the code so that it gets the requirejs
+    //API instead of the Node API, and it is done lexically so
+    //that it survives later execution.
+    req.makeNodeWrapper = function (contents) {
+        return '(function (require, requirejs, define) { ' +
+                contents +
+                '\n}(requirejsVars.require, requirejsVars.requirejs, requirejsVars.define));';
+    };
+
+    req.load = function (context, moduleName, url) {
+        var contents, err,
+            config = context.config;
+
+        if (config.shim[moduleName] && (!config.suppress || !config.suppress.nodeShim)) {
+            console.warn('Shim config not supported in Node, may or may not work. Detected ' +
+                            'for module: ' + moduleName);
+        }
+
+        if (exists(url)) {
+            contents = fs.readFileSync(url, 'utf8');
+
+            contents = req.makeNodeWrapper(contents);
+            try {
+                vm.runInThisContext(contents, fs.realpathSync(url));
+            } catch (e) {
+                err = new Error('Evaluating ' + url + ' as module "' +
+                                moduleName + '" failed with error: ' + e);
+                err.originalError = e;
+                err.moduleName = moduleName;
+                err.requireModules = [moduleName];
+                err.fileName = url;
+                return context.onError(err);
+            }
+        } else {
+            def(moduleName, function () {
+                //Get the original name, since relative requires may be
+                //resolved differently in node (issue #202). Also, if relative,
+                //make it relative to the URL of the item requesting it
+                //(issue #393)
+                var dirName,
+                    map = hasProp(context.registry, moduleName) &&
+                            context.registry[moduleName].map,
+                    parentMap = map && map.parentMap,
+                    originalName = map && map.originalName;
+
+                if (originalName.charAt(0) === '.' && parentMap) {
+                    dirName = parentMap.url.split('/');
+                    dirName.pop();
+                    originalName = dirName.join('/') + '/' + originalName;
+                }
+
+                try {
+                    return (context.config.nodeRequire || req.nodeRequire)(originalName);
+                } catch (e) {
+                    err = new Error('Tried loading "' + moduleName + '" at ' +
+                                     url + ' then tried node\'s require("' +
+                                        originalName + '") and it failed ' +
+                                     'with error: ' + e);
+                    err.originalError = e;
+                    err.moduleName = originalName;
+                    err.requireModules = [moduleName];
+                    throw err;
+                }
+            });
+        }
+
+        //Support anonymous modules.
+        context.completeLoad(moduleName);
+    };
+
+    //Override to provide the function wrapper for define/require.
+    req.exec = function (text) {
+        /*jslint evil: true */
+        text = req.makeNodeWrapper(text);
+        return eval(text);
+    };
+}());
+
+    } else if (env === 'xpconnect') {
+        /*jslint */
+/*global require, load */
+
+(function () {
+    'use strict';
+    require.load = function (context, moduleName, url) {
+
+        load(url);
+
+        //Support anonymous modules.
+        context.completeLoad(moduleName);
+    };
+
+}());
+
+    }
+
+    //Support a default file name to execute. Useful for hosted envs
+    //like Joyent where it defaults to a server.js as the only executed
+    //script. But only do it if this is not an optimization run.
+    if (commandOption !== 'o' && (!fileName || !jsSuffixRegExp.test(fileName))) {
+        fileName = 'main.js';
+    }
+
+    /**
+     * Loads the library files that can be used for the optimizer, or for other
+     * tasks.
+     */
+    function loadLib() {
+        /*jslint strict: false */
+/*global Packages: false, process: false, window: false, navigator: false,
+  document: false, define: false */
+
+/**
+ * A plugin that modifies any /env/ path to be the right path based on
+ * the host environment. Right now only works for Node, Rhino and browser.
+ */
+(function () {
+    var pathRegExp = /(\/|^)env\/|\{env\}/,
+        env = 'unknown';
+
+    if (typeof process !== 'undefined' && process.versions && !!process.versions.node) {
+        env = 'node';
+    } else if (typeof Packages !== 'undefined') {
+        env = 'rhino';
+    } else if ((typeof navigator !== 'undefined' && typeof document !== 'undefined') ||
+            (typeof importScripts !== 'undefined' && typeof self !== 'undefined')) {
+        env = 'browser';
+    } else if (typeof Components !== 'undefined' && Components.classes && Components.interfaces) {
+        env = 'xpconnect';
+    }
+
+    define('env', {
+        get: function () {
+            return env;
+        },
+
+        load: function (name, req, load, config) {
+            //Allow override in the config.
+            if (config.env) {
+                env = config.env;
+            }
+
+            name = name.replace(pathRegExp, function (match, prefix) {
+                if (match.indexOf('{') === -1) {
+                    return prefix + env + '/';
+                } else {
+                    return env;
+                }
+            });
+
+            req([name], function (mod) {
+                load(mod);
+            });
+        }
+    });
+}());
+/*jslint plusplus: true */
+/*global define, java */
+
+define('lang', function () {
+    'use strict';
+
+    var lang, isJavaObj,
+        hasOwn = Object.prototype.hasOwnProperty;
+
+    function hasProp(obj, prop) {
+        return hasOwn.call(obj, prop);
+    }
+
+    isJavaObj = function () {
+        return false;
+    };
+
+    //Rhino, but not Nashorn (detected by importPackage not existing)
+    //Can have some strange foreign objects.
+    if (typeof java !== 'undefined' && java.lang && java.lang.Object && typeof importPackage !== 'undefined') {
+        isJavaObj = function (obj) {
+            return obj instanceof java.lang.Object;
+        };
+    }
+
+    lang = {
+        backSlashRegExp: /\\/g,
+        ostring: Object.prototype.toString,
+
+        isArray: Array.isArray || function (it) {
+            return lang.ostring.call(it) === "[object Array]";
+        },
+
+        isFunction: function(it) {
+            return lang.ostring.call(it) === "[object Function]";
+        },
+
+        isRegExp: function(it) {
+            return it && it instanceof RegExp;
+        },
+
+        hasProp: hasProp,
+
+        //returns true if the object does not have an own property prop,
+        //or if it does, it is a falsy value.
+        falseProp: function (obj, prop) {
+            return !hasProp(obj, prop) || !obj[prop];
+        },
+
+        //gets own property value for given prop on object
+        getOwn: function (obj, prop) {
+            return hasProp(obj, prop) && obj[prop];
+        },
+
+        _mixin: function(dest, source, override){
+            var name;
+            for (name in source) {
+                if(source.hasOwnProperty(name) &&
+                    (override || !dest.hasOwnProperty(name))) {
+                    dest[name] = source[name];
+                }
+            }
+
+            return dest; // Object
+        },
+
+        /**
+         * mixin({}, obj1, obj2) is allowed. If the last argument is a boolean,
+         * then the source objects properties are force copied over to dest.
+         */
+        mixin: function(dest){
+            var parameters = Array.prototype.slice.call(arguments),
+                override, i, l;
+
+            if (!dest) { dest = {}; }
+
+            if (parameters.length > 2 && typeof arguments[parameters.length-1] === 'boolean') {
+                override = parameters.pop();
+            }
+
+            for (i = 1, l = parameters.length; i < l; i++) {
+                lang._mixin(dest, parameters[i], override);
+            }
+            return dest; // Object
+        },
+
+        /**
+         * Does a deep mix of source into dest, where source values override
+         * dest values if a winner is needed.
+         * @param  {Object} dest destination object that receives the mixed
+         * values.
+         * @param  {Object} source source object contributing properties to mix
+         * in.
+         * @return {[Object]} returns dest object with the modification.
+         */
+        deepMix: function(dest, source) {
+            lang.eachProp(source, function (value, prop) {
+                if (typeof value === 'object' && value &&
+                    !lang.isArray(value) && !lang.isFunction(value) &&
+                    !(value instanceof RegExp)) {
+
+                    if (!dest[prop]) {
+                        dest[prop] = {};
+                    }
+                    lang.deepMix(dest[prop], value);
+                } else {
+                    dest[prop] = value;
+                }
+            });
+            return dest;
+        },
+
+        /**
+         * Does a type of deep copy. Do not give it anything fancy, best
+         * for basic object copies of objects that also work well as
+         * JSON-serialized things, or has properties pointing to functions.
+         * For non-array/object values, just returns the same object.
+         * @param  {Object} obj      copy properties from this object
+         * @param  {Object} [ignoredProps] optional object whose own properties
+         * are keys that should be ignored.
+         * @return {Object}
+         */
+        deeplikeCopy: function (obj, ignoredProps) {
+            var type, result;
+
+            if (lang.isArray(obj)) {
+                result = [];
+                obj.forEach(function(value) {
+                    result.push(lang.deeplikeCopy(value, ignoredProps));
+                });
+                return result;
+            }
+
+            type = typeof obj;
+            if (obj === null || obj === undefined || type === 'boolean' ||
+                type === 'string' || type === 'number' || lang.isFunction(obj) ||
+                lang.isRegExp(obj)|| isJavaObj(obj)) {
+                return obj;
+            }
+
+            //Anything else is an object, hopefully.
+            result = {};
+            lang.eachProp(obj, function(value, key) {
+                if (!ignoredProps || !hasProp(ignoredProps, key)) {
+                    result[key] = lang.deeplikeCopy(value, ignoredProps);
+                }
+            });
+            return result;
+        },
+
+        delegate: (function () {
+            // boodman/crockford delegation w/ cornford optimization
+            function TMP() {}
+            return function (obj, props) {
+                TMP.prototype = obj;
+                var tmp = new TMP();
+                TMP.prototype = null;
+                if (props) {
+                    lang.mixin(tmp, props);
+                }
+                return tmp; // Object
+            };
+        }()),
+
+        /**
+         * Helper function for iterating over an array. If the func returns
+         * a true value, it will break out of the loop.
+         */
+        each: function each(ary, func) {
+            if (ary) {
+                var i;
+                for (i = 0; i < ary.length; i += 1) {
+                    if (func(ary[i], i, ary)) {
+                        break;
+                    }
+                }
+            }
+        },
+
+        /**
+         * Cycles over properties in an object and calls a function for each
+         * property value. If the function returns a truthy value, then the
+         * iteration is stopped.
+         */
+        eachProp: function eachProp(obj, func) {
+            var prop;
+            for (prop in obj) {
+                if (hasProp(obj, prop)) {
+                    if (func(obj[prop], prop)) {
+                        break;
+                    }
+                }
+            }
+        },
+
+        //Similar to Function.prototype.bind, but the "this" object is specified
+        //first, since it is easier to read/figure out what "this" will be.
+        bind: function bind(obj, fn) {
+            return function () {
+                return fn.apply(obj, arguments);
+            };
+        },
+
+        //Escapes a content string to be be a string that has characters escaped
+        //for inclusion as part of a JS string.
+        jsEscape: function (content) {
+            return content.replace(/(["'\\])/g, '\\$1')
+                .replace(/[\f]/g, "\\f")
+                .replace(/[\b]/g, "\\b")
+                .replace(/[\n]/g, "\\n")
+                .replace(/[\t]/g, "\\t")
+                .replace(/[\r]/g, "\\r");
+        }
+    };
+    return lang;
+});
+/**
+ * prim 0.0.1 Copyright (c) 2012-2014, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/requirejs/prim for details
+ */
+
+/*global setImmediate, process, setTimeout, define, module */
+
+//Set prime.hideResolutionConflict = true to allow "resolution-races"
+//in promise-tests to pass.
+//Since the goal of prim is to be a small impl for trusted code, it is
+//more important to normally throw in this case so that we can find
+//logic errors quicker.
+
+var prim;
+(function () {
+    'use strict';
+    var op = Object.prototype,
+        hasOwn = op.hasOwnProperty;
+
+    function hasProp(obj, prop) {
+        return hasOwn.call(obj, prop);
+    }
+
+    /**
+     * Helper function for iterating over an array. If the func returns
+     * a true value, it will break out of the loop.
+     */
+    function each(ary, func) {
+        if (ary) {
+            var i;
+            for (i = 0; i < ary.length; i += 1) {
+                if (ary[i]) {
+                    func(ary[i], i, ary);
+                }
+            }
+        }
+    }
+
+    function check(p) {
+        if (hasProp(p, 'e') || hasProp(p, 'v')) {
+            if (!prim.hideResolutionConflict) {
+                throw new Error('Prim promise already resolved: ' +
+                                JSON.stringify(p));
+            }
+            return false;
+        }
+        return true;
+    }
+
+    function notify(ary, value) {
+        prim.nextTick(function () {
+            each(ary, function (item) {
+                item(value);
+            });
+        });
+    }
+
+    prim = function prim() {
+        var p,
+            ok = [],
+            fail = [];
+
+        return (p = {
+            callback: function (yes, no) {
+                if (no) {
+                    p.errback(no);
+                }
+
+                if (hasProp(p, 'v')) {
+                    prim.nextTick(function () {
+                        yes(p.v);
+                    });
+                } else {
+                    ok.push(yes);
+                }
+            },
+
+            errback: function (no) {
+                if (hasProp(p, 'e')) {
+                    prim.nextTick(function () {
+                        no(p.e);
+                    });
+                } else {
+                    fail.push(no);
+                }
+            },
+
+            finished: function () {
+                return hasProp(p, 'e') || hasProp(p, 'v');
+            },
+
+            rejected: function () {
+                return hasProp(p, 'e');
+            },
+
+            resolve: function (v) {
+                if (check(p)) {
+                    p.v = v;
+                    notify(ok, v);
+                }
+                return p;
+            },
+            reject: function (e) {
+                if (check(p)) {
+                    p.e = e;
+                    notify(fail, e);
+                }
+                return p;
+            },
+
+            start: function (fn) {
+                p.resolve();
+                return p.promise.then(fn);
+            },
+
+            promise: {
+                then: function (yes, no) {
+                    var next = prim();
+
+                    p.callback(function (v) {
+                        try {
+                            if (yes && typeof yes === 'function') {
+                                v = yes(v);
+                            }
+
+                            if (v && v.then) {
+                                v.then(next.resolve, next.reject);
+                            } else {
+                                next.resolve(v);
+                            }
+                        } catch (e) {
+                            next.reject(e);
+                        }
+                    }, function (e) {
+                        var err;
+
+                        try {
+                            if (!no || typeof no !== 'function') {
+                                next.reject(e);
+                            } else {
+                                err = no(e);
+
+                                if (err && err.then) {
+                                    err.then(next.resolve, next.reject);
+                                } else {
+                                    next.resolve(err);
+                                }
+                            }
+                        } catch (e2) {
+                            next.reject(e2);
+                        }
+                    });
+
+                    return next.promise;
+                },
+
+                fail: function (no) {
+                    return p.promise.then(null, no);
+                },
+
+                end: function () {
+                    p.errback(function (e) {
+                        throw e;
+                    });
+                }
+            }
+        });
+    };
+
+    prim.serial = function (ary) {
+        var result = prim().resolve().promise;
+        each(ary, function (item) {
+            result = result.then(function () {
+                return item();
+            });
+        });
+        return result;
+    };
+
+    prim.nextTick = typeof setImmediate === 'function' ? setImmediate :
+        (typeof process !== 'undefined' && process.nextTick ?
+            process.nextTick : (typeof setTimeout !== 'undefined' ?
+                function (fn) {
+                setTimeout(fn, 0);
+            } : function (fn) {
+        fn();
+    }));
+
+    if (typeof define === 'function' && define.amd) {
+        define('prim', function () { return prim; });
+    } else if (typeof module !== 'undefined' && module.exports) {
+        module.exports = prim;
+    }
+}());
+if(env === 'browser') {
+/*jslint strict: false */
+/*global define: false, load: false */
+
+//Just a stub for use with uglify's consolidator.js
+define('browser/assert', function () {
+    return {};
+});
+
+}
+
+if(env === 'node') {
+/*jslint strict: false */
+/*global define: false, load: false */
+
+//Needed so that rhino/assert can return a stub for uglify's consolidator.js
+define('node/assert', ['assert'], function (assert) {
+    return assert;
+});
+
+}
+
+if(env === 'rhino') {
+/*jslint strict: false */
+/*global define: false, load: false */
+
+//Just a stub for use with uglify's consolidator.js
+define('rhino/assert', function () {
+    return {};
+});
+
+}
+
+if(env === 'xpconnect') {
+/*jslint strict: false */
+/*global define: false, load: false */
+
+//Just a stub for use with uglify's consolidator.js
+define('xpconnect/assert', function () {
+    return {};
+});
+
+}
+
+if(env === 'browser') {
+/*jslint strict: false */
+/*global define: false, process: false */
+
+define('browser/args', function () {
+    //Always expect config via an API call
+    return [];
+});
+
+}
+
+if(env === 'node') {
+/*jslint strict: false */
+/*global define: false, process: false */
+
+define('node/args', function () {
+    //Do not return the "node" or "r.js" arguments
+    var args = process.argv.slice(2);
+
+    //Ignore any command option used for main x.js branching
+    if (args[0] && args[0].indexOf('-') === 0) {
+        args = args.slice(1);
+    }
+
+    return args;
+});
+
+}
+
+if(env === 'rhino') {
+/*jslint strict: false */
+/*global define: false, process: false */
+
+var jsLibRhinoArgs = (typeof rhinoArgs !== 'undefined' && rhinoArgs) || [].concat(Array.prototype.slice.call(arguments, 0));
+
+define('rhino/args', function () {
+    var args = jsLibRhinoArgs;
+
+    //Ignore any command option used for main x.js branching
+    if (args[0] && args[0].indexOf('-') === 0) {
+        args = args.slice(1);
+    }
+
+    return args;
+});
+
+}
+
+if(env === 'xpconnect') {
+/*jslint strict: false */
+/*global define, xpconnectArgs */
+
+var jsLibXpConnectArgs = (typeof xpconnectArgs !== 'undefined' && xpconnectArgs) || [].concat(Array.prototype.slice.call(arguments, 0));
+
+define('xpconnect/args', function () {
+    var args = jsLibXpConnectArgs;
+
+    //Ignore any command option used for main x.js branching
+    if (args[0] && args[0].indexOf('-') === 0) {
+        args = args.slice(1);
+    }
+
+    return args;
+});
+
+}
+
+if(env === 'browser') {
+/*jslint strict: false */
+/*global define: false, console: false */
+
+define('browser/load', ['./file'], function (file) {
+    function load(fileName) {
+        eval(file.readFile(fileName));
+    }
+
+    return load;
+});
+
+}
+
+if(env === 'node') {
+/*jslint strict: false */
+/*global define: false, console: false */
+
+define('node/load', ['fs'], function (fs) {
+    function load(fileName) {
+        var contents = fs.readFileSync(fileName, 'utf8');
+        process.compile(contents, fileName);
+    }
+
+    return load;
+});
+
+}
+
+if(env === 'rhino') {
+/*jslint strict: false */
+/*global define: false, load: false */
+
+define('rhino/load', function () {
+    return load;
+});
+
+}
+
+if(env === 'xpconnect') {
+/*jslint strict: false */
+/*global define: false, load: false */
+
+define('xpconnect/load', function () {
+    return load;
+});
+
+}
+
+if(env === 'browser') {
+/*jslint sloppy: true, nomen: true */
+/*global require, define, console, XMLHttpRequest, requirejs, location */
+
+define('browser/file', ['prim'], function (prim) {
+
+    var file,
+        currDirRegExp = /^\.(\/|$)/;
+
+    function frontSlash(path) {
+        return path.replace(/\\/g, '/');
+    }
+
+    function exists(path) {
+        var status, xhr = new XMLHttpRequest();
+
+        //Oh yeah, that is right SYNC IO. Behold its glory
+        //and horrible blocking behavior.
+        xhr.open('HEAD', path, false);
+        xhr.send();
+        status = xhr.status;
+
+        return status === 200 || status === 304;
+    }
+
+    function mkDir(dir) {
+        console.log('mkDir is no-op in browser');
+    }
+
+    function mkFullDir(dir) {
+        console.log('mkFullDir is no-op in browser');
+    }
+
+    file = {
+        backSlashRegExp: /\\/g,
+        exclusionRegExp: /^\./,
+        getLineSeparator: function () {
+            return '/';
+        },
+
+        exists: function (fileName) {
+            return exists(fileName);
+        },
+
+        parent: function (fileName) {
+            var parts = fileName.split('/');
+            parts.pop();
+            return parts.join('/');
+        },
+
+        /**
+         * Gets the absolute file path as a string, normalized
+         * to using front slashes for path separators.
+         * @param {String} fileName
+         */
+        absPath: function (fileName) {
+            var dir;
+            if (currDirRegExp.test(fileName)) {
+                dir = frontSlash(location.href);
+                if (dir.indexOf('/') !== -1) {
+                    dir = dir.split('/');
+
+                    //Pull off protocol and host, just want
+                    //to allow paths (other build parts, like
+                    //require._isSupportedBuildUrl do not support
+                    //full URLs), but a full path from
+                    //the root.
+                    dir.splice(0, 3);
+
+                    dir.pop();
+                    dir = '/' + dir.join('/');
+                }
+
+                fileName = dir + fileName.substring(1);
+            }
+
+            return fileName;
+        },
+
+        normalize: function (fileName) {
+            return fileName;
+        },
+
+        isFile: function (path) {
+            return true;
+        },
+
+        isDirectory: function (path) {
+            return false;
+        },
+
+        getFilteredFileList: function (startDir, regExpFilters, makeUnixPaths) {
+            console.log('file.getFilteredFileList is no-op in browser');
+        },
+
+        copyDir: function (srcDir, destDir, regExpFilter, onlyCopyNew) {
+            console.log('file.copyDir is no-op in browser');
+
+        },
+
+        copyFile: function (srcFileName, destFileName, onlyCopyNew) {
+            console.log('file.copyFile is no-op in browser');
+        },
+
+        /**
+         * Renames a file. May fail if "to" already exists or is on another drive.
+         */
+        renameFile: function (from, to) {
+            console.log('file.renameFile is no-op in browser');
+        },
+
+        /**
+         * Reads a *text* file.
+         */
+        readFile: function (path, encoding) {
+            var xhr = new XMLHttpRequest();
+
+            //Oh yeah, that is right SYNC IO. Behold its glory
+            //and horrible blocking behavior.
+            xhr.open('GET', path, false);
+            xhr.send();
+
+            return xhr.responseText;
+        },
+
+        readFileAsync: function (path, encoding) {
+            var xhr = new XMLHttpRequest(),
+                d = prim();
+
+            xhr.open('GET', path, true);
+            xhr.send();
+
+            xhr.onreadystatechange = function () {
+                if (xhr.readyState === 4) {
+                    if (xhr.status > 400) {
+                        d.reject(new Error('Status: ' + xhr.status + ': ' + xhr.statusText));
+                    } else {
+                        d.resolve(xhr.responseText);
+                    }
+                }
+            };
+
+            return d.promise;
+        },
+
+        saveUtf8File: function (fileName, fileContents) {
+            //summary: saves a *text* file using UTF-8 encoding.
+            file.saveFile(fileName, fileContents, "utf8");
+        },
+
+        saveFile: function (fileName, fileContents, encoding) {
+            requirejs.browser.saveFile(fileName, fileContents, encoding);
+        },
+
+        deleteFile: function (fileName) {
+            console.log('file.deleteFile is no-op in browser');
+        },
+
+        /**
+         * Deletes any empty directories under the given directory.
+         */
+        deleteEmptyDirs: function (startDir) {
+            console.log('file.deleteEmptyDirs is no-op in browser');
+        }
+    };
+
+    return file;
+
+});
+
+}
+
+if(env === 'node') {
+/*jslint plusplus: false, octal:false, strict: false */
+/*global define: false, process: false */
+
+define('node/file', ['fs', 'path', 'prim'], function (fs, path, prim) {
+
+    var isWindows = process.platform === 'win32',
+        windowsDriveRegExp = /^[a-zA-Z]\:\/$/,
+        file;
+
+    function frontSlash(path) {
+        return path.replace(/\\/g, '/');
+    }
+
+    function exists(path) {
+        if (isWindows && path.charAt(path.length - 1) === '/' &&
+            path.charAt(path.length - 2) !== ':') {
+            path = path.substring(0, path.length - 1);
+        }
+
+        try {
+            fs.statSync(path);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    function mkDir(dir) {
+        if (!exists(dir) && (!isWindows || !windowsDriveRegExp.test(dir))) {
+            fs.mkdirSync(dir, 511);
+        }
+    }
+
+    function mkFullDir(dir) {
+        var parts = dir.split('/'),
+            currDir = '',
+            first = true;
+
+        parts.forEach(function (part) {
+            //First part may be empty string if path starts with a slash.
+            currDir += part + '/';
+            first = false;
+
+            if (part) {
+                mkDir(currDir);
+            }
+        });
+    }
+
+    file = {
+        backSlashRegExp: /\\/g,
+        exclusionRegExp: /^\./,
+        getLineSeparator: function () {
+            return '/';
+        },
+
+        exists: function (fileName) {
+            return exists(fileName);
+        },
+
+        parent: function (fileName) {
+            var parts = fileName.split('/');
+            parts.pop();
+            return parts.join('/');
+        },
+
+        /**
+         * Gets the absolute file path as a string, normalized
+         * to using front slashes for path separators.
+         * @param {String} fileName
+         */
+        absPath: function (fileName) {
+            return frontSlash(path.normalize(frontSlash(fs.realpathSync(fileName))));
+        },
+
+        normalize: function (fileName) {
+            return frontSlash(path.normalize(fileName));
+        },
+
+        isFile: function (path) {
+            return fs.statSync(path).isFile();
+        },
+
+        isDirectory: function (path) {
+            return fs.statSync(path).isDirectory();
+        },
+
+        getFilteredFileList: function (/*String*/startDir, /*RegExp*/regExpFilters, /*boolean?*/makeUnixPaths) {
+            //summary: Recurses startDir and finds matches to the files that match regExpFilters.include
+            //and do not match regExpFilters.exclude. Or just one regexp can be passed in for regExpFilters,
+            //and it will be treated as the "include" case.
+            //Ignores files/directories that start with a period (.) unless exclusionRegExp
+            //is set to another value.
+            var files = [], topDir, regExpInclude, regExpExclude, dirFileArray,
+                i, stat, filePath, ok, dirFiles, fileName;
+
+            topDir = startDir;
+
+            regExpInclude = regExpFilters.include || regExpFilters;
+            regExpExclude = regExpFilters.exclude || null;
+
+            if (file.exists(topDir)) {
+                dirFileArray = fs.readdirSync(topDir);
+                for (i = 0; i < dirFileArray.length; i++) {
+                    fileName = dirFileArray[i];
+                    filePath = path.join(topDir, fileName);
+                    stat = fs.statSync(filePath);
+                    if (stat.isFile()) {
+                        if (makeUnixPaths) {
+                            //Make sure we have a JS string.
+                            if (filePath.indexOf("/") === -1) {
+                                filePath = frontSlash(filePath);
+                            }
+                        }
+
+                        ok = true;
+                        if (regExpInclude) {
+                            ok = filePath.match(regExpInclude);
+                        }
+                        if (ok && regExpExclude) {
+                            ok = !filePath.match(regExpExclude);
+                        }
+
+                        if (ok && (!file.exclusionRegExp ||
+                            !file.exclusionRegExp.test(fileName))) {
+                            files.push(filePath);
+                        }
+                    } else if (stat.isDirectory() &&
+                              (!file.exclusionRegExp || !file.exclusionRegExp.test(fileName))) {
+                        dirFiles = this.getFilteredFileList(filePath, regExpFilters, makeUnixPaths);
+                        //Do not use push.apply for dir listings, can hit limit of max number
+                        //of arguments to a function call, #921.
+                        dirFiles.forEach(function (dirFile) {
+                            files.push(dirFile);
+                        });
+                    }
+                }
+            }
+
+            return files; //Array
+        },
+
+        copyDir: function (/*String*/srcDir, /*String*/destDir, /*RegExp?*/regExpFilter, /*boolean?*/onlyCopyNew) {
+            //summary: copies files from srcDir to destDir using the regExpFilter to determine if the
+            //file should be copied. Returns a list file name strings of the destinations that were copied.
+            regExpFilter = regExpFilter || /\w/;
+
+            //Normalize th directory names, but keep front slashes.
+            //path module on windows now returns backslashed paths.
+            srcDir = frontSlash(path.normalize(srcDir));
+            destDir = frontSlash(path.normalize(destDir));
+
+            var fileNames = file.getFilteredFileList(srcDir, regExpFilter, true),
+            copiedFiles = [], i, srcFileName, destFileName;
+
+            for (i = 0; i < fileNames.length; i++) {
+                srcFileName = fileNames[i];
+                destFileName = srcFileName.replace(srcDir, destDir);
+
+                if (file.copyFile(srcFileName, destFileName, onlyCopyNew)) {
+                    copiedFiles.push(destFileName);
+                }
+            }
+
+            return copiedFiles.length ? copiedFiles : null; //Array or null
+        },
+
+        copyFile: function (/*String*/srcFileName, /*String*/destFileName, /*boolean?*/onlyCopyNew) {
+            //summary: copies srcFileName to destFileName. If onlyCopyNew is set, it only copies the file if
+            //srcFileName is newer than destFileName. Returns a boolean indicating if the copy occurred.
+            var parentDir;
+
+            //logger.trace("Src filename: " + srcFileName);
+            //logger.trace("Dest filename: " + destFileName);
+
+            //If onlyCopyNew is true, then compare dates and only copy if the src is newer
+            //than dest.
+            if (onlyCopyNew) {
+                if (file.exists(destFileName) && fs.statSync(destFileName).mtime.getTime() >= fs.statSync(srcFileName).mtime.getTime()) {
+                    return false; //Boolean
+                }
+            }
+
+            //Make sure destination dir exists.
+            parentDir = path.dirname(destFileName);
+            if (!file.exists(parentDir)) {
+                mkFullDir(parentDir);
+            }
+
+            fs.writeFileSync(destFileName, fs.readFileSync(srcFileName, 'binary'), 'binary');
+
+            return true; //Boolean
+        },
+
+        /**
+         * Renames a file. May fail if "to" already exists or is on another drive.
+         */
+        renameFile: function (from, to) {
+            return fs.renameSync(from, to);
+        },
+
+        /**
+         * Reads a *text* file.
+         */
+        readFile: function (/*String*/path, /*String?*/encoding) {
+            if (encoding === 'utf-8') {
+                encoding = 'utf8';
+            }
+            if (!encoding) {
+                encoding = 'utf8';
+            }
+
+            var text = fs.readFileSync(path, encoding);
+
+            //Hmm, would not expect to get A BOM, but it seems to happen,
+            //remove it just in case.
+            if (text.indexOf('\uFEFF') === 0) {
+                text = text.substring(1, text.length);
+            }
+
+            return text;
+        },
+
+        readFileAsync: function (path, encoding) {
+            var d = prim();
+            try {
+                d.resolve(file.readFile(path, encoding));
+            } catch (e) {
+                d.reject(e);
+            }
+            return d.promise;
+        },
+
+        saveUtf8File: function (/*String*/fileName, /*String*/fileContents) {
+            //summary: saves a *text* file using UTF-8 encoding.
+            file.saveFile(fileName, fileContents, "utf8");
+        },
+
+        saveFile: function (/*String*/fileName, /*String*/fileContents, /*String?*/encoding) {
+            //summary: saves a *text* file.
+            var parentDir;
+
+            if (encoding === 'utf-8') {
+                encoding = 'utf8';
+            }
+            if (!encoding) {
+                encoding = 'utf8';
+            }
+
+            //Make sure destination directories exist.
+            parentDir = path.dirname(fileName);
+            if (!file.exists(parentDir)) {
+                mkFullDir(parentDir);
+            }
+
+            fs.writeFileSync(fileName, fileContents, encoding);
+        },
+
+        deleteFile: function (/*String*/fileName) {
+            //summary: deletes a file or directory if it exists.
+            var files, i, stat;
+            if (file.exists(fileName)) {
+                stat = fs.lstatSync(fileName);
+                if (stat.isDirectory()) {
+                    files = fs.readdirSync(fileName);
+                    for (i = 0; i < files.length; i++) {
+                        this.deleteFile(path.join(fileName, files[i]));
+                    }
+                    fs.rmdirSync(fileName);
+                } else {
+                    fs.unlinkSync(fileName);
+                }
+            }
+        },
+
+
+        /**
+         * Deletes any empty directories under the given directory.
+         */
+        deleteEmptyDirs: function (startDir) {
+            var dirFileArray, i, fileName, filePath, stat;
+
+            if (file.exists(startDir)) {
+                dirFileArray = fs.readdirSync(startDir);
+                for (i = 0; i < dirFileArray.length; i++) {
+                    fileName = dirFileArray[i];
+                    filePath = path.join(startDir, fileName);
+                    stat = fs.lstatSync(filePath);
+                    if (stat.isDirectory()) {
+                        file.deleteEmptyDirs(filePath);
+                    }
+                }
+
+                //If directory is now empty, remove it.
+                if (fs.readdirSync(startDir).length ===  0) {
+                    file.deleteFile(startDir);
+                }
+            }
+        }
+    };
+
+    return file;
+
+});
+
+}
+
+if(env === 'rhino') {
+//Helper functions to deal with file I/O.
+
+/*jslint plusplus: false */
+/*global java: false, define: false */
+
+define('rhino/file', ['prim'], function (prim) {
+    var file = {
+        backSlashRegExp: /\\/g,
+
+        exclusionRegExp: /^\./,
+
+        getLineSeparator: function () {
+            return file.lineSeparator;
+        },
+
+        lineSeparator: java.lang.System.getProperty("line.separator"), //Java String
+
+        exists: function (fileName) {
+            return (new java.io.File(fileName)).exists();
+        },
+
+        parent: function (fileName) {
+            return file.absPath((new java.io.File(fileName)).getParentFile());
+        },
+
+        normalize: function (fileName) {
+            return file.absPath(fileName);
+        },
+
+        isFile: function (path) {
+            return (new java.io.File(path)).isFile();
+        },
+
+        isDirectory: function (path) {
+            return (new java.io.File(path)).isDirectory();
+        },
+
+        /**
+         * Gets the absolute file path as a string, normalized
+         * to using front slashes for path separators.
+         * @param {java.io.File||String} file
+         */
+        absPath: function (fileObj) {
+            if (typeof fileObj === "string") {
+                fileObj = new java.io.File(fileObj);
+            }
+            return (fileObj.getCanonicalPath() + "").replace(file.backSlashRegExp, "/");
+        },
+
+        getFilteredFileList: function (/*String*/startDir, /*RegExp*/regExpFilters, /*boolean?*/makeUnixPaths, /*boolean?*/startDirIsJavaObject) {
+            //summary: Recurses startDir and finds matches to the files that match regExpFilters.include
+            //and do not match regExpFilters.exclude. Or just one regexp can be passed in for regExpFilters,
+            //and it will be treated as the "include" case.
+            //Ignores files/directories that start with a period (.) unless exclusionRegExp
+            //is set to another value.
+            var files = [], topDir, regExpInclude, regExpExclude, dirFileArray,
+                i, fileObj, filePath, ok, dirFiles;
+
+            topDir = startDir;
+            if (!startDirIsJavaObject) {
+                topDir = new java.io.File(startDir);
+            }
+
+            regExpInclude = regExpFilters.include || regExpFilters;
+            regExpExclude = regExpFilters.exclude || null;
+
+            if (topDir.exists()) {
+                dirFileArray = topDir.listFiles();
+                for (i = 0; i < dirFileArray.length; i++) {
+                    fileObj = dirFileArray[i];
+                    if (fileObj.isFile()) {
+                        filePath = fileObj.getPath();
+                        if (makeUnixPaths) {
+                            //Make sure we have a JS string.
+                            filePath = String(filePath);
+                            if (filePath.indexOf("/") === -1) {
+                                filePath = filePath.replace(/\\/g, "/");
+                            }
+                        }
+
+                        ok = true;
+                        if (regExpInclude) {
+                            ok = filePath.match(regExpInclude);
+                        }
+                        if (ok && regExpExclude) {
+                            ok = !filePath.match(regExpExclude);
+                        }
+
+                        if (ok && (!file.exclusionRegExp ||
+                            !file.exclusionRegExp.test(fileObj.getName()))) {
+                            files.push(filePath);
+                        }
+                    } else if (fileObj.isDirectory() &&
+                              (!file.exclusionRegExp || !file.exclusionRegExp.test(fileObj.getName()))) {
+                        dirFiles = this.getFilteredFileList(fileObj, regExpFilters, makeUnixPaths, true);
+                        //Do not use push.apply for dir listings, can hit limit of max number
+                        //of arguments to a function call, #921.
+                        dirFiles.forEach(function (dirFile) {
+                            files.push(dirFile);
+                        });
+                    }
+                }
+            }
+
+            return files; //Array
+        },
+
+        copyDir: function (/*String*/srcDir, /*String*/destDir, /*RegExp?*/regExpFilter, /*boolean?*/onlyCopyNew) {
+            //summary: copies files from srcDir to destDir using the regExpFilter to determine if the
+            //file should be copied. Returns a list file name strings of the destinations that were copied.
+            regExpFilter = regExpFilter || /\w/;
+
+            var fileNames = file.getFilteredFileList(srcDir, regExpFilter, true),
+            copiedFiles = [], i, srcFileName, destFileName;
+
+            for (i = 0; i < fileNames.length; i++) {
+                srcFileName = fileNames[i];
+                destFileName = srcFileName.replace(srcDir, destDir);
+
+                if (file.copyFile(srcFileName, destFileName, onlyCopyNew)) {
+                    copiedFiles.push(destFileName);
+                }
+            }
+
+            return copiedFiles.length ? copiedFiles : null; //Array or null
+        },
+
+        copyFile: function (/*String*/srcFileName, /*String*/destFileName, /*boolean?*/onlyCopyNew) {
+            //summary: copies srcFileName to destFileName. If onlyCopyNew is set, it only copies the file if
+            //srcFileName is newer than destFileName. Returns a boolean indicating if the copy occurred.
+            var destFile = new java.io.File(destFileName), srcFile, parentDir,
+            srcChannel, destChannel;
+
+            //logger.trace("Src filename: " + srcFileName);
+            //logger.trace("Dest filename: " + destFileName);
+
+            //If onlyCopyNew is true, then compare dates and only copy if the src is newer
+            //than dest.
+            if (onlyCopyNew) {
+                srcFile = new java.io.File(srcFileName);
+                if (destFile.exists() && destFile.lastModified() >= srcFile.lastModified()) {
+                    return false; //Boolean
+                }
+            }
+
+            //Make sure destination dir exists.
+            parentDir = destFile.getParentFile();
+            if (!parentDir.exists()) {
+                if (!parentDir.mkdirs()) {
+                    throw "Could not create directory: " + parentDir.getCanonicalPath();
+                }
+            }
+
+            //Java's version of copy file.
+            srcChannel = new java.io.FileInputStream(srcFileName).getChannel();
+            destChannel = new java.io.FileOutputStream(destFileName).getChannel();
+            destChannel.transferFrom(srcChannel, 0, srcChannel.size());
+            srcChannel.close();
+            destChannel.close();
+
+            return true; //Boolean
+        },
+
+        /**
+         * Renames a file. May fail if "to" already exists or is on another drive.
+         */
+        renameFile: function (from, to) {
+            return (new java.io.File(from)).renameTo((new java.io.File(to)));
+        },
+
+        readFile: function (/*String*/path, /*String?*/encoding) {
+            //A file read function that can deal with BOMs
+            encoding = encoding || "utf-8";
+            var fileObj = new java.io.File(path),
+                    input = new java.io.BufferedReader(new java.io.InputStreamReader(new java.io.FileInputStream(fileObj), encoding)),
+                    stringBuffer, line;
+            try {
+                stringBuffer = new java.lang.StringBuffer();
+                line = input.readLine();
+
+                // Byte Order Mark (BOM) - The Unicode Standard, version 3.0, page 324
+                // http://www.unicode.org/faq/utf_bom.html
+
+                // Note that when we use utf-8, the BOM should appear as "EF BB BF", but it doesn't due to this bug in the JDK:
+                // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4508058
+                if (line && line.length() && line.charAt(0) === 0xfeff) {
+                    // Eat the BOM, since we've already found the encoding on this file,
+                    // and we plan to concatenating this buffer with others; the BOM should
+                    // only appear at the top of a file.
+                    line = line.substring(1);
+                }
+                while (line !== null) {
+                    stringBuffer.append(line);
+                    stringBuffer.append(file.lineSeparator);
+                    line = input.readLine();
+                }
+                //Make sure we return a JavaScript string and not a Java string.
+                return String(stringBuffer.toString()); //String
+            } finally {
+                input.close();
+            }
+        },
+
+        readFileAsync: function (path, encoding) {
+            var d = prim();
+            try {
+                d.resolve(file.readFile(path, encoding));
+            } catch (e) {
+                d.reject(e);
+            }
+            return d.promise;
+        },
+
+        saveUtf8File: function (/*String*/fileName, /*String*/fileContents) {
+            //summary: saves a file using UTF-8 encoding.
+            file.saveFile(fileName, fileContents, "utf-8");
+        },
+
+        saveFile: function (/*String*/fileName, /*String*/fileContents, /*String?*/encoding) {
+            //summary: saves a file.
+            var outFile = new java.io.File(fileName), outWriter, parentDir, os;
+
+            parentDir = outFile.getAbsoluteFile().getParentFile();
+            if (!parentDir.exists()) {
+                if (!parentDir.mkdirs()) {
+                    throw "Could not create directory: " + parentDir.getAbsolutePath();
+                }
+            }
+
+            if (encoding) {
+                outWriter = new java.io.OutputStreamWriter(new java.io.FileOutputStream(outFile), encoding);
+            } else {
+                outWriter = new java.io.OutputStreamWriter(new java.io.FileOutputStream(outFile));
+            }
+
+            os = new java.io.BufferedWriter(outWriter);
+            try {
+                //If in Nashorn, need to coerce the JS string to a Java string so that
+                //writer.write method dispatch correctly detects the type.
+                if (typeof importPackage !== 'undefined') {
+                    os.write(fileContents);
+                } else {
+                    os.write(new java.lang.String(fileContents));
+                }
+            } finally {
+                os.close();
+            }
+        },
+
+        deleteFile: function (/*String*/fileName) {
+            //summary: deletes a file or directory if it exists.
+            var fileObj = new java.io.File(fileName), files, i;
+            if (fileObj.exists()) {
+                if (fileObj.isDirectory()) {
+                    files = fileObj.listFiles();
+                    for (i = 0; i < files.length; i++) {
+                        this.deleteFile(files[i]);
+                    }
+                }
+                fileObj["delete"]();
+            }
+        },
+
+        /**
+         * Deletes any empty directories under the given directory.
+         * The startDirIsJavaObject is private to this implementation's
+         * recursion needs.
+         */
+        deleteEmptyDirs: function (startDir, startDirIsJavaObject) {
+            var topDir = startDir,
+                dirFileArray, i, fileObj;
+
+            if (!startDirIsJavaObject) {
+                topDir = new java.io.File(startDir);
+            }
+
+            if (topDir.exists()) {
+                dirFileArray = topDir.listFiles();
+                for (i = 0; i < dirFileArray.length; i++) {
+                    fileObj = dirFileArray[i];
+                    if (fileObj.isDirectory()) {
+                        file.deleteEmptyDirs(fileObj, true);
+                    }
+                }
+
+                //If the directory is empty now, delete it.
+                if (topDir.listFiles().length === 0) {
+                    file.deleteFile(String(topDir.getPath()));
+                }
+            }
+        }
+    };
+
+    return file;
+});
+
+}
+
+if(env === 'xpconnect') {
+//Helper functions to deal with file I/O.
+
+/*jslint plusplus: false */
+/*global define, Components, xpcUtil */
+
+define('xpconnect/file', ['prim'], function (prim) {
+    var file,
+        Cc = Components.classes,
+        Ci = Components.interfaces,
+        //Depends on xpcUtil which is set up in x.js
+        xpfile = xpcUtil.xpfile;
+
+    function mkFullDir(dirObj) {
+        //1 is DIRECTORY_TYPE, 511 is 0777 permissions
+        if (!dirObj.exists()) {
+            dirObj.create(1, 511);
+        }
+    }
+
+    file = {
+        backSlashRegExp: /\\/g,
+
+        exclusionRegExp: /^\./,
+
+        getLineSeparator: function () {
+            return file.lineSeparator;
+        },
+
+        lineSeparator: ('@mozilla.org/windows-registry-key;1' in Cc) ?
+                        '\r\n' : '\n',
+
+        exists: function (fileName) {
+            return xpfile(fileName).exists();
+        },
+
+        parent: function (fileName) {
+            return xpfile(fileName).parent;
+        },
+
+        normalize: function (fileName) {
+            return file.absPath(fileName);
+        },
+
+        isFile: function (path) {
+            return xpfile(path).isFile();
+        },
+
+        isDirectory: function (path) {
+            return xpfile(path).isDirectory();
+        },
+
+        /**
+         * Gets the absolute file path as a string, normalized
+         * to using front slashes for path separators.
+         * @param {java.io.File||String} file
+         */
+        absPath: function (fileObj) {
+            if (typeof fileObj === "string") {
+                fileObj = xpfile(fileObj);
+            }
+            return fileObj.path;
+        },
+
+        getFilteredFileList: function (/*String*/startDir, /*RegExp*/regExpFilters, /*boolean?*/makeUnixPaths, /*boolean?*/startDirIsObject) {
+            //summary: Recurses startDir and finds matches to the files that match regExpFilters.include
+            //and do not match regExpFilters.exclude. Or just one regexp can be passed in for regExpFilters,
+            //and it will be treated as the "include" case.
+            //Ignores files/directories that start with a period (.) unless exclusionRegExp
+            //is set to another value.
+            var files = [], topDir, regExpInclude, regExpExclude, dirFileArray,
+                fileObj, filePath, ok, dirFiles;
+
+            topDir = startDir;
+            if (!startDirIsObject) {
+                topDir = xpfile(startDir);
+            }
+
+            regExpInclude = regExpFilters.include || regExpFilters;
+            regExpExclude = regExpFilters.exclude || null;
+
+            if (topDir.exists()) {
+                dirFileArray = topDir.directoryEntries;
+                while (dirFileArray.hasMoreElements()) {
+                    fileObj = dirFileArray.getNext().QueryInterface(Ci.nsILocalFile);
+                    if (fileObj.isFile()) {
+                        filePath = fileObj.path;
+                        if (makeUnixPaths) {
+                            if (filePath.indexOf("/") === -1) {
+                                filePath = filePath.replace(/\\/g, "/");
+                            }
+                        }
+
+                        ok = true;
+                        if (regExpInclude) {
+                            ok = filePath.match(regExpInclude);
+                        }
+                        if (ok && regExpExclude) {
+                            ok = !filePath.match(regExpExclude);
+                        }
+
+                        if (ok && (!file.exclusionRegExp ||
+                            !file.exclusionRegExp.test(fileObj.leafName))) {
+                            files.push(filePath);
+                        }
+                    } else if (fileObj.isDirectory() &&
+                              (!file.exclusionRegExp || !file.exclusionRegExp.test(fileObj.leafName))) {
+                        dirFiles = this.getFilteredFileList(fileObj, regExpFilters, makeUnixPaths, true);
+                        //Do not use push.apply for dir listings, can hit limit of max number
+                        //of arguments to a function call, #921.
+                        dirFiles.forEach(function (dirFile) {
+                            files.push(dirFile);
+                        });
+                    }
+                }
+            }
+
+            return files; //Array
+        },
+
+        copyDir: function (/*String*/srcDir, /*String*/destDir, /*RegExp?*/regExpFilter, /*boolean?*/onlyCopyNew) {
+            //summary: copies files from srcDir to destDir using the regExpFilter to determine if the
+            //file should be copied. Returns a list file name strings of the destinations that were copied.
+            regExpFilter = regExpFilter || /\w/;
+
+            var fileNames = file.getFilteredFileList(srcDir, regExpFilter, true),
+            copiedFiles = [], i, srcFileName, destFileName;
+
+            for (i = 0; i < fileNames.length; i += 1) {
+                srcFileName = fileNames[i];
+                destFileName = srcFileName.replace(srcDir, destDir);
+
+                if (file.copyFile(srcFileName, destFileName, onlyCopyNew)) {
+                    copiedFiles.push(destFileName);
+                }
+            }
+
+            return copiedFiles.length ? copiedFiles : null; //Array or null
+        },
+
+        copyFile: function (/*String*/srcFileName, /*String*/destFileName, /*boolean?*/onlyCopyNew) {
+            //summary: copies srcFileName to destFileName. If onlyCopyNew is set, it only copies the file if
+            //srcFileName is newer than destFileName. Returns a boolean indicating if the copy occurred.
+            var destFile = xpfile(destFileName),
+            srcFile = xpfile(srcFileName);
+
+            //logger.trace("Src filename: " + srcFileName);
+            //logger.trace("Dest filename: " + destFileName);
+
+            //If onlyCopyNew is true, then compare dates and only copy if the src is newer
+            //than dest.
+            if (onlyCopyNew) {
+                if (destFile.exists() && destFile.lastModifiedTime >= srcFile.lastModifiedTime) {
+                    return false; //Boolean
+                }
+            }
+
+            srcFile.copyTo(destFile.parent, destFile.leafName);
+
+            return true; //Boolean
+        },
+
+        /**
+         * Renames a file. May fail if "to" already exists or is on another drive.
+         */
+        renameFile: function (from, to) {
+            var toFile = xpfile(to);
+            return xpfile(from).moveTo(toFile.parent, toFile.leafName);
+        },
+
+        readFile: xpcUtil.readFile,
+
+        readFileAsync: function (path, encoding) {
+            var d = prim();
+            try {
+                d.resolve(file.readFile(path, encoding));
+            } catch (e) {
+                d.reject(e);
+            }
+            return d.promise;
+        },
+
+        saveUtf8File: function (/*String*/fileName, /*String*/fileContents) {
+            //summary: saves a file using UTF-8 encoding.
+            file.saveFile(fileName, fileContents, "utf-8");
+        },
+
+        saveFile: function (/*String*/fileName, /*String*/fileContents, /*String?*/encoding) {
+            var outStream, convertStream,
+                fileObj = xpfile(fileName);
+
+            mkFullDir(fileObj.parent);
+
+            try {
+                outStream = Cc['@mozilla.org/network/file-output-stream;1']
+                             .createInstance(Ci.nsIFileOutputStream);
+                //438 is decimal for 0777
+                outStream.init(fileObj, 0x02 | 0x08 | 0x20, 511, 0);
+
+                convertStream = Cc['@mozilla.org/intl/converter-output-stream;1']
+                                  .createInstance(Ci.nsIConverterOutputStream);
+
+                convertStream.init(outStream, encoding, 0, 0);
+                convertStream.writeString(fileContents);
+            } catch (e) {
+                throw new Error((fileObj && fileObj.path || '') + ': ' + e);
+            } finally {
+                if (convertStream) {
+                    convertStream.close();
+                }
+                if (outStream) {
+                    outStream.close();
+                }
+            }
+        },
+
+        deleteFile: function (/*String*/fileName) {
+            //summary: deletes a file or directory if it exists.
+            var fileObj = xpfile(fileName);
+            if (fileObj.exists()) {
+                fileObj.remove(true);
+            }
+        },
+
+        /**
+         * Deletes any empty directories under the given directory.
+         * The startDirIsJavaObject is private to this implementation's
+         * recursion needs.
+         */
+        deleteEmptyDirs: function (startDir, startDirIsObject) {
+            var topDir = startDir,
+                dirFileArray, fileObj;
+
+            if (!startDirIsObject) {
+                topDir = xpfile(startDir);
+            }
+
+            if (topDir.exists()) {
+                dirFileArray = topDir.directoryEntries;
+                while (dirFileArray.hasMoreElements()) {
+                    fileObj = dirFileArray.getNext().QueryInterface(Ci.nsILocalFile);
+
+                    if (fileObj.isDirectory()) {
+                        file.deleteEmptyDirs(fileObj, true);
+                    }
+                }
+
+                //If the directory is empty now, delete it.
+                dirFileArray = topDir.directoryEntries;
+                if (!dirFileArray.hasMoreElements()) {
+                    file.deleteFile(topDir.path);
+                }
+            }
+        }
+    };
+
+    return file;
+});
+
+}
+
+if(env === 'browser') {
+/*global process */
+define('browser/quit', function () {
+    'use strict';
+    return function (code) {
+    };
+});
+}
+
+if(env === 'node') {
+/*global process */
+define('node/quit', function () {
+    'use strict';
+    return function (code) {
+        var draining = 0;
+        var exit = function () {
+            if (draining === 0) {
+                process.exit(code);
+            } else {
+                draining -= 1;
+            }
+        };
+        if (process.stdout.bufferSize) {
+            draining += 1;
+            process.stdout.once('drain', exit);
+        }
+        if (process.stderr.bufferSize) {
+            draining += 1;
+            process.stderr.once('drain', exit);
+        }
+        exit();
+    };
+});
+
+}
+
+if(env === 'rhino') {
+/*global quit */
+define('rhino/quit', function () {
+    'use strict';
+    return function (code) {
+        return quit(code);
+    };
+});
+
+}
+
+if(env === 'xpconnect') {
+/*global quit */
+define('xpconnect/quit', function () {
+    'use strict';
+    return function (code) {
+        return quit(code);
+    };
+});
+
+}
+
+if(env === 'browser') {
+/*jslint strict: false */
+/*global define: false, console: false */
+
+define('browser/print', function () {
+    function print(msg) {
+        console.log(msg);
+    }
+
+    return print;
+});
+
+}
+
+if(env === 'node') {
+/*jslint strict: false */
+/*global define: false, console: false */
+
+define('node/print', function () {
+    function print(msg) {
+        console.log(msg);
+    }
+
+    return print;
+});
+
+}
+
+if(env === 'rhino') {
+/*jslint strict: false */
+/*global define: false, print: false */
+
+define('rhino/print', function () {
+    return print;
+});
+
+}
+
+if(env === 'xpconnect') {
+/*jslint strict: false */
+/*global define: false, print: false */
+
+define('xpconnect/print', function () {
+    return print;
+});
+
+}
+/*jslint nomen: false, strict: false */
+/*global define: false */
+
+define('logger', ['env!env/print'], function (print) {
+    var logger = {
+        TRACE: 0,
+        INFO: 1,
+        WARN: 2,
+        ERROR: 3,
+        SILENT: 4,
+        level: 0,
+        logPrefix: "",
+
+        logLevel: function( level ) {
+            this.level = level;
+        },
+
+        trace: function (message) {
+            if (this.level <= this.TRACE) {
+                this._print(message);
+            }
+        },
+
+        info: function (message) {
+            if (this.level <= this.INFO) {
+                this._print(message);
+            }
+        },
+
+        warn: function (message) {
+            if (this.level <= this.WARN) {
+                this._print(message);
+            }
+        },
+
+        error: function (message) {
+            if (this.level <= this.ERROR) {
+                this._print(message);
+            }
+        },
+
+        _print: function (message) {
+            this._sysPrint((this.logPrefix ? (this.logPrefix + " ") : "") + message);
+        },
+
+        _sysPrint: function (message) {
+            print(message);
+        }
+    };
+
+    return logger;
+});
+//Just a blank file to use when building the optimizer with the optimizer,
+//so that the build does not attempt to inline some env modules,
+//like Node's fs and path.
+
+(function webpackUniversalModuleDefinition(root, factory) {
+/* istanbul ignore next */
+	if(typeof define === 'function' && define.amd)
+		define('esprima', [], 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. '&#123;'

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

+	                        break;

+	                    case 3:

+	                        if (numeric) {

+	                            // e.g. '&#x41;'

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

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

+	                            numeric = numeric && !hex;

+	                        }

+	                        break;

+	                    default:

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

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

+	                        break;

+	                }

+	            }

+	        }

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

+	            // e.g. '&#x41;' becomes just '#x41'

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

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

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

+	            }

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

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

+	            }

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

+	                result = xhtml_entities_1.XHTMLEntities[str];

+	            }

+	        }

+	        return result;

+	    };

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

+	    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++];

+	            return {

+	                type: 7 /* Punctuator */,

+	                value: value,

+	                lineNumber: this.scanner.lineNumber,

+	                lineStart: this.scanner.lineStart,

+	                start: this.scanner.index - 1,

+	                end: this.scanner.index

+	            };

+	        }

+	        // " '

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

+	            var start = this.scanner.index;

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

+	            var str = '';

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

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

+	                if (ch === quote) {

+	                    break;

+	                }

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

+	                    str += this.scanXHTMLEntity(quote);

+	                }

+	                else {

+	                    str += ch;

+	                }

+	            }

+	            return {

+	                type: 8 /* StringLiteral */,

+	                value: str,

+	                lineNumber: this.scanner.lineNumber,

+	                lineStart: this.scanner.lineStart,

+	                start: start,

+	                end: this.scanner.index

+	            };

+	        }

+	        // ... or .

+	        if (cp === 46) {

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

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

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

+	            var start = this.scanner.index;

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

+	            return {

+	                type: 7 /* Punctuator */,

+	                value: value,

+	                lineNumber: this.scanner.lineNumber,

+	                lineStart: this.scanner.lineStart,

+	                start: start,

+	                end: this.scanner.index

+	            };

+	        }

+	        // `

+	        if (cp === 96) {

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

+	            return {

+	                type: 10 /* Template */,

+	                value: '',

+	                lineNumber: this.scanner.lineNumber,

+	                lineStart: this.scanner.lineStart,

+	                start: this.scanner.index,

+	                end: this.scanner.index

+	            };

+	        }

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

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

+	            var start = this.scanner.index;

+	            ++this.scanner.index;

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

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

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

+	                    ++this.scanner.index;

+	                }

+	                else if (ch === 45) {

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

+	                    ++this.scanner.index;

+	                }

+	                else {

+	                    break;

+	                }

+	            }

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

+	            return {

+	                type: 100 /* Identifier */,

+	                value: id,

+	                lineNumber: this.scanner.lineNumber,

+	                lineStart: this.scanner.lineStart,

+	                start: start,

+	                end: this.scanner.index

+	            };

+	        }

+	        return this.scanner.lex();

+	    };

+	    JSXParser.prototype.nextJSXToken = function () {

+	        this.collectComments();

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

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

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

+	        var token = this.lexJSX();

+	        this.lastMarker.index = this.scanner.index;

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

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

+	        if (this.config.tokens) {

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

+	        }

+	        return token;

+	    };

+	    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;

+	        var text = '';

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

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

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

+	                break;

+	            }

+	            ++this.scanner.index;

+	            text += ch;

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

+	                ++this.scanner.lineNumber;

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

+	                    ++this.scanner.index;

+	                }

+	                this.scanner.lineStart = this.scanner.index;

+	            }

+	        }

+	        this.lastMarker.index = this.scanner.index;

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

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

+	        var token = {

+	            type: 101 /* Text */,

+	            value: text,

+	            lineNumber: this.scanner.lineNumber,

+	            lineStart: this.scanner.lineStart,

+	            start: start,

+	            end: this.scanner.index

+	        };

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

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

+	        }

+	        return token;

+	    };

+	    JSXParser.prototype.peekJSXToken = function () {

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

+	        this.scanner.scanComments();

+	        var next = this.lexJSX();

+	        this.scanner.restoreState(state);

+	        return next;

+	    };

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

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

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

+	        var token = this.nextJSXToken();

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

+	            this.throwUnexpectedToken(token);

+	        }

+	    };

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

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

+	        var next = this.peekJSXToken();

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

+	    };

+	    JSXParser.prototype.parseJSXIdentifier = function () {

+	        var node = this.createJSXNode();

+	        var token = this.nextJSXToken();

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

+	            this.throwUnexpectedToken(token);

+	        }

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

+	    };

+	    JSXParser.prototype.parseJSXElementName = function () {

+	        var node = this.createJSXNode();

+	        var elementName = this.parseJSXIdentifier();

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

+	            var namespace = elementName;

+	            this.expectJSX(':');

+	            var name_1 = this.parseJSXIdentifier();

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

+	        }

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

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

+	                var object = elementName;

+	                this.expectJSX('.');

+	                var property = this.parseJSXIdentifier();

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

+	            }

+	        }

+	        return elementName;

+	    };

+	    JSXParser.prototype.parseJSXAttributeName = function () {

+	        var node = this.createJSXNode();

+	        var attributeName;

+	        var identifier = this.parseJSXIdentifier();

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

+	            var namespace = identifier;

+	            this.expectJSX(':');

+	            var name_2 = this.parseJSXIdentifier();

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

+	        }

+	        else {

+	            attributeName = identifier;

+	        }

+	        return attributeName;

+	    };

+	    JSXParser.prototype.parseJSXStringLiteralAttribute = function () {

+	        var node = this.createJSXNode();

+	        var token = this.nextJSXToken();

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

+	            this.throwUnexpectedToken(token);

+	        }

+	        var raw = this.getTokenRaw(token);

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

+	    };

+	    JSXParser.prototype.parseJSXExpressionAttribute = function () {

+	        var node = this.createJSXNode();

+	        this.expectJSX('{');

+	        this.finishJSX();

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

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

+	        }

+	        var expression = this.parseAssignmentExpression();

+	        this.reenterJSX();

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

+	    };

+	    JSXParser.prototype.parseJSXAttributeValue = function () {

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

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

+	    };

+	    JSXParser.prototype.parseJSXNameValueAttribute = function () {

+	        var node = this.createJSXNode();

+	        var name = this.parseJSXAttributeName();

+	        var value = null;

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

+	            this.expectJSX('=');

+	            value = this.parseJSXAttributeValue();

+	        }

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

+	    };

+	    JSXParser.prototype.parseJSXSpreadAttribute = function () {

+	        var node = this.createJSXNode();

+	        this.expectJSX('{');

+	        this.expectJSX('...');

+	        this.finishJSX();

+	        var argument = this.parseAssignmentExpression();

+	        this.reenterJSX();

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

+	    };

+	    JSXParser.prototype.parseJSXAttributes = function () {

+	        var attributes = [];

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

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

+	                this.parseJSXNameValueAttribute();

+	            attributes.push(attribute);

+	        }

+	        return attributes;

+	    };

+	    JSXParser.prototype.parseJSXOpeningElement = function () {

+	        var node = this.createJSXNode();

+	        this.expectJSX('<');

+	        var name = this.parseJSXElementName();

+	        var attributes = this.parseJSXAttributes();

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

+	        if (selfClosing) {

+	            this.expectJSX('/');

+	        }

+	        this.expectJSX('>');

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

+	    };

+	    JSXParser.prototype.parseJSXBoundaryElement = function () {

+	        var node = this.createJSXNode();

+	        this.expectJSX('<');

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

+	            this.expectJSX('/');

+	            var name_3 = this.parseJSXElementName();

+	            this.expectJSX('>');

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

+	        }

+	        var name = this.parseJSXElementName();

+	        var attributes = this.parseJSXAttributes();

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

+	        if (selfClosing) {

+	            this.expectJSX('/');

+	        }

+	        this.expectJSX('>');

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

+	    };

+	    JSXParser.prototype.parseJSXEmptyExpression = function () {

+	        var node = this.createJSXChildNode();

+	        this.collectComments();

+	        this.lastMarker.index = this.scanner.index;

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

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

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

+	    };

+	    JSXParser.prototype.parseJSXExpressionContainer = function () {

+	        var node = this.createJSXNode();

+	        this.expectJSX('{');

+	        var expression;

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

+	            expression = this.parseJSXEmptyExpression();

+	            this.expectJSX('}');

+	        }

+	        else {

+	            this.finishJSX();

+	            expression = this.parseAssignmentExpression();

+	            this.reenterJSX();

+	        }

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

+	    };

+	    JSXParser.prototype.parseJSXChildren = function () {

+	        var children = [];

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

+	            var node = this.createJSXChildNode();

+	            var token = this.nextJSXText();

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

+	                var raw = this.getTokenRaw(token);

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

+	                children.push(child);

+	            }

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

+	                var container = this.parseJSXExpressionContainer();

+	                children.push(container);

+	            }

+	            else {

+	                break;

+	            }

+	        }

+	        return children;

+	    };

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

+	        var stack = [];

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

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

+	            var node = this.createJSXChildNode();

+	            var element = this.parseJSXBoundaryElement();

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

+	                var opening = element;

+	                if (opening.selfClosing) {

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

+	                    el.children.push(child);

+	                }

+	                else {

+	                    stack.push(el);

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

+	                }

+	            }

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

+	                el.closing = element;

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

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

+	                if (open_1 !== close_1) {

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

+	                }

+	                if (stack.length > 0) {

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

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

+	                    el.children.push(child);

+	                    stack.pop();

+	                }

+	                else {

+	                    break;

+	                }

+	            }

+	        }

+	        return el;

+	    };

+	    JSXParser.prototype.parseJSXElement = function () {

+	        var node = this.createJSXNode();

+	        var opening = this.parseJSXOpeningElement();

+	        var children = [];

+	        var closing = null;

+	        if (!opening.selfClosing) {

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

+	            children = el.children;

+	            closing = el.closing;

+	        }

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

+	    };

+	    JSXParser.prototype.parseJSXRoot = function () {

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

+	        if (this.config.tokens) {

+	            this.tokens.pop();

+	        }

+	        this.startJSX();

+	        var element = this.parseJSXElement();

+	        this.finishJSX();

+	        return element;

+	    };

+	    JSXParser.prototype.isStartOfExpression = function () {

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

+	    };

+	    return JSXParser;

+	}(parser_1.Parser));

+	exports.JSXParser = JSXParser;

+
+
+/***/ },
+/* 4 */
+/***/ function(module, exports) {
+
+	"use strict";

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

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

+	var Regex = {

+	    // Unicode v8.0.0 NonAsciiIdentifierStart:

+	    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]/,

+	    // Unicode v8.0.0 NonAsciiIdentifierPart:

+	    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]/

+	};

+	exports.Character = {

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

+	    fromCodePoint: function (cp) {

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

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

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

+	    },

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

+	    isWhiteSpace: function (cp) {

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

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

+	    },

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

+	    isLineTerminator: function (cp) {

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

+	    },

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

+	    isIdentifierStart: function (cp) {

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

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

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

+	            (cp === 0x5C) ||

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

+	    },

+	    isIdentifierPart: function (cp) {

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

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

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

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

+	            (cp === 0x5C) ||

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

+	    },

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

+	    isDecimalDigit: function (cp) {

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

+	    },

+	    isHexDigit: function (cp) {

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

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

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

+	    },

+	    isOctalDigit: function (cp) {

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

+	    }

+	};

+
+
+/***/ },
+/* 5 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";

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

+	var jsx_syntax_1 = __webpack_require__(6);

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

+	var JSXClosingElement = (function () {

+	    function JSXClosingElement(name) {

+	        this.type = jsx_syntax_1.JSXSyntax.JSXClosingElement;

+	        this.name = name;

+	    }

+	    return JSXClosingElement;

+	}());

+	exports.JSXClosingElement = JSXClosingElement;

+	var JSXElement = (function () {

+	    function JSXElement(openingElement, children, closingElement) {

+	        this.type = jsx_syntax_1.JSXSyntax.JSXElement;

+	        this.openingElement = openingElement;

+	        this.children = children;

+	        this.closingElement = closingElement;

+	    }

+	    return JSXElement;

+	}());

+	exports.JSXElement = JSXElement;

+	var JSXEmptyExpression = (function () {

+	    function JSXEmptyExpression() {

+	        this.type = jsx_syntax_1.JSXSyntax.JSXEmptyExpression;

+	    }

+	    return JSXEmptyExpression;

+	}());

+	exports.JSXEmptyExpression = JSXEmptyExpression;

+	var JSXExpressionContainer = (function () {

+	    function JSXExpressionContainer(expression) {

+	        this.type = jsx_syntax_1.JSXSyntax.JSXExpressionContainer;

+	        this.expression = expression;

+	    }

+	    return JSXExpressionContainer;

+	}());

+	exports.JSXExpressionContainer = JSXExpressionContainer;

+	var JSXIdentifier = (function () {

+	    function JSXIdentifier(name) {

+	        this.type = jsx_syntax_1.JSXSyntax.JSXIdentifier;

+	        this.name = name;

+	    }

+	    return JSXIdentifier;

+	}());

+	exports.JSXIdentifier = JSXIdentifier;

+	var JSXMemberExpression = (function () {

+	    function JSXMemberExpression(object, property) {

+	        this.type = jsx_syntax_1.JSXSyntax.JSXMemberExpression;

+	        this.object = object;

+	        this.property = property;

+	    }

+	    return JSXMemberExpression;

+	}());

+	exports.JSXMemberExpression = JSXMemberExpression;

+	var JSXAttribute = (function () {

+	    function JSXAttribute(name, value) {

+	        this.type = jsx_syntax_1.JSXSyntax.JSXAttribute;

+	        this.name = name;

+	        this.value = value;

+	    }

+	    return JSXAttribute;

+	}());

+	exports.JSXAttribute = JSXAttribute;

+	var JSXNamespacedName = (function () {

+	    function JSXNamespacedName(namespace, name) {

+	        this.type = jsx_syntax_1.JSXSyntax.JSXNamespacedName;

+	        this.namespace = namespace;

+	        this.name = name;

+	    }

+	    return JSXNamespacedName;

+	}());

+	exports.JSXNamespacedName = JSXNamespacedName;

+	var JSXOpeningElement = (function () {

+	    function JSXOpeningElement(name, selfClosing, attributes) {

+	        this.type = jsx_syntax_1.JSXSyntax.JSXOpeningElement;

+	        this.name = name;

+	        this.selfClosing = selfClosing;

+	        this.attributes = attributes;

+	    }

+	    return JSXOpeningElement;

+	}());

+	exports.JSXOpeningElement = JSXOpeningElement;

+	var JSXSpreadAttribute = (function () {

+	    function JSXSpreadAttribute(argument) {

+	        this.type = jsx_syntax_1.JSXSyntax.JSXSpreadAttribute;

+	        this.argument = argument;

+	    }

+	    return JSXSpreadAttribute;

+	}());

+	exports.JSXSpreadAttribute = JSXSpreadAttribute;

+	var JSXText = (function () {

+	    function JSXText(value, raw) {

+	        this.type = jsx_syntax_1.JSXSyntax.JSXText;

+	        this.value = value;

+	        this.raw = raw;

+	    }

+	    return JSXText;

+	}());

+	exports.JSXText = JSXText;

+
+
+/***/ },
+/* 6 */
+/***/ function(module, exports) {
+
+	"use strict";

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

+	exports.JSXSyntax = {

+	    JSXAttribute: 'JSXAttribute',

+	    JSXClosingElement: 'JSXClosingElement',

+	    JSXElement: 'JSXElement',

+	    JSXEmptyExpression: 'JSXEmptyExpression',

+	    JSXExpressionContainer: 'JSXExpressionContainer',

+	    JSXIdentifier: 'JSXIdentifier',

+	    JSXMemberExpression: 'JSXMemberExpression',

+	    JSXNamespacedName: 'JSXNamespacedName',

+	    JSXOpeningElement: 'JSXOpeningElement',

+	    JSXSpreadAttribute: 'JSXSpreadAttribute',

+	    JSXText: 'JSXText'

+	};

+
+
+/***/ },
+/* 7 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";

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

+	var syntax_1 = __webpack_require__(2);

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

+	var ArrayExpression = (function () {

+	    function ArrayExpression(elements) {

+	        this.type = syntax_1.Syntax.ArrayExpression;

+	        this.elements = elements;

+	    }

+	    return ArrayExpression;

+	}());

+	exports.ArrayExpression = ArrayExpression;

+	var ArrayPattern = (function () {

+	    function ArrayPattern(elements) {

+	        this.type = syntax_1.Syntax.ArrayPattern;

+	        this.elements = elements;

+	    }

+	    return ArrayPattern;

+	}());

+	exports.ArrayPattern = ArrayPattern;

+	var ArrowFunctionExpression = (function () {

+	    function ArrowFunctionExpression(params, body, expression) {

+	        this.type = syntax_1.Syntax.ArrowFunctionExpression;

+	        this.id = null;

+	        this.params = params;

+	        this.body = body;

+	        this.generator = false;

+	        this.expression = expression;

+	        this.async = false;

+	    }

+	    return ArrowFunctionExpression;

+	}());

+	exports.ArrowFunctionExpression = ArrowFunctionExpression;

+	var AssignmentExpression = (function () {

+	    function AssignmentExpression(operator, left, right) {

+	        this.type = syntax_1.Syntax.AssignmentExpression;

+	        this.operator = operator;

+	        this.left = left;

+	        this.right = right;

+	    }

+	    return AssignmentExpression;

+	}());

+	exports.AssignmentExpression = AssignmentExpression;

+	var AssignmentPattern = (function () {

+	    function AssignmentPattern(left, right) {

+	        this.type = syntax_1.Syntax.AssignmentPattern;

+	        this.left = left;

+	        this.right = right;

+	    }

+	    return AssignmentPattern;

+	}());

+	exports.AssignmentPattern = AssignmentPattern;

+	var AsyncArrowFunctionExpression = (function () {

+	    function AsyncArrowFunctionExpression(params, body, expression) {

+	        this.type = syntax_1.Syntax.ArrowFunctionExpression;

+	        this.id = null;

+	        this.params = params;

+	        this.body = body;

+	        this.generator = false;

+	        this.expression = expression;

+	        this.async = true;

+	    }

+	    return AsyncArrowFunctionExpression;

+	}());

+	exports.AsyncArrowFunctionExpression = AsyncArrowFunctionExpression;

+	var AsyncFunctionDeclaration = (function () {

+	    function AsyncFunctionDeclaration(id, params, body) {

+	        this.type = syntax_1.Syntax.FunctionDeclaration;

+	        this.id = id;

+	        this.params = params;

+	        this.body = body;

+	        this.generator = false;

+	        this.expression = false;

+	        this.async = true;

+	    }

+	    return AsyncFunctionDeclaration;

+	}());

+	exports.AsyncFunctionDeclaration = AsyncFunctionDeclaration;

+	var AsyncFunctionExpression = (function () {

+	    function AsyncFunctionExpression(id, params, body) {

+	        this.type = syntax_1.Syntax.FunctionExpression;

+	        this.id = id;

+	        this.params = params;

+	        this.body = body;

+	        this.generator = false;

+	        this.expression = false;

+	        this.async = true;

+	    }

+	    return AsyncFunctionExpression;

+	}());

+	exports.AsyncFunctionExpression = AsyncFunctionExpression;

+	var AwaitExpression = (function () {

+	    function AwaitExpression(argument) {

+	        this.type = syntax_1.Syntax.AwaitExpression;

+	        this.argument = argument;

+	    }

+	    return AwaitExpression;

+	}());

+	exports.AwaitExpression = AwaitExpression;

+	var BinaryExpression = (function () {

+	    function BinaryExpression(operator, left, right) {

+	        var logical = (operator === '||' || operator === '&&');

+	        this.type = logical ? syntax_1.Syntax.LogicalExpression : syntax_1.Syntax.BinaryExpression;

+	        this.operator = operator;

+	        this.left = left;

+	        this.right = right;

+	    }

+	    return BinaryExpression;

+	}());

+	exports.BinaryExpression = BinaryExpression;

+	var BlockStatement = (function () {

+	    function BlockStatement(body) {

+	        this.type = syntax_1.Syntax.BlockStatement;

+	        this.body = body;

+	    }

+	    return BlockStatement;

+	}());

+	exports.BlockStatement = BlockStatement;

+	var BreakStatement = (function () {

+	    function BreakStatement(label) {

+	        this.type = syntax_1.Syntax.BreakStatement;

+	        this.label = label;

+	    }

+	    return BreakStatement;

+	}());

+	exports.BreakStatement = BreakStatement;

+	var CallExpression = (function () {

+	    function CallExpression(callee, args) {

+	        this.type = syntax_1.Syntax.CallExpression;

+	        this.callee = callee;

+	        this.arguments = args;

+	    }

+	    return CallExpression;

+	}());

+	exports.CallExpression = CallExpression;

+	var CatchClause = (function () {

+	    function CatchClause(param, body) {

+	        this.type = syntax_1.Syntax.CatchClause;

+	        this.param = param;

+	        this.body = body;

+	    }

+	    return CatchClause;

+	}());

+	exports.CatchClause = CatchClause;

+	var ClassBody = (function () {

+	    function ClassBody(body) {

+	        this.type = syntax_1.Syntax.ClassBody;

+	        this.body = body;

+	    }

+	    return ClassBody;

+	}());

+	exports.ClassBody = ClassBody;

+	var ClassDeclaration = (function () {

+	    function ClassDeclaration(id, superClass, body) {

+	        this.type = syntax_1.Syntax.ClassDeclaration;

+	        this.id = id;

+	        this.superClass = superClass;

+	        this.body = body;

+	    }

+	    return ClassDeclaration;

+	}());

+	exports.ClassDeclaration = ClassDeclaration;

+	var ClassExpression = (function () {

+	    function ClassExpression(id, superClass, body) {

+	        this.type = syntax_1.Syntax.ClassExpression;

+	        this.id = id;

+	        this.superClass = superClass;

+	        this.body = body;

+	    }

+	    return ClassExpression;

+	}());

+	exports.ClassExpression = ClassExpression;

+	var ComputedMemberExpression = (function () {

+	    function ComputedMemberExpression(object, property) {

+	        this.type = syntax_1.Syntax.MemberExpression;

+	        this.computed = true;

+	        this.object = object;

+	        this.property = property;

+	    }

+	    return ComputedMemberExpression;

+	}());

+	exports.ComputedMemberExpression = ComputedMemberExpression;

+	var ConditionalExpression = (function () {

+	    function ConditionalExpression(test, consequent, alternate) {

+	        this.type = syntax_1.Syntax.ConditionalExpression;

+	        this.test = test;

+	        this.consequent = consequent;

+	        this.alternate = alternate;

+	    }

+	    return ConditionalExpression;

+	}());

+	exports.ConditionalExpression = ConditionalExpression;

+	var ContinueStatement = (function () {

+	    function ContinueStatement(label) {

+	        this.type = syntax_1.Syntax.ContinueStatement;

+	        this.label = label;

+	    }

+	    return ContinueStatement;

+	}());

+	exports.ContinueStatement = ContinueStatement;

+	var DebuggerStatement = (function () {

+	    function DebuggerStatement() {

+	        this.type = syntax_1.Syntax.DebuggerStatement;

+	    }

+	    return DebuggerStatement;

+	}());

+	exports.DebuggerStatement = DebuggerStatement;

+	var Directive = (function () {

+	    function Directive(expression, directive) {

+	        this.type = syntax_1.Syntax.ExpressionStatement;

+	        this.expression = expression;

+	        this.directive = directive;

+	    }

+	    return Directive;

+	}());

+	exports.Directive = Directive;

+	var DoWhileStatement = (function () {

+	    function DoWhileStatement(body, test) {

+	        this.type = syntax_1.Syntax.DoWhileStatement;

+	        this.body = body;

+	        this.test = test;

+	    }

+	    return DoWhileStatement;

+	}());

+	exports.DoWhileStatement = DoWhileStatement;

+	var EmptyStatement = (function () {

+	    function EmptyStatement() {

+	        this.type = syntax_1.Syntax.EmptyStatement;

+	    }

+	    return EmptyStatement;

+	}());

+	exports.EmptyStatement = EmptyStatement;

+	var ExportAllDeclaration = (function () {

+	    function ExportAllDeclaration(source) {

+	        this.type = syntax_1.Syntax.ExportAllDeclaration;

+	        this.source = source;

+	    }

+	    return ExportAllDeclaration;

+	}());

+	exports.ExportAllDeclaration = ExportAllDeclaration;

+	var ExportDefaultDeclaration = (function () {

+	    function ExportDefaultDeclaration(declaration) {

+	        this.type = syntax_1.Syntax.ExportDefaultDeclaration;

+	        this.declaration = declaration;

+	    }

+	    return ExportDefaultDeclaration;

+	}());

+	exports.ExportDefaultDeclaration = ExportDefaultDeclaration;

+	var ExportNamedDeclaration = (function () {

+	    function ExportNamedDeclaration(declaration, specifiers, source) {

+	        this.type = syntax_1.Syntax.ExportNamedDeclaration;

+	        this.declaration = declaration;

+	        this.specifiers = specifiers;

+	        this.source = source;

+	    }

+	    return ExportNamedDeclaration;

+	}());

+	exports.ExportNamedDeclaration = ExportNamedDeclaration;

+	var ExportSpecifier = (function () {

+	    function ExportSpecifier(local, exported) {

+	        this.type = syntax_1.Syntax.ExportSpecifier;

+	        this.exported = exported;

+	        this.local = local;

+	    }

+	    return ExportSpecifier;

+	}());

+	exports.ExportSpecifier = ExportSpecifier;

+	var ExpressionStatement = (function () {

+	    function ExpressionStatement(expression) {

+	        this.type = syntax_1.Syntax.ExpressionStatement;

+	        this.expression = expression;

+	    }

+	    return ExpressionStatement;

+	}());

+	exports.ExpressionStatement = ExpressionStatement;

+	var ForInStatement = (function () {

+	    function ForInStatement(left, right, body) {

+	        this.type = syntax_1.Syntax.ForInStatement;

+	        this.left = left;

+	        this.right = right;

+	        this.body = body;

+	        this.each = false;

+	    }

+	    return ForInStatement;

+	}());

+	exports.ForInStatement = ForInStatement;

+	var ForOfStatement = (function () {

+	    function ForOfStatement(left, right, body) {

+	        this.type = syntax_1.Syntax.ForOfStatement;

+	        this.left = left;

+	        this.right = right;

+	        this.body = body;

+	    }

+	    return ForOfStatement;

+	}());

+	exports.ForOfStatement = ForOfStatement;

+	var ForStatement = (function () {

+	    function ForStatement(init, test, update, body) {

+	        this.type = syntax_1.Syntax.ForStatement;

+	        this.init = init;

+	        this.test = test;

+	        this.update = update;

+	        this.body = body;

+	    }

+	    return ForStatement;

+	}());

+	exports.ForStatement = ForStatement;

+	var FunctionDeclaration = (function () {

+	    function FunctionDeclaration(id, params, body, generator) {

+	        this.type = syntax_1.Syntax.FunctionDeclaration;

+	        this.id = id;

+	        this.params = params;

+	        this.body = body;

+	        this.generator = generator;

+	        this.expression = false;

+	        this.async = false;

+	    }

+	    return FunctionDeclaration;

+	}());

+	exports.FunctionDeclaration = FunctionDeclaration;

+	var FunctionExpression = (function () {

+	    function FunctionExpression(id, params, body, generator) {

+	        this.type = syntax_1.Syntax.FunctionExpression;

+	        this.id = id;

+	        this.params = params;

+	        this.body = body;

+	        this.generator = generator;

+	        this.expression = false;

+	        this.async = false;

+	    }

+	    return FunctionExpression;

+	}());

+	exports.FunctionExpression = FunctionExpression;

+	var Identifier = (function () {

+	    function Identifier(name) {

+	        this.type = syntax_1.Syntax.Identifier;

+	        this.name = name;

+	    }

+	    return Identifier;

+	}());

+	exports.Identifier = Identifier;

+	var IfStatement = (function () {

+	    function IfStatement(test, consequent, alternate) {

+	        this.type = syntax_1.Syntax.IfStatement;

+	        this.test = test;

+	        this.consequent = consequent;

+	        this.alternate = alternate;

+	    }

+	    return IfStatement;

+	}());

+	exports.IfStatement = IfStatement;

+	var ImportDeclaration = (function () {

+	    function ImportDeclaration(specifiers, source) {

+	        this.type = syntax_1.Syntax.ImportDeclaration;

+	        this.specifiers = specifiers;

+	        this.source = source;

+	    }

+	    return ImportDeclaration;

+	}());

+	exports.ImportDeclaration = ImportDeclaration;

+	var ImportDefaultSpecifier = (function () {

+	    function ImportDefaultSpecifier(local) {

+	        this.type = syntax_1.Syntax.ImportDefaultSpecifier;

+	        this.local = local;

+	    }

+	    return ImportDefaultSpecifier;

+	}());

+	exports.ImportDefaultSpecifier = ImportDefaultSpecifier;

+	var ImportNamespaceSpecifier = (function () {

+	    function ImportNamespaceSpecifier(local) {

+	        this.type = syntax_1.Syntax.ImportNamespaceSpecifier;

+	        this.local = local;

+	    }

+	    return ImportNamespaceSpecifier;

+	}());

+	exports.ImportNamespaceSpecifier = ImportNamespaceSpecifier;

+	var ImportSpecifier = (function () {

+	    function ImportSpecifier(local, imported) {

+	        this.type = syntax_1.Syntax.ImportSpecifier;

+	        this.local = local;

+	        this.imported = imported;

+	    }

+	    return ImportSpecifier;

+	}());

+	exports.ImportSpecifier = ImportSpecifier;

+	var LabeledStatement = (function () {

+	    function LabeledStatement(label, body) {

+	        this.type = syntax_1.Syntax.LabeledStatement;

+	        this.label = label;

+	        this.body = body;

+	    }

+	    return LabeledStatement;

+	}());

+	exports.LabeledStatement = LabeledStatement;

+	var Literal = (function () {

+	    function Literal(value, raw) {

+	        this.type = syntax_1.Syntax.Literal;

+	        this.value = value;

+	        this.raw = raw;

+	    }

+	    return Literal;

+	}());

+	exports.Literal = Literal;

+	var MetaProperty = (function () {

+	    function MetaProperty(meta, property) {

+	        this.type = syntax_1.Syntax.MetaProperty;

+	        this.meta = meta;

+	        this.property = property;

+	    }

+	    return MetaProperty;

+	}());

+	exports.MetaProperty = MetaProperty;

+	var MethodDefinition = (function () {

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

+	        this.type = syntax_1.Syntax.MethodDefinition;

+	        this.key = key;

+	        this.computed = computed;

+	        this.value = value;

+	        this.kind = kind;

+	        this.static = isStatic;

+	    }

+	    return MethodDefinition;

+	}());

+	exports.MethodDefinition = MethodDefinition;

+	var Module = (function () {

+	    function Module(body) {

+	        this.type = syntax_1.Syntax.Program;

+	        this.body = body;

+	        this.sourceType = 'module';

+	    }

+	    return Module;

+	}());

+	exports.Module = Module;

+	var NewExpression = (function () {

+	    function NewExpression(callee, args) {

+	        this.type = syntax_1.Syntax.NewExpression;

+	        this.callee = callee;

+	        this.arguments = args;

+	    }

+	    return NewExpression;

+	}());

+	exports.NewExpression = NewExpression;

+	var ObjectExpression = (function () {

+	    function ObjectExpression(properties) {

+	        this.type = syntax_1.Syntax.ObjectExpression;

+	        this.properties = properties;

+	    }

+	    return ObjectExpression;

+	}());

+	exports.ObjectExpression = ObjectExpression;

+	var ObjectPattern = (function () {

+	    function ObjectPattern(properties) {

+	        this.type = syntax_1.Syntax.ObjectPattern;

+	        this.properties = properties;

+	    }

+	    return ObjectPattern;

+	}());

+	exports.ObjectPattern = ObjectPattern;

+	var Property = (function () {

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

+	        this.type = syntax_1.Syntax.Property;

+	        this.key = key;

+	        this.computed = computed;

+	        this.value = value;

+	        this.kind = kind;

+	        this.method = method;

+	        this.shorthand = shorthand;

+	    }

+	    return Property;

+	}());

+	exports.Property = Property;

+	var RegexLiteral = (function () {

+	    function RegexLiteral(value, raw, pattern, flags) {

+	        this.type = syntax_1.Syntax.Literal;

+	        this.value = value;

+	        this.raw = raw;

+	        this.regex = { pattern: pattern, flags: flags };

+	    }

+	    return RegexLiteral;

+	}());

+	exports.RegexLiteral = RegexLiteral;

+	var RestElement = (function () {

+	    function RestElement(argument) {

+	        this.type = syntax_1.Syntax.RestElement;

+	        this.argument = argument;

+	    }

+	    return RestElement;

+	}());

+	exports.RestElement = RestElement;

+	var ReturnStatement = (function () {

+	    function ReturnStatement(argument) {

+	        this.type = syntax_1.Syntax.ReturnStatement;

+	        this.argument = argument;

+	    }

+	    return ReturnStatement;

+	}());

+	exports.ReturnStatement = ReturnStatement;

+	var Script = (function () {

+	    function Script(body) {

+	        this.type = syntax_1.Syntax.Program;

+	        this.body = body;

+	        this.sourceType = 'script';

+	    }

+	    return Script;

+	}());

+	exports.Script = Script;

+	var SequenceExpression = (function () {

+	    function SequenceExpression(expressions) {

+	        this.type = syntax_1.Syntax.SequenceExpression;

+	        this.expressions = expressions;

+	    }

+	    return SequenceExpression;

+	}());

+	exports.SequenceExpression = SequenceExpression;

+	var SpreadElement = (function () {

+	    function SpreadElement(argument) {

+	        this.type = syntax_1.Syntax.SpreadElement;

+	        this.argument = argument;

+	    }

+	    return SpreadElement;

+	}());

+	exports.SpreadElement = SpreadElement;

+	var StaticMemberExpression = (function () {

+	    function StaticMemberExpression(object, property) {

+	        this.type = syntax_1.Syntax.MemberExpression;

+	        this.computed = false;

+	        this.object = object;

+	        this.property = property;

+	    }

+	    return StaticMemberExpression;

+	}());

+	exports.StaticMemberExpression = StaticMemberExpression;

+	var Super = (function () {

+	    function Super() {

+	        this.type = syntax_1.Syntax.Super;

+	    }

+	    return Super;

+	}());

+	exports.Super = Super;

+	var SwitchCase = (function () {

+	    function SwitchCase(test, consequent) {

+	        this.type = syntax_1.Syntax.SwitchCase;

+	        this.test = test;

+	        this.consequent = consequent;

+	    }

+	    return SwitchCase;

+	}());

+	exports.SwitchCase = SwitchCase;

+	var SwitchStatement = (function () {

+	    function SwitchStatement(discriminant, cases) {

+	        this.type = syntax_1.Syntax.SwitchStatement;

+	        this.discriminant = discriminant;

+	        this.cases = cases;

+	    }

+	    return SwitchStatement;

+	}());

+	exports.SwitchStatement = SwitchStatement;

+	var TaggedTemplateExpression = (function () {

+	    function TaggedTemplateExpression(tag, quasi) {

+	        this.type = syntax_1.Syntax.TaggedTemplateExpression;

+	        this.tag = tag;

+	        this.quasi = quasi;

+	    }

+	    return TaggedTemplateExpression;

+	}());

+	exports.TaggedTemplateExpression = TaggedTemplateExpression;

+	var TemplateElement = (function () {

+	    function TemplateElement(value, tail) {

+	        this.type = syntax_1.Syntax.TemplateElement;

+	        this.value = value;

+	        this.tail = tail;

+	    }

+	    return TemplateElement;

+	}());

+	exports.TemplateElement = TemplateElement;

+	var TemplateLiteral = (function () {

+	    function TemplateLiteral(quasis, expressions) {

+	        this.type = syntax_1.Syntax.TemplateLiteral;

+	        this.quasis = quasis;

+	        this.expressions = expressions;

+	    }

+	    return TemplateLiteral;

+	}());

+	exports.TemplateLiteral = TemplateLiteral;

+	var ThisExpression = (function () {

+	    function ThisExpression() {

+	        this.type = syntax_1.Syntax.ThisExpression;

+	    }

+	    return ThisExpression;

+	}());

+	exports.ThisExpression = ThisExpression;

+	var ThrowStatement = (function () {

+	    function ThrowStatement(argument) {

+	        this.type = syntax_1.Syntax.ThrowStatement;

+	        this.argument = argument;

+	    }

+	    return ThrowStatement;

+	}());

+	exports.ThrowStatement = ThrowStatement;

+	var TryStatement = (function () {

+	    function TryStatement(block, handler, finalizer) {

+	        this.type = syntax_1.Syntax.TryStatement;

+	        this.block = block;

+	        this.handler = handler;

+	        this.finalizer = finalizer;

+	    }

+	    return TryStatement;

+	}());

+	exports.TryStatement = TryStatement;

+	var UnaryExpression = (function () {

+	    function UnaryExpression(operator, argument) {

+	        this.type = syntax_1.Syntax.UnaryExpression;

+	        this.operator = operator;

+	        this.argument = argument;

+	        this.prefix = true;

+	    }

+	    return UnaryExpression;

+	}());

+	exports.UnaryExpression = UnaryExpression;

+	var UpdateExpression = (function () {

+	    function UpdateExpression(operator, argument, prefix) {

+	        this.type = syntax_1.Syntax.UpdateExpression;

+	        this.operator = operator;

+	        this.argument = argument;

+	        this.prefix = prefix;

+	    }

+	    return UpdateExpression;

+	}());

+	exports.UpdateExpression = UpdateExpression;

+	var VariableDeclaration = (function () {

+	    function VariableDeclaration(declarations, kind) {

+	        this.type = syntax_1.Syntax.VariableDeclaration;

+	        this.declarations = declarations;

+	        this.kind = kind;

+	    }

+	    return VariableDeclaration;

+	}());

+	exports.VariableDeclaration = VariableDeclaration;

+	var VariableDeclarator = (function () {

+	    function VariableDeclarator(id, init) {

+	        this.type = syntax_1.Syntax.VariableDeclarator;

+	        this.id = id;

+	        this.init = init;

+	    }

+	    return VariableDeclarator;

+	}());

+	exports.VariableDeclarator = VariableDeclarator;

+	var WhileStatement = (function () {

+	    function WhileStatement(test, body) {

+	        this.type = syntax_1.Syntax.WhileStatement;

+	        this.test = test;

+	        this.body = body;

+	    }

+	    return WhileStatement;

+	}());

+	exports.WhileStatement = WhileStatement;

+	var WithStatement = (function () {

+	    function WithStatement(object, body) {

+	        this.type = syntax_1.Syntax.WithStatement;

+	        this.object = object;

+	        this.body = body;

+	    }

+	    return WithStatement;

+	}());

+	exports.WithStatement = WithStatement;

+	var YieldExpression = (function () {

+	    function YieldExpression(argument, delegate) {

+	        this.type = syntax_1.Syntax.YieldExpression;

+	        this.argument = argument;

+	        this.delegate = delegate;

+	    }

+	    return YieldExpression;

+	}());

+	exports.YieldExpression = YieldExpression;

+
+
+/***/ },
+/* 8 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";

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

+	var assert_1 = __webpack_require__(9);

+	var error_handler_1 = __webpack_require__(10);

+	var messages_1 = __webpack_require__(11);

+	var Node = __webpack_require__(7);

+	var scanner_1 = __webpack_require__(12);

+	var syntax_1 = __webpack_require__(2);

+	var token_1 = __webpack_require__(13);

+	var ArrowParameterPlaceHolder = 'ArrowParameterPlaceHolder';

+	var Parser = (function () {

+	    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,

+	            source: null,

+	            tokens: (typeof options.tokens === 'boolean') && options.tokens,

+	            comment: (typeof options.comment === 'boolean') && options.comment,

+	            tolerant: (typeof options.tolerant === 'boolean') && options.tolerant

+	        };

+	        if (this.config.loc && options.source && options.source !== null) {

+	            this.config.source = String(options.source);

+	        }

+	        this.delegate = delegate;

+	        this.errorHandler = new error_handler_1.ErrorHandler();

+	        this.errorHandler.tolerant = this.config.tolerant;

+	        this.scanner = new scanner_1.Scanner(code, this.errorHandler);

+	        this.scanner.trackComment = this.config.comment;

+	        this.operatorPrecedence = {

+	            ')': 0,

+	            ';': 0,

+	            ',': 0,

+	            '=': 0,

+	            ']': 0,

+	            '||': 1,

+	            '&&': 2,

+	            '|': 3,

+	            '^': 4,

+	            '&': 5,

+	            '==': 6,

+	            '!=': 6,

+	            '===': 6,

+	            '!==': 6,

+	            '<': 7,

+	            '>': 7,

+	            '<=': 7,

+	            '>=': 7,

+	            '<<': 8,

+	            '>>': 8,

+	            '>>>': 8,

+	            '+': 9,

+	            '-': 9,

+	            '*': 11,

+	            '/': 11,

+	            '%': 11

+	        };

+	        this.lookahead = {

+	            type: 2 /* EOF */,

+	            value: '',

+	            lineNumber: this.scanner.lineNumber,

+	            lineStart: 0,

+	            start: 0,

+	            end: 0

+	        };

+	        this.hasLineTerminator = false;

+	        this.context = {

+	            isModule: false,

+	            await: false,

+	            allowIn: true,

+	            allowStrictDirective: true,

+	            allowYield: true,

+	            firstCoverInitializedNameError: null,

+	            isAssignmentTarget: false,

+	            isBindingElement: false,

+	            inFunctionBody: false,

+	            inIteration: false,

+	            inSwitch: false,

+	            labelSet: {},

+	            strict: false

+	        };

+	        this.tokens = [];

+	        this.startMarker = {

+	            index: 0,

+	            line: this.scanner.lineNumber,

+	            column: 0

+	        };

+	        this.lastMarker = {

+	            index: 0,

+	            line: this.scanner.lineNumber,

+	            column: 0

+	        };

+	        this.nextToken();

+	        this.lastMarker = {

+	            index: this.scanner.index,

+	            line: this.scanner.lineNumber,

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

+	        };

+	    }

+	    Parser.prototype.throwError = function (messageFormat) {

+	        var values = [];

+	        for (var _i = 1; _i < arguments.length; _i++) {

+	            values[_i - 1] = arguments[_i];

+	        }

+	        var args = Array.prototype.slice.call(arguments, 1);

+	        var msg = messageFormat.replace(/%(\d)/g, function (whole, idx) {

+	            assert_1.assert(idx < args.length, 'Message reference must be in range');

+	            return args[idx];

+	        });

+	        var index = this.lastMarker.index;

+	        var line = this.lastMarker.line;

+	        var column = this.lastMarker.column + 1;

+	        throw this.errorHandler.createError(index, line, column, msg);

+	    };

+	    Parser.prototype.tolerateError = function (messageFormat) {

+	        var values = [];

+	        for (var _i = 1; _i < arguments.length; _i++) {

+	            values[_i - 1] = arguments[_i];

+	        }

+	        var args = Array.prototype.slice.call(arguments, 1);

+	        var msg = messageFormat.replace(/%(\d)/g, function (whole, idx) {

+	            assert_1.assert(idx < args.length, 'Message reference must be in range');

+	            return args[idx];

+	        });

+	        var index = this.lastMarker.index;

+	        var line = this.scanner.lineNumber;

+	        var column = this.lastMarker.column + 1;

+	        this.errorHandler.tolerateError(index, line, column, msg);

+	    };

+	    // Throw an exception because of the token.

+	    Parser.prototype.unexpectedTokenError = function (token, message) {

+	        var msg = message || messages_1.Messages.UnexpectedToken;

+	        var value;

+	        if (token) {

+	            if (!message) {

+	                msg = (token.type === 2 /* EOF */) ? messages_1.Messages.UnexpectedEOS :

+	                    (token.type === 3 /* Identifier */) ? messages_1.Messages.UnexpectedIdentifier :

+	                        (token.type === 6 /* NumericLiteral */) ? messages_1.Messages.UnexpectedNumber :

+	                            (token.type === 8 /* StringLiteral */) ? messages_1.Messages.UnexpectedString :

+	                                (token.type === 10 /* Template */) ? messages_1.Messages.UnexpectedTemplate :

+	                                    messages_1.Messages.UnexpectedToken;

+	                if (token.type === 4 /* Keyword */) {

+	                    if (this.scanner.isFutureReservedWord(token.value)) {

+	                        msg = messages_1.Messages.UnexpectedReserved;

+	                    }

+	                    else if (this.context.strict && this.scanner.isStrictModeReservedWord(token.value)) {

+	                        msg = messages_1.Messages.StrictReservedWord;

+	                    }

+	                }

+	            }

+	            value = token.value;

+	        }

+	        else {

+	            value = 'ILLEGAL';

+	        }

+	        msg = msg.replace('%0', value);

+	        if (token && typeof token.lineNumber === 'number') {

+	            var index = token.start;

+	            var line = token.lineNumber;

+	            var lastMarkerLineStart = this.lastMarker.index - this.lastMarker.column;

+	            var column = token.start - lastMarkerLineStart + 1;

+	            return this.errorHandler.createError(index, line, column, msg);

+	        }

+	        else {

+	            var index = this.lastMarker.index;

+	            var line = this.lastMarker.line;

+	            var column = this.lastMarker.column + 1;

+	            return this.errorHandler.createError(index, line, column, msg);

+	        }

+	    };

+	    Parser.prototype.throwUnexpectedToken = function (token, message) {

+	        throw this.unexpectedTokenError(token, message);

+	    };

+	    Parser.prototype.tolerateUnexpectedToken = function (token, message) {

+	        this.errorHandler.tolerate(this.unexpectedTokenError(token, message));

+	    };

+	    Parser.prototype.collectComments = function () {

+	        if (!this.config.comment) {

+	            this.scanner.scanComments();

+	        }

+	        else {

+	            var comments = this.scanner.scanComments();

+	            if (comments.length > 0 && this.delegate) {

+	                for (var i = 0; i < comments.length; ++i) {

+	                    var e = comments[i];

+	                    var node = void 0;

+	                    node = {

+	                        type: e.multiLine ? 'BlockComment' : 'LineComment',

+	                        value: this.scanner.source.slice(e.slice[0], e.slice[1])

+	                    };

+	                    if (this.config.range) {

+	                        node.range = e.range;

+	                    }

+	                    if (this.config.loc) {

+	                        node.loc = e.loc;

+	                    }

+	                    var metadata = {

+	                        start: {

+	                            line: e.loc.start.line,

+	                            column: e.loc.start.column,

+	                            offset: e.range[0]

+	                        },

+	                        end: {

+	                            line: e.loc.end.line,

+	                            column: e.loc.end.column,

+	                            offset: e.range[1]

+	                        }

+	                    };

+	                    this.delegate(node, metadata);

+	                }

+	            }

+	        }

+	    };

+	    // From internal representation to an external structure

+	    Parser.prototype.getTokenRaw = function (token) {

+	        return this.scanner.source.slice(token.start, token.end);

+	    };

+	    Parser.prototype.convertToken = function (token) {

+	        var t = {

+	            type: token_1.TokenName[token.type],

+	            value: this.getTokenRaw(token)

+	        };

+	        if (this.config.range) {

+	            t.range = [token.start, token.end];

+	        }

+	        if (this.config.loc) {

+	            t.loc = {

+	                start: {

+	                    line: this.startMarker.line,

+	                    column: this.startMarker.column

+	                },

+	                end: {

+	                    line: this.scanner.lineNumber,

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

+	                }

+	            };

+	        }

+	        if (token.type === 9 /* RegularExpression */) {

+	            var pattern = token.pattern;

+	            var flags = token.flags;

+	            t.regex = { pattern: pattern, flags: flags };

+	        }

+	        return t;

+	    };

+	    Parser.prototype.nextToken = function () {

+	        var token = this.lookahead;

+	        this.lastMarker.index = this.scanner.index;

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

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

+	        this.collectComments();

+	        if (this.scanner.index !== this.startMarker.index) {

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

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

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

+	        }

+	        var next = this.scanner.lex();

+	        this.hasLineTerminator = (token.lineNumber !== next.lineNumber);

+	        if (next && this.context.strict && next.type === 3 /* Identifier */) {

+	            if (this.scanner.isStrictModeReservedWord(next.value)) {

+	                next.type = 4 /* Keyword */;

+	            }

+	        }

+	        this.lookahead = next;

+	        if (this.config.tokens && next.type !== 2 /* EOF */) {

+	            this.tokens.push(this.convertToken(next));

+	        }

+	        return token;

+	    };

+	    Parser.prototype.nextRegexToken = function () {

+	        this.collectComments();

+	        var token = this.scanner.scanRegExp();

+	        if (this.config.tokens) {

+	            // Pop the previous token, '/' or '/='

+	            // This is added from the lookahead token.

+	            this.tokens.pop();

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

+	        }

+	        // Prime the next lookahead.

+	        this.lookahead = token;

+	        this.nextToken();

+	        return token;

+	    };

+	    Parser.prototype.createNode = function () {

+	        return {

+	            index: this.startMarker.index,

+	            line: this.startMarker.line,

+	            column: this.startMarker.column

+	        };

+	    };

+	    Parser.prototype.startNode = function (token) {

+	        return {

+	            index: token.start,

+	            line: token.lineNumber,

+	            column: token.start - token.lineStart

+	        };

+	    };

+	    Parser.prototype.finalize = function (marker, node) {

+	        if (this.config.range) {

+	            node.range = [marker.index, this.lastMarker.index];

+	        }

+	        if (this.config.loc) {

+	            node.loc = {

+	                start: {

+	                    line: marker.line,

+	                    column: marker.column,

+	                },

+	                end: {

+	                    line: this.lastMarker.line,

+	                    column: this.lastMarker.column

+	                }

+	            };

+	            if (this.config.source) {

+	                node.loc.source = this.config.source;

+	            }

+	        }

+	        if (this.delegate) {

+	            var metadata = {

+	                start: {

+	                    line: marker.line,

+	                    column: marker.column,

+	                    offset: marker.index

+	                },

+	                end: {

+	                    line: this.lastMarker.line,

+	                    column: this.lastMarker.column,

+	                    offset: this.lastMarker.index

+	                }

+	            };

+	            this.delegate(node, metadata);

+	        }

+	        return node;

+	    };

+	    // Expect the next token to match the specified punctuator.

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

+	    Parser.prototype.expect = function (value) {

+	        var token = this.nextToken();

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

+	            this.throwUnexpectedToken(token);

+	        }

+	    };

+	    // Quietly expect a comma when in tolerant mode, otherwise delegates to expect().

+	    Parser.prototype.expectCommaSeparator = function () {

+	        if (this.config.tolerant) {

+	            var token = this.lookahead;

+	            if (token.type === 7 /* Punctuator */ && token.value === ',') {

+	                this.nextToken();

+	            }

+	            else if (token.type === 7 /* Punctuator */ && token.value === ';') {

+	                this.nextToken();

+	                this.tolerateUnexpectedToken(token);

+	            }

+	            else {

+	                this.tolerateUnexpectedToken(token, messages_1.Messages.UnexpectedToken);

+	            }

+	        }

+	        else {

+	            this.expect(',');

+	        }

+	    };

+	    // Expect the next token to match the specified keyword.

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

+	    Parser.prototype.expectKeyword = function (keyword) {

+	        var token = this.nextToken();

+	        if (token.type !== 4 /* Keyword */ || token.value !== keyword) {

+	            this.throwUnexpectedToken(token);

+	        }

+	    };

+	    // Return true if the next token matches the specified punctuator.

+	    Parser.prototype.match = function (value) {

+	        return this.lookahead.type === 7 /* Punctuator */ && this.lookahead.value === value;

+	    };

+	    // Return true if the next token matches the specified keyword

+	    Parser.prototype.matchKeyword = function (keyword) {

+	        return this.lookahead.type === 4 /* Keyword */ && this.lookahead.value === keyword;

+	    };

+	    // Return true if the next token matches the specified contextual keyword

+	    // (where an identifier is sometimes a keyword depending on the context)

+	    Parser.prototype.matchContextualKeyword = function (keyword) {

+	        return this.lookahead.type === 3 /* Identifier */ && this.lookahead.value === keyword;

+	    };

+	    // Return true if the next token is an assignment operator

+	    Parser.prototype.matchAssign = function () {

+	        if (this.lookahead.type !== 7 /* Punctuator */) {

+	            return false;

+	        }

+	        var op = this.lookahead.value;

+	        return op === '=' ||

+	            op === '*=' ||

+	            op === '**=' ||

+	            op === '/=' ||

+	            op === '%=' ||

+	            op === '+=' ||

+	            op === '-=' ||

+	            op === '<<=' ||

+	            op === '>>=' ||

+	            op === '>>>=' ||

+	            op === '&=' ||

+	            op === '^=' ||

+	            op === '|=';

+	    };

+	    // Cover grammar support.

+	    //

+	    // When an assignment expression position starts with an left parenthesis, the determination of the type

+	    // of the syntax is to be deferred arbitrarily long until the end of the parentheses pair (plus a lookahead)

+	    // or the first comma. This situation also defers the determination of all the expressions nested in the pair.

+	    //

+	    // There are three productions that can be parsed in a parentheses pair that needs to be determined

+	    // after the outermost pair is closed. They are:

+	    //

+	    //   1. AssignmentExpression

+	    //   2. BindingElements

+	    //   3. AssignmentTargets

+	    //

+	    // In order to avoid exponential backtracking, we use two flags to denote if the production can be

+	    // binding element or assignment target.

+	    //

+	    // The three productions have the relationship:

+	    //

+	    //   BindingElements ⊆ AssignmentTargets ⊆ AssignmentExpression

+	    //

+	    // with a single exception that CoverInitializedName when used directly in an Expression, generates

+	    // an early error. Therefore, we need the third state, firstCoverInitializedNameError, to track the

+	    // first usage of CoverInitializedName and report it when we reached the end of the parentheses pair.

+	    //

+	    // isolateCoverGrammar function runs the given parser function with a new cover grammar context, and it does not

+	    // effect the current flags. This means the production the parser parses is only used as an expression. Therefore

+	    // the CoverInitializedName check is conducted.

+	    //

+	    // inheritCoverGrammar function runs the given parse function with a new cover grammar context, and it propagates

+	    // the flags outside of the parser. This means the production the parser parses is used as a part of a potential

+	    // pattern. The CoverInitializedName check is deferred.

+	    Parser.prototype.isolateCoverGrammar = function (parseFunction) {

+	        var previousIsBindingElement = this.context.isBindingElement;

+	        var previousIsAssignmentTarget = this.context.isAssignmentTarget;

+	        var previousFirstCoverInitializedNameError = this.context.firstCoverInitializedNameError;

+	        this.context.isBindingElement = true;

+	        this.context.isAssignmentTarget = true;

+	        this.context.firstCoverInitializedNameError = null;

+	        var result = parseFunction.call(this);

+	        if (this.context.firstCoverInitializedNameError !== null) {

+	            this.throwUnexpectedToken(this.context.firstCoverInitializedNameError);

+	        }

+	        this.context.isBindingElement = previousIsBindingElement;

+	        this.context.isAssignmentTarget = previousIsAssignmentTarget;

+	        this.context.firstCoverInitializedNameError = previousFirstCoverInitializedNameError;

+	        return result;

+	    };

+	    Parser.prototype.inheritCoverGrammar = function (parseFunction) {

+	        var previousIsBindingElement = this.context.isBindingElement;

+	        var previousIsAssignmentTarget = this.context.isAssignmentTarget;

+	        var previousFirstCoverInitializedNameError = this.context.firstCoverInitializedNameError;

+	        this.context.isBindingElement = true;

+	        this.context.isAssignmentTarget = true;

+	        this.context.firstCoverInitializedNameError = null;

+	        var result = parseFunction.call(this);

+	        this.context.isBindingElement = this.context.isBindingElement && previousIsBindingElement;

+	        this.context.isAssignmentTarget = this.context.isAssignmentTarget && previousIsAssignmentTarget;

+	        this.context.firstCoverInitializedNameError = previousFirstCoverInitializedNameError || this.context.firstCoverInitializedNameError;

+	        return result;

+	    };

+	    Parser.prototype.consumeSemicolon = function () {

+	        if (this.match(';')) {

+	            this.nextToken();

+	        }

+	        else if (!this.hasLineTerminator) {

+	            if (this.lookahead.type !== 2 /* EOF */ && !this.match('}')) {

+	                this.throwUnexpectedToken(this.lookahead);

+	            }

+	            this.lastMarker.index = this.startMarker.index;

+	            this.lastMarker.line = this.startMarker.line;

+	            this.lastMarker.column = this.startMarker.column;

+	        }

+	    };

+	    // https://tc39.github.io/ecma262/#sec-primary-expression

+	    Parser.prototype.parsePrimaryExpression = function () {

+	        var node = this.createNode();

+	        var expr;

+	        var token, raw;

+	        switch (this.lookahead.type) {

+	            case 3 /* Identifier */:

+	                if ((this.context.isModule || this.context.await) && this.lookahead.value === 'await') {

+	                    this.tolerateUnexpectedToken(this.lookahead);

+	                }

+	                expr = this.matchAsyncFunction() ? this.parseFunctionExpression() : this.finalize(node, new Node.Identifier(this.nextToken().value));

+	                break;

+	            case 6 /* NumericLiteral */:

+	            case 8 /* StringLiteral */:

+	                if (this.context.strict && this.lookahead.octal) {

+	                    this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.StrictOctalLiteral);

+	                }

+	                this.context.isAssignmentTarget = false;

+	                this.context.isBindingElement = false;

+	                token = this.nextToken();

+	                raw = this.getTokenRaw(token);

+	                expr = this.finalize(node, new Node.Literal(token.value, raw));

+	                break;

+	            case 1 /* BooleanLiteral */:

+	                this.context.isAssignmentTarget = false;

+	                this.context.isBindingElement = false;

+	                token = this.nextToken();

+	                raw = this.getTokenRaw(token);

+	                expr = this.finalize(node, new Node.Literal(token.value === 'true', raw));

+	                break;

+	            case 5 /* NullLiteral */:

+	                this.context.isAssignmentTarget = false;

+	                this.context.isBindingElement = false;

+	                token = this.nextToken();

+	                raw = this.getTokenRaw(token);

+	                expr = this.finalize(node, new Node.Literal(null, raw));

+	                break;

+	            case 10 /* Template */:

+	                expr = this.parseTemplateLiteral();

+	                break;

+	            case 7 /* Punctuator */:

+	                switch (this.lookahead.value) {

+	                    case '(':

+	                        this.context.isBindingElement = false;

+	                        expr = this.inheritCoverGrammar(this.parseGroupExpression);

+	                        break;

+	                    case '[':

+	                        expr = this.inheritCoverGrammar(this.parseArrayInitializer);

+	                        break;

+	                    case '{':

+	                        expr = this.inheritCoverGrammar(this.parseObjectInitializer);

+	                        break;

+	                    case '/':

+	                    case '/=':

+	                        this.context.isAssignmentTarget = false;

+	                        this.context.isBindingElement = false;

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

+	                        token = this.nextRegexToken();

+	                        raw = this.getTokenRaw(token);

+	                        expr = this.finalize(node, new Node.RegexLiteral(token.regex, raw, token.pattern, token.flags));

+	                        break;

+	                    default:

+	                        expr = this.throwUnexpectedToken(this.nextToken());

+	                }

+	                break;

+	            case 4 /* Keyword */:

+	                if (!this.context.strict && this.context.allowYield && this.matchKeyword('yield')) {

+	                    expr = this.parseIdentifierName();

+	                }

+	                else if (!this.context.strict && this.matchKeyword('let')) {

+	                    expr = this.finalize(node, new Node.Identifier(this.nextToken().value));

+	                }

+	                else {

+	                    this.context.isAssignmentTarget = false;

+	                    this.context.isBindingElement = false;

+	                    if (this.matchKeyword('function')) {

+	                        expr = this.parseFunctionExpression();

+	                    }

+	                    else if (this.matchKeyword('this')) {

+	                        this.nextToken();

+	                        expr = this.finalize(node, new Node.ThisExpression());

+	                    }

+	                    else if (this.matchKeyword('class')) {

+	                        expr = this.parseClassExpression();

+	                    }

+	                    else {

+	                        expr = this.throwUnexpectedToken(this.nextToken());

+	                    }

+	                }

+	                break;

+	            default:

+	                expr = this.throwUnexpectedToken(this.nextToken());

+	        }

+	        return expr;

+	    };

+	    // https://tc39.github.io/ecma262/#sec-array-initializer

+	    Parser.prototype.parseSpreadElement = function () {

+	        var node = this.createNode();

+	        this.expect('...');

+	        var arg = this.inheritCoverGrammar(this.parseAssignmentExpression);

+	        return this.finalize(node, new Node.SpreadElement(arg));

+	    };

+	    Parser.prototype.parseArrayInitializer = function () {

+	        var node = this.createNode();

+	        var elements = [];

+	        this.expect('[');

+	        while (!this.match(']')) {

+	            if (this.match(',')) {

+	                this.nextToken();

+	                elements.push(null);

+	            }

+	            else if (this.match('...')) {

+	                var element = this.parseSpreadElement();

+	                if (!this.match(']')) {

+	                    this.context.isAssignmentTarget = false;

+	                    this.context.isBindingElement = false;

+	                    this.expect(',');

+	                }

+	                elements.push(element);

+	            }

+	            else {

+	                elements.push(this.inheritCoverGrammar(this.parseAssignmentExpression));

+	                if (!this.match(']')) {

+	                    this.expect(',');

+	                }

+	            }

+	        }

+	        this.expect(']');

+	        return this.finalize(node, new Node.ArrayExpression(elements));

+	    };

+	    // https://tc39.github.io/ecma262/#sec-object-initializer

+	    Parser.prototype.parsePropertyMethod = function (params) {

+	        this.context.isAssignmentTarget = false;

+	        this.context.isBindingElement = false;

+	        var previousStrict = this.context.strict;

+	        var previousAllowStrictDirective = this.context.allowStrictDirective;

+	        this.context.allowStrictDirective = params.simple;

+	        var body = this.isolateCoverGrammar(this.parseFunctionSourceElements);

+	        if (this.context.strict && params.firstRestricted) {

+	            this.tolerateUnexpectedToken(params.firstRestricted, params.message);

+	        }

+	        if (this.context.strict && params.stricted) {

+	            this.tolerateUnexpectedToken(params.stricted, params.message);

+	        }

+	        this.context.strict = previousStrict;

+	        this.context.allowStrictDirective = previousAllowStrictDirective;

+	        return body;

+	    };

+	    Parser.prototype.parsePropertyMethodFunction = function () {

+	        var isGenerator = false;

+	        var node = this.createNode();

+	        var previousAllowYield = this.context.allowYield;

+	        this.context.allowYield = false;

+	        var params = this.parseFormalParameters();

+	        var method = this.parsePropertyMethod(params);

+	        this.context.allowYield = previousAllowYield;

+	        return this.finalize(node, new Node.FunctionExpression(null, params.params, method, isGenerator));

+	    };

+	    Parser.prototype.parsePropertyMethodAsyncFunction = function () {

+	        var node = this.createNode();

+	        var previousAllowYield = this.context.allowYield;

+	        var previousAwait = this.context.await;

+	        this.context.allowYield = false;

+	        this.context.await = true;

+	        var params = this.parseFormalParameters();

+	        var method = this.parsePropertyMethod(params);

+	        this.context.allowYield = previousAllowYield;

+	        this.context.await = previousAwait;

+	        return this.finalize(node, new Node.AsyncFunctionExpression(null, params.params, method));

+	    };

+	    Parser.prototype.parseObjectPropertyKey = function () {

+	        var node = this.createNode();

+	        var token = this.nextToken();

+	        var key;

+	        switch (token.type) {

+	            case 8 /* StringLiteral */:

+	            case 6 /* NumericLiteral */:

+	                if (this.context.strict && token.octal) {

+	                    this.tolerateUnexpectedToken(token, messages_1.Messages.StrictOctalLiteral);

+	                }

+	                var raw = this.getTokenRaw(token);

+	                key = this.finalize(node, new Node.Literal(token.value, raw));

+	                break;

+	            case 3 /* Identifier */:

+	            case 1 /* BooleanLiteral */:

+	            case 5 /* NullLiteral */:

+	            case 4 /* Keyword */:

+	                key = this.finalize(node, new Node.Identifier(token.value));

+	                break;

+	            case 7 /* Punctuator */:

+	                if (token.value === '[') {

+	                    key = this.isolateCoverGrammar(this.parseAssignmentExpression);

+	                    this.expect(']');

+	                }

+	                else {

+	                    key = this.throwUnexpectedToken(token);

+	                }

+	                break;

+	            default:

+	                key = this.throwUnexpectedToken(token);

+	        }

+	        return key;

+	    };

+	    Parser.prototype.isPropertyKey = function (key, value) {

+	        return (key.type === syntax_1.Syntax.Identifier && key.name === value) ||

+	            (key.type === syntax_1.Syntax.Literal && key.value === value);

+	    };

+	    Parser.prototype.parseObjectProperty = function (hasProto) {

+	        var node = this.createNode();

+	        var token = this.lookahead;

+	        var kind;

+	        var key = null;

+	        var value = null;

+	        var computed = false;

+	        var method = false;

+	        var shorthand = false;

+	        var isAsync = false;

+	        if (token.type === 3 /* Identifier */) {

+	            var id = token.value;

+	            this.nextToken();

+	            computed = this.match('[');

+	            isAsync = !this.hasLineTerminator && (id === 'async') &&

+	                !this.match(':') && !this.match('(') && !this.match('*');

+	            key = isAsync ? this.parseObjectPropertyKey() : this.finalize(node, new Node.Identifier(id));

+	        }

+	        else if (this.match('*')) {

+	            this.nextToken();

+	        }

+	        else {

+	            computed = this.match('[');

+	            key = this.parseObjectPropertyKey();

+	        }

+	        var lookaheadPropertyKey = this.qualifiedPropertyName(this.lookahead);

+	        if (token.type === 3 /* Identifier */ && !isAsync && token.value === 'get' && lookaheadPropertyKey) {

+	            kind = 'get';

+	            computed = this.match('[');

+	            key = this.parseObjectPropertyKey();

+	            this.context.allowYield = false;

+	            value = this.parseGetterMethod();

+	        }

+	        else if (token.type === 3 /* Identifier */ && !isAsync && token.value === 'set' && lookaheadPropertyKey) {

+	            kind = 'set';

+	            computed = this.match('[');

+	            key = this.parseObjectPropertyKey();

+	            value = this.parseSetterMethod();

+	        }

+	        else if (token.type === 7 /* Punctuator */ && token.value === '*' && lookaheadPropertyKey) {

+	            kind = 'init';

+	            computed = this.match('[');

+	            key = this.parseObjectPropertyKey();

+	            value = this.parseGeneratorMethod();

+	            method = true;

+	        }

+	        else {

+	            if (!key) {

+	                this.throwUnexpectedToken(this.lookahead);

+	            }

+	            kind = 'init';

+	            if (this.match(':') && !isAsync) {

+	                if (!computed && this.isPropertyKey(key, '__proto__')) {

+	                    if (hasProto.value) {

+	                        this.tolerateError(messages_1.Messages.DuplicateProtoProperty);

+	                    }

+	                    hasProto.value = true;

+	                }

+	                this.nextToken();

+	                value = this.inheritCoverGrammar(this.parseAssignmentExpression);

+	            }

+	            else if (this.match('(')) {

+	                value = isAsync ? this.parsePropertyMethodAsyncFunction() : this.parsePropertyMethodFunction();

+	                method = true;

+	            }

+	            else if (token.type === 3 /* Identifier */) {

+	                var id = this.finalize(node, new Node.Identifier(token.value));

+	                if (this.match('=')) {

+	                    this.context.firstCoverInitializedNameError = this.lookahead;

+	                    this.nextToken();

+	                    shorthand = true;

+	                    var init = this.isolateCoverGrammar(this.parseAssignmentExpression);

+	                    value = this.finalize(node, new Node.AssignmentPattern(id, init));

+	                }

+	                else {

+	                    shorthand = true;

+	                    value = id;

+	                }

+	            }

+	            else {

+	                this.throwUnexpectedToken(this.nextToken());

+	            }

+	        }

+	        return this.finalize(node, new Node.Property(kind, key, computed, value, method, shorthand));

+	    };

+	    Parser.prototype.parseObjectInitializer = function () {

+	        var node = this.createNode();

+	        this.expect('{');

+	        var properties = [];

+	        var hasProto = { value: false };

+	        while (!this.match('}')) {

+	            properties.push(this.parseObjectProperty(hasProto));

+	            if (!this.match('}')) {

+	                this.expectCommaSeparator();

+	            }

+	        }

+	        this.expect('}');

+	        return this.finalize(node, new Node.ObjectExpression(properties));

+	    };

+	    // https://tc39.github.io/ecma262/#sec-template-literals

+	    Parser.prototype.parseTemplateHead = function () {

+	        assert_1.assert(this.lookahead.head, 'Template literal must start with a template head');

+	        var node = this.createNode();

+	        var token = this.nextToken();

+	        var raw = token.value;

+	        var cooked = token.cooked;

+	        return this.finalize(node, new Node.TemplateElement({ raw: raw, cooked: cooked }, token.tail));

+	    };

+	    Parser.prototype.parseTemplateElement = function () {

+	        if (this.lookahead.type !== 10 /* Template */) {

+	            this.throwUnexpectedToken();

+	        }

+	        var node = this.createNode();

+	        var token = this.nextToken();

+	        var raw = token.value;

+	        var cooked = token.cooked;

+	        return this.finalize(node, new Node.TemplateElement({ raw: raw, cooked: cooked }, token.tail));

+	    };

+	    Parser.prototype.parseTemplateLiteral = function () {

+	        var node = this.createNode();

+	        var expressions = [];

+	        var quasis = [];

+	        var quasi = this.parseTemplateHead();

+	        quasis.push(quasi);

+	        while (!quasi.tail) {

+	            expressions.push(this.parseExpression());

+	            quasi = this.parseTemplateElement();

+	            quasis.push(quasi);

+	        }

+	        return this.finalize(node, new Node.TemplateLiteral(quasis, expressions));

+	    };

+	    // https://tc39.github.io/ecma262/#sec-grouping-operator

+	    Parser.prototype.reinterpretExpressionAsPattern = function (expr) {

+	        switch (expr.type) {

+	            case syntax_1.Syntax.Identifier:

+	            case syntax_1.Syntax.MemberExpression:

+	            case syntax_1.Syntax.RestElement:

+	            case syntax_1.Syntax.AssignmentPattern:

+	                break;

+	            case syntax_1.Syntax.SpreadElement:

+	                expr.type = syntax_1.Syntax.RestElement;

+	                this.reinterpretExpressionAsPattern(expr.argument);

+	                break;

+	            case syntax_1.Syntax.ArrayExpression:

+	                expr.type = syntax_1.Syntax.ArrayPattern;

+	                for (var i = 0; i < expr.elements.length; i++) {

+	                    if (expr.elements[i] !== null) {

+	                        this.reinterpretExpressionAsPattern(expr.elements[i]);

+	                    }

+	                }

+	                break;

+	            case syntax_1.Syntax.ObjectExpression:

+	                expr.type = syntax_1.Syntax.ObjectPattern;

+	                for (var i = 0; i < expr.properties.length; i++) {

+	                    this.reinterpretExpressionAsPattern(expr.properties[i].value);

+	                }

+	                break;

+	            case syntax_1.Syntax.AssignmentExpression:

+	                expr.type = syntax_1.Syntax.AssignmentPattern;

+	                delete expr.operator;

+	                this.reinterpretExpressionAsPattern(expr.left);

+	                break;

+	            default:

+	                // Allow other node type for tolerant parsing.

+	                break;

+	        }

+	    };

+	    Parser.prototype.parseGroupExpression = function () {

+	        var expr;

+	        this.expect('(');

+	        if (this.match(')')) {

+	            this.nextToken();

+	            if (!this.match('=>')) {

+	                this.expect('=>');

+	            }

+	            expr = {

+	                type: ArrowParameterPlaceHolder,

+	                params: [],

+	                async: false

+	            };

+	        }

+	        else {

+	            var startToken = this.lookahead;

+	            var params = [];

+	            if (this.match('...')) {

+	                expr = this.parseRestElement(params);

+	                this.expect(')');

+	                if (!this.match('=>')) {

+	                    this.expect('=>');

+	                }

+	                expr = {

+	                    type: ArrowParameterPlaceHolder,

+	                    params: [expr],

+	                    async: false

+	                };

+	            }

+	            else {

+	                var arrow = false;

+	                this.context.isBindingElement = true;

+	                expr = this.inheritCoverGrammar(this.parseAssignmentExpression);

+	                if (this.match(',')) {

+	                    var expressions = [];

+	                    this.context.isAssignmentTarget = false;

+	                    expressions.push(expr);

+	                    while (this.lookahead.type !== 2 /* EOF */) {

+	                        if (!this.match(',')) {

+	                            break;

+	                        }

+	                        this.nextToken();

+	                        if (this.match(')')) {

+	                            this.nextToken();

+	                            for (var i = 0; i < expressions.length; i++) {

+	                                this.reinterpretExpressionAsPattern(expressions[i]);

+	                            }

+	                            arrow = true;

+	                            expr = {

+	                                type: ArrowParameterPlaceHolder,

+	                                params: expressions,

+	                                async: false

+	                            };

+	                        }

+	                        else if (this.match('...')) {

+	                            if (!this.context.isBindingElement) {

+	                                this.throwUnexpectedToken(this.lookahead);

+	                            }

+	                            expressions.push(this.parseRestElement(params));

+	                            this.expect(')');

+	                            if (!this.match('=>')) {

+	                                this.expect('=>');

+	                            }

+	                            this.context.isBindingElement = false;

+	                            for (var i = 0; i < expressions.length; i++) {

+	                                this.reinterpretExpressionAsPattern(expressions[i]);

+	                            }

+	                            arrow = true;

+	                            expr = {

+	                                type: ArrowParameterPlaceHolder,

+	                                params: expressions,

+	                                async: false

+	                            };

+	                        }

+	                        else {

+	                            expressions.push(this.inheritCoverGrammar(this.parseAssignmentExpression));

+	                        }

+	                        if (arrow) {

+	                            break;

+	                        }

+	                    }

+	                    if (!arrow) {

+	                        expr = this.finalize(this.startNode(startToken), new Node.SequenceExpression(expressions));

+	                    }

+	                }

+	                if (!arrow) {

+	                    this.expect(')');

+	                    if (this.match('=>')) {

+	                        if (expr.type === syntax_1.Syntax.Identifier && expr.name === 'yield') {

+	                            arrow = true;

+	                            expr = {

+	                                type: ArrowParameterPlaceHolder,

+	                                params: [expr],

+	                                async: false

+	                            };

+	                        }

+	                        if (!arrow) {

+	                            if (!this.context.isBindingElement) {

+	                                this.throwUnexpectedToken(this.lookahead);

+	                            }

+	                            if (expr.type === syntax_1.Syntax.SequenceExpression) {

+	                                for (var i = 0; i < expr.expressions.length; i++) {

+	                                    this.reinterpretExpressionAsPattern(expr.expressions[i]);

+	                                }

+	                            }

+	                            else {

+	                                this.reinterpretExpressionAsPattern(expr);

+	                            }

+	                            var parameters = (expr.type === syntax_1.Syntax.SequenceExpression ? expr.expressions : [expr]);

+	                            expr = {

+	                                type: ArrowParameterPlaceHolder,

+	                                params: parameters,

+	                                async: false

+	                            };

+	                        }

+	                    }

+	                    this.context.isBindingElement = false;

+	                }

+	            }

+	        }

+	        return expr;

+	    };

+	    // https://tc39.github.io/ecma262/#sec-left-hand-side-expressions

+	    Parser.prototype.parseArguments = function () {

+	        this.expect('(');

+	        var args = [];

+	        if (!this.match(')')) {

+	            while (true) {

+	                var expr = this.match('...') ? this.parseSpreadElement() :

+	                    this.isolateCoverGrammar(this.parseAssignmentExpression);

+	                args.push(expr);

+	                if (this.match(')')) {

+	                    break;

+	                }

+	                this.expectCommaSeparator();

+	                if (this.match(')')) {

+	                    break;

+	                }

+	            }

+	        }

+	        this.expect(')');

+	        return args;

+	    };

+	    Parser.prototype.isIdentifierName = function (token) {

+	        return token.type === 3 /* Identifier */ ||

+	            token.type === 4 /* Keyword */ ||

+	            token.type === 1 /* BooleanLiteral */ ||

+	            token.type === 5 /* NullLiteral */;

+	    };

+	    Parser.prototype.parseIdentifierName = function () {

+	        var node = this.createNode();

+	        var token = this.nextToken();

+	        if (!this.isIdentifierName(token)) {

+	            this.throwUnexpectedToken(token);

+	        }

+	        return this.finalize(node, new Node.Identifier(token.value));

+	    };

+	    Parser.prototype.parseNewExpression = function () {

+	        var node = this.createNode();

+	        var id = this.parseIdentifierName();

+	        assert_1.assert(id.name === 'new', 'New expression must start with `new`');

+	        var expr;

+	        if (this.match('.')) {

+	            this.nextToken();

+	            if (this.lookahead.type === 3 /* Identifier */ && this.context.inFunctionBody && this.lookahead.value === 'target') {

+	                var property = this.parseIdentifierName();

+	                expr = new Node.MetaProperty(id, property);

+	            }

+	            else {

+	                this.throwUnexpectedToken(this.lookahead);

+	            }

+	        }

+	        else {

+	            var callee = this.isolateCoverGrammar(this.parseLeftHandSideExpression);

+	            var args = this.match('(') ? this.parseArguments() : [];

+	            expr = new Node.NewExpression(callee, args);

+	            this.context.isAssignmentTarget = false;

+	            this.context.isBindingElement = false;

+	        }

+	        return this.finalize(node, expr);

+	    };

+	    Parser.prototype.parseAsyncArgument = function () {

+	        var arg = this.parseAssignmentExpression();

+	        this.context.firstCoverInitializedNameError = null;

+	        return arg;

+	    };

+	    Parser.prototype.parseAsyncArguments = function () {

+	        this.expect('(');

+	        var args = [];

+	        if (!this.match(')')) {

+	            while (true) {

+	                var expr = this.match('...') ? this.parseSpreadElement() :

+	                    this.isolateCoverGrammar(this.parseAsyncArgument);

+	                args.push(expr);

+	                if (this.match(')')) {

+	                    break;

+	                }

+	                this.expectCommaSeparator();

+	                if (this.match(')')) {

+	                    break;

+	                }

+	            }

+	        }

+	        this.expect(')');

+	        return args;

+	    };

+	    Parser.prototype.parseLeftHandSideExpressionAllowCall = function () {

+	        var startToken = this.lookahead;

+	        var maybeAsync = this.matchContextualKeyword('async');

+	        var previousAllowIn = this.context.allowIn;

+	        this.context.allowIn = true;

+	        var expr;

+	        if (this.matchKeyword('super') && this.context.inFunctionBody) {

+	            expr = this.createNode();

+	            this.nextToken();

+	            expr = this.finalize(expr, new Node.Super());

+	            if (!this.match('(') && !this.match('.') && !this.match('[')) {

+	                this.throwUnexpectedToken(this.lookahead);

+	            }

+	        }

+	        else {

+	            expr = this.inheritCoverGrammar(this.matchKeyword('new') ? this.parseNewExpression : this.parsePrimaryExpression);

+	        }

+	        while (true) {

+	            if (this.match('.')) {

+	                this.context.isBindingElement = false;

+	                this.context.isAssignmentTarget = true;

+	                this.expect('.');

+	                var property = this.parseIdentifierName();

+	                expr = this.finalize(this.startNode(startToken), new Node.StaticMemberExpression(expr, property));

+	            }

+	            else if (this.match('(')) {

+	                var asyncArrow = maybeAsync && (startToken.lineNumber === this.lookahead.lineNumber);

+	                this.context.isBindingElement = false;

+	                this.context.isAssignmentTarget = false;

+	                var args = asyncArrow ? this.parseAsyncArguments() : this.parseArguments();

+	                expr = this.finalize(this.startNode(startToken), new Node.CallExpression(expr, args));

+	                if (asyncArrow && this.match('=>')) {

+	                    for (var i = 0; i < args.length; ++i) {

+	                        this.reinterpretExpressionAsPattern(args[i]);

+	                    }

+	                    expr = {

+	                        type: ArrowParameterPlaceHolder,

+	                        params: args,

+	                        async: true

+	                    };

+	                }

+	            }

+	            else if (this.match('[')) {

+	                this.context.isBindingElement = false;

+	                this.context.isAssignmentTarget = true;

+	                this.expect('[');

+	                var property = this.isolateCoverGrammar(this.parseExpression);

+	                this.expect(']');

+	                expr = this.finalize(this.startNode(startToken), new Node.ComputedMemberExpression(expr, property));

+	            }

+	            else if (this.lookahead.type === 10 /* Template */ && this.lookahead.head) {

+	                var quasi = this.parseTemplateLiteral();

+	                expr = this.finalize(this.startNode(startToken), new Node.TaggedTemplateExpression(expr, quasi));

+	            }

+	            else {

+	                break;

+	            }

+	        }

+	        this.context.allowIn = previousAllowIn;

+	        return expr;

+	    };

+	    Parser.prototype.parseSuper = function () {

+	        var node = this.createNode();

+	        this.expectKeyword('super');

+	        if (!this.match('[') && !this.match('.')) {

+	            this.throwUnexpectedToken(this.lookahead);

+	        }

+	        return this.finalize(node, new Node.Super());

+	    };

+	    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);

+	        while (true) {

+	            if (this.match('[')) {

+	                this.context.isBindingElement = false;

+	                this.context.isAssignmentTarget = true;

+	                this.expect('[');

+	                var property = this.isolateCoverGrammar(this.parseExpression);

+	                this.expect(']');

+	                expr = this.finalize(node, new Node.ComputedMemberExpression(expr, property));

+	            }

+	            else if (this.match('.')) {

+	                this.context.isBindingElement = false;

+	                this.context.isAssignmentTarget = true;

+	                this.expect('.');

+	                var property = this.parseIdentifierName();

+	                expr = this.finalize(node, new Node.StaticMemberExpression(expr, property));

+	            }

+	            else if (this.lookahead.type === 10 /* Template */ && this.lookahead.head) {

+	                var quasi = this.parseTemplateLiteral();

+	                expr = this.finalize(node, new Node.TaggedTemplateExpression(expr, quasi));

+	            }

+	            else {

+	                break;

+	            }

+	        }

+	        return expr;

+	    };

+	    // https://tc39.github.io/ecma262/#sec-update-expressions

+	    Parser.prototype.parseUpdateExpression = function () {

+	        var expr;

+	        var startToken = this.lookahead;

+	        if (this.match('++') || this.match('--')) {

+	            var node = this.startNode(startToken);

+	            var token = this.nextToken();

+	            expr = this.inheritCoverGrammar(this.parseUnaryExpression);

+	            if (this.context.strict && expr.type === syntax_1.Syntax.Identifier && this.scanner.isRestrictedWord(expr.name)) {

+	                this.tolerateError(messages_1.Messages.StrictLHSPrefix);

+	            }

+	            if (!this.context.isAssignmentTarget) {

+	                this.tolerateError(messages_1.Messages.InvalidLHSInAssignment);

+	            }

+	            var prefix = true;

+	            expr = this.finalize(node, new Node.UpdateExpression(token.value, expr, prefix));

+	            this.context.isAssignmentTarget = false;

+	            this.context.isBindingElement = false;

+	        }

+	        else {

+	            expr = this.inheritCoverGrammar(this.parseLeftHandSideExpressionAllowCall);

+	            if (!this.hasLineTerminator && this.lookahead.type === 7 /* Punctuator */) {

+	                if (this.match('++') || this.match('--')) {

+	                    if (this.context.strict && expr.type === syntax_1.Syntax.Identifier && this.scanner.isRestrictedWord(expr.name)) {

+	                        this.tolerateError(messages_1.Messages.StrictLHSPostfix);

+	                    }

+	                    if (!this.context.isAssignmentTarget) {

+	                        this.tolerateError(messages_1.Messages.InvalidLHSInAssignment);

+	                    }

+	                    this.context.isAssignmentTarget = false;

+	                    this.context.isBindingElement = false;

+	                    var operator = this.nextToken().value;

+	                    var prefix = false;

+	                    expr = this.finalize(this.startNode(startToken), new Node.UpdateExpression(operator, expr, prefix));

+	                }

+	            }

+	        }

+	        return expr;

+	    };

+	    // https://tc39.github.io/ecma262/#sec-unary-operators

+	    Parser.prototype.parseAwaitExpression = function () {

+	        var node = this.createNode();

+	        this.nextToken();

+	        var argument = this.parseUnaryExpression();

+	        return this.finalize(node, new Node.AwaitExpression(argument));

+	    };

+	    Parser.prototype.parseUnaryExpression = function () {

+	        var expr;

+	        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);

+	            expr = this.finalize(node, new Node.UnaryExpression(token.value, expr));

+	            if (this.context.strict && expr.operator === 'delete' && expr.argument.type === syntax_1.Syntax.Identifier) {

+	                this.tolerateError(messages_1.Messages.StrictDelete);

+	            }

+	            this.context.isAssignmentTarget = false;

+	            this.context.isBindingElement = false;

+	        }

+	        else if (this.context.await && this.matchContextualKeyword('await')) {

+	            expr = this.parseAwaitExpression();

+	        }

+	        else {

+	            expr = this.parseUpdateExpression();

+	        }

+	        return expr;

+	    };

+	    Parser.prototype.parseExponentiationExpression = function () {

+	        var startToken = this.lookahead;

+	        var expr = this.inheritCoverGrammar(this.parseUnaryExpression);

+	        if (expr.type !== syntax_1.Syntax.UnaryExpression && this.match('**')) {

+	            this.nextToken();

+	            this.context.isAssignmentTarget = false;

+	            this.context.isBindingElement = false;

+	            var left = expr;

+	            var right = this.isolateCoverGrammar(this.parseExponentiationExpression);

+	            expr = this.finalize(this.startNode(startToken), new Node.BinaryExpression('**', left, right));

+	        }

+	        return expr;

+	    };

+	    // https://tc39.github.io/ecma262/#sec-exp-operator

+	    // https://tc39.github.io/ecma262/#sec-multiplicative-operators

+	    // https://tc39.github.io/ecma262/#sec-additive-operators

+	    // https://tc39.github.io/ecma262/#sec-bitwise-shift-operators

+	    // https://tc39.github.io/ecma262/#sec-relational-operators

+	    // https://tc39.github.io/ecma262/#sec-equality-operators

+	    // https://tc39.github.io/ecma262/#sec-binary-bitwise-operators

+	    // https://tc39.github.io/ecma262/#sec-binary-logical-operators

+	    Parser.prototype.binaryPrecedence = function (token) {

+	        var op = token.value;

+	        var precedence;

+	        if (token.type === 7 /* Punctuator */) {

+	            precedence = this.operatorPrecedence[op] || 0;

+	        }

+	        else if (token.type === 4 /* Keyword */) {

+	            precedence = (op === 'instanceof' || (this.context.allowIn && op === 'in')) ? 7 : 0;

+	        }

+	        else {

+	            precedence = 0;

+	        }

+	        return precedence;

+	    };

+	    Parser.prototype.parseBinaryExpression = function () {

+	        var startToken = this.lookahead;

+	        var expr = this.inheritCoverGrammar(this.parseExponentiationExpression);

+	        var token = this.lookahead;

+	        var prec = this.binaryPrecedence(token);

+	        if (prec > 0) {

+	            this.nextToken();

+	            this.context.isAssignmentTarget = false;

+	            this.context.isBindingElement = false;

+	            var markers = [startToken, this.lookahead];

+	            var left = expr;

+	            var right = this.isolateCoverGrammar(this.parseExponentiationExpression);

+	            var stack = [left, token.value, right];

+	            var precedences = [prec];

+	            while (true) {

+	                prec = this.binaryPrecedence(this.lookahead);

+	                if (prec <= 0) {

+	                    break;

+	                }

+	                // Reduce: make a binary expression from the three topmost entries.

+	                while ((stack.length > 2) && (prec <= precedences[precedences.length - 1])) {

+	                    right = stack.pop();

+	                    var operator = stack.pop();

+	                    precedences.pop();

+	                    left = stack.pop();

+	                    markers.pop();

+	                    var node = this.startNode(markers[markers.length - 1]);

+	                    stack.push(this.finalize(node, new Node.BinaryExpression(operator, left, right)));

+	                }

+	                // Shift.

+	                stack.push(this.nextToken().value);

+	                precedences.push(prec);

+	                markers.push(this.lookahead);

+	                stack.push(this.isolateCoverGrammar(this.parseExponentiationExpression));

+	            }

+	            // Final reduce to clean-up the stack.

+	            var i = stack.length - 1;

+	            expr = stack[i];

+	            markers.pop();

+	            while (i > 1) {

+	                var node = this.startNode(markers.pop());

+	                var operator = stack[i - 1];

+	                expr = this.finalize(node, new Node.BinaryExpression(operator, stack[i - 2], expr));

+	                i -= 2;

+	            }

+	        }

+	        return expr;

+	    };

+	    // https://tc39.github.io/ecma262/#sec-conditional-operator

+	    Parser.prototype.parseConditionalExpression = function () {

+	        var startToken = this.lookahead;

+	        var expr = this.inheritCoverGrammar(this.parseBinaryExpression);

+	        if (this.match('?')) {

+	            this.nextToken();

+	            var previousAllowIn = this.context.allowIn;

+	            this.context.allowIn = true;

+	            var consequent = this.isolateCoverGrammar(this.parseAssignmentExpression);

+	            this.context.allowIn = previousAllowIn;

+	            this.expect(':');

+	            var alternate = this.isolateCoverGrammar(this.parseAssignmentExpression);

+	            expr = this.finalize(this.startNode(startToken), new Node.ConditionalExpression(expr, consequent, alternate));

+	            this.context.isAssignmentTarget = false;

+	            this.context.isBindingElement = false;

+	        }

+	        return expr;

+	    };

+	    // https://tc39.github.io/ecma262/#sec-assignment-operators

+	    Parser.prototype.checkPatternParam = function (options, param) {

+	        switch (param.type) {

+	            case syntax_1.Syntax.Identifier:

+	                this.validateParam(options, param, param.name);

+	                break;

+	            case syntax_1.Syntax.RestElement:

+	                this.checkPatternParam(options, param.argument);

+	                break;

+	            case syntax_1.Syntax.AssignmentPattern:

+	                this.checkPatternParam(options, param.left);

+	                break;

+	            case syntax_1.Syntax.ArrayPattern:

+	                for (var i = 0; i < param.elements.length; i++) {

+	                    if (param.elements[i] !== null) {

+	                        this.checkPatternParam(options, param.elements[i]);

+	                    }

+	                }

+	                break;

+	            case syntax_1.Syntax.ObjectPattern:

+	                for (var i = 0; i < param.properties.length; i++) {

+	                    this.checkPatternParam(options, param.properties[i].value);

+	                }

+	                break;

+	            default:

+	                break;

+	        }

+	        options.simple = options.simple && (param instanceof Node.Identifier);

+	    };

+	    Parser.prototype.reinterpretAsCoverFormalsList = function (expr) {

+	        var params = [expr];

+	        var options;

+	        var asyncArrow = false;

+	        switch (expr.type) {

+	            case syntax_1.Syntax.Identifier:

+	                break;

+	            case ArrowParameterPlaceHolder:

+	                params = expr.params;

+	                asyncArrow = expr.async;

+	                break;

+	            default:

+	                return null;

+	        }

+	        options = {

+	            simple: true,

+	            paramSet: {}

+	        };

+	        for (var i = 0; i < params.length; ++i) {

+	            var param = params[i];

+	            if (param.type === syntax_1.Syntax.AssignmentPattern) {

+	                if (param.right.type === syntax_1.Syntax.YieldExpression) {

+	                    if (param.right.argument) {

+	                        this.throwUnexpectedToken(this.lookahead);

+	                    }

+	                    param.right.type = syntax_1.Syntax.Identifier;

+	                    param.right.name = 'yield';

+	                    delete param.right.argument;

+	                    delete param.right.delegate;

+	                }

+	            }

+	            else if (asyncArrow && param.type === syntax_1.Syntax.Identifier && param.name === 'await') {

+	                this.throwUnexpectedToken(this.lookahead);

+	            }

+	            this.checkPatternParam(options, param);

+	            params[i] = param;

+	        }

+	        if (this.context.strict || !this.context.allowYield) {

+	            for (var i = 0; i < params.length; ++i) {

+	                var param = params[i];

+	                if (param.type === syntax_1.Syntax.YieldExpression) {

+	                    this.throwUnexpectedToken(this.lookahead);

+	                }

+	            }

+	        }

+	        if (options.message === messages_1.Messages.StrictParamDupe) {

+	            var token = this.context.strict ? options.stricted : options.firstRestricted;

+	            this.throwUnexpectedToken(token, options.message);

+	        }

+	        return {

+	            simple: options.simple,

+	            params: params,

+	            stricted: options.stricted,

+	            firstRestricted: options.firstRestricted,

+	            message: options.message

+	        };

+	    };

+	    Parser.prototype.parseAssignmentExpression = function () {

+	        var expr;

+	        if (!this.context.allowYield && this.matchKeyword('yield')) {

+	            expr = this.parseYieldExpression();

+	        }

+	        else {

+	            var startToken = this.lookahead;

+	            var token = startToken;

+	            expr = this.parseConditionalExpression();

+	            if (token.type === 3 /* Identifier */ && (token.lineNumber === this.lookahead.lineNumber) && token.value === 'async') {

+	                if (this.lookahead.type === 3 /* Identifier */ || this.matchKeyword('yield')) {

+	                    var arg = this.parsePrimaryExpression();

+	                    this.reinterpretExpressionAsPattern(arg);

+	                    expr = {

+	                        type: ArrowParameterPlaceHolder,

+	                        params: [arg],

+	                        async: true

+	                    };

+	                }

+	            }

+	            if (expr.type === ArrowParameterPlaceHolder || this.match('=>')) {

+	                // https://tc39.github.io/ecma262/#sec-arrow-function-definitions

+	                this.context.isAssignmentTarget = false;

+	                this.context.isBindingElement = false;

+	                var isAsync = expr.async;

+	                var list = this.reinterpretAsCoverFormalsList(expr);

+	                if (list) {

+	                    if (this.hasLineTerminator) {

+	                        this.tolerateUnexpectedToken(this.lookahead);

+	                    }

+	                    this.context.firstCoverInitializedNameError = null;

+	                    var previousStrict = this.context.strict;

+	                    var previousAllowStrictDirective = this.context.allowStrictDirective;

+	                    this.context.allowStrictDirective = list.simple;

+	                    var previousAllowYield = this.context.allowYield;

+	                    var previousAwait = this.context.await;

+	                    this.context.allowYield = true;

+	                    this.context.await = isAsync;

+	                    var node = this.startNode(startToken);

+	                    this.expect('=>');

+	                    var body = void 0;

+	                    if (this.match('{')) {

+	                        var previousAllowIn = this.context.allowIn;

+	                        this.context.allowIn = true;

+	                        body = this.parseFunctionSourceElements();

+	                        this.context.allowIn = previousAllowIn;

+	                    }

+	                    else {

+	                        body = this.isolateCoverGrammar(this.parseAssignmentExpression);

+	                    }

+	                    var expression = body.type !== syntax_1.Syntax.BlockStatement;

+	                    if (this.context.strict && list.firstRestricted) {

+	                        this.throwUnexpectedToken(list.firstRestricted, list.message);

+	                    }

+	                    if (this.context.strict && list.stricted) {

+	                        this.tolerateUnexpectedToken(list.stricted, list.message);

+	                    }

+	                    expr = isAsync ? this.finalize(node, new Node.AsyncArrowFunctionExpression(list.params, body, expression)) :

+	                        this.finalize(node, new Node.ArrowFunctionExpression(list.params, body, expression));

+	                    this.context.strict = previousStrict;

+	                    this.context.allowStrictDirective = previousAllowStrictDirective;

+	                    this.context.allowYield = previousAllowYield;

+	                    this.context.await = previousAwait;

+	                }

+	            }

+	            else {

+	                if (this.matchAssign()) {

+	                    if (!this.context.isAssignmentTarget) {

+	                        this.tolerateError(messages_1.Messages.InvalidLHSInAssignment);

+	                    }

+	                    if (this.context.strict && expr.type === syntax_1.Syntax.Identifier) {

+	                        var id = expr;

+	                        if (this.scanner.isRestrictedWord(id.name)) {

+	                            this.tolerateUnexpectedToken(token, messages_1.Messages.StrictLHSAssignment);

+	                        }

+	                        if (this.scanner.isStrictModeReservedWord(id.name)) {

+	                            this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);

+	                        }

+	                    }

+	                    if (!this.match('=')) {

+	                        this.context.isAssignmentTarget = false;

+	                        this.context.isBindingElement = false;

+	                    }

+	                    else {

+	                        this.reinterpretExpressionAsPattern(expr);

+	                    }

+	                    token = this.nextToken();

+	                    var operator = token.value;

+	                    var right = this.isolateCoverGrammar(this.parseAssignmentExpression);

+	                    expr = this.finalize(this.startNode(startToken), new Node.AssignmentExpression(operator, expr, right));

+	                    this.context.firstCoverInitializedNameError = null;

+	                }

+	            }

+	        }

+	        return expr;

+	    };

+	    // https://tc39.github.io/ecma262/#sec-comma-operator

+	    Parser.prototype.parseExpression = function () {

+	        var startToken = this.lookahead;

+	        var expr = this.isolateCoverGrammar(this.parseAssignmentExpression);

+	        if (this.match(',')) {

+	            var expressions = [];

+	            expressions.push(expr);

+	            while (this.lookahead.type !== 2 /* EOF */) {

+	                if (!this.match(',')) {

+	                    break;

+	                }

+	                this.nextToken();

+	                expressions.push(this.isolateCoverGrammar(this.parseAssignmentExpression));

+	            }

+	            expr = this.finalize(this.startNode(startToken), new Node.SequenceExpression(expressions));

+	        }

+	        return expr;

+	    };

+	    // https://tc39.github.io/ecma262/#sec-block

+	    Parser.prototype.parseStatementListItem = function () {

+	        var statement;

+	        this.context.isAssignmentTarget = true;

+	        this.context.isBindingElement = true;

+	        if (this.lookahead.type === 4 /* Keyword */) {

+	            switch (this.lookahead.value) {

+	                case 'export':

+	                    if (!this.context.isModule) {

+	                        this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.IllegalExportDeclaration);

+	                    }

+	                    statement = this.parseExportDeclaration();

+	                    break;

+	                case 'import':

+	                    if (!this.context.isModule) {

+	                        this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.IllegalImportDeclaration);

+	                    }

+	                    statement = this.parseImportDeclaration();

+	                    break;

+	                case 'const':

+	                    statement = this.parseLexicalDeclaration({ inFor: false });

+	                    break;

+	                case 'function':

+	                    statement = this.parseFunctionDeclaration();

+	                    break;

+	                case 'class':

+	                    statement = this.parseClassDeclaration();

+	                    break;

+	                case 'let':

+	                    statement = this.isLexicalDeclaration() ? this.parseLexicalDeclaration({ inFor: false }) : this.parseStatement();

+	                    break;

+	                default:

+	                    statement = this.parseStatement();

+	                    break;

+	            }

+	        }

+	        else {

+	            statement = this.parseStatement();

+	        }

+	        return statement;

+	    };

+	    Parser.prototype.parseBlock = function () {

+	        var node = this.createNode();

+	        this.expect('{');

+	        var block = [];

+	        while (true) {

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

+	                break;

+	            }

+	            block.push(this.parseStatementListItem());

+	        }

+	        this.expect('}');

+	        return this.finalize(node, new Node.BlockStatement(block));

+	    };

+	    // https://tc39.github.io/ecma262/#sec-let-and-const-declarations

+	    Parser.prototype.parseLexicalBinding = function (kind, options) {

+	        var node = this.createNode();

+	        var params = [];

+	        var id = this.parsePattern(params, kind);

+	        if (this.context.strict && id.type === syntax_1.Syntax.Identifier) {

+	            if (this.scanner.isRestrictedWord(id.name)) {

+	                this.tolerateError(messages_1.Messages.StrictVarName);

+	            }

+	        }

+	        var init = null;

+	        if (kind === 'const') {

+	            if (!this.matchKeyword('in') && !this.matchContextualKeyword('of')) {

+	                if (this.match('=')) {

+	                    this.nextToken();

+	                    init = this.isolateCoverGrammar(this.parseAssignmentExpression);

+	                }

+	                else {

+	                    this.throwError(messages_1.Messages.DeclarationMissingInitializer, 'const');

+	                }

+	            }

+	        }

+	        else if ((!options.inFor && id.type !== syntax_1.Syntax.Identifier) || this.match('=')) {

+	            this.expect('=');

+	            init = this.isolateCoverGrammar(this.parseAssignmentExpression);

+	        }

+	        return this.finalize(node, new Node.VariableDeclarator(id, init));

+	    };

+	    Parser.prototype.parseBindingList = function (kind, options) {

+	        var list = [this.parseLexicalBinding(kind, options)];

+	        while (this.match(',')) {

+	            this.nextToken();

+	            list.push(this.parseLexicalBinding(kind, options));

+	        }

+	        return list;

+	    };

+	    Parser.prototype.isLexicalDeclaration = function () {

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

+	        this.scanner.scanComments();

+	        var next = this.scanner.lex();

+	        this.scanner.restoreState(state);

+	        return (next.type === 3 /* Identifier */) ||

+	            (next.type === 7 /* Punctuator */ && next.value === '[') ||

+	            (next.type === 7 /* Punctuator */ && next.value === '{') ||

+	            (next.type === 4 /* Keyword */ && next.value === 'let') ||

+	            (next.type === 4 /* Keyword */ && next.value === 'yield');

+	    };

+	    Parser.prototype.parseLexicalDeclaration = function (options) {

+	        var node = this.createNode();

+	        var kind = this.nextToken().value;

+	        assert_1.assert(kind === 'let' || kind === 'const', 'Lexical declaration must be either let or const');

+	        var declarations = this.parseBindingList(kind, options);

+	        this.consumeSemicolon();

+	        return this.finalize(node, new Node.VariableDeclaration(declarations, kind));

+	    };

+	    // https://tc39.github.io/ecma262/#sec-destructuring-binding-patterns

+	    Parser.prototype.parseBindingRestElement = function (params, kind) {

+	        var node = this.createNode();

+	        this.expect('...');

+	        var arg = this.parsePattern(params, kind);

+	        return this.finalize(node, new Node.RestElement(arg));

+	    };

+	    Parser.prototype.parseArrayPattern = function (params, kind) {

+	        var node = this.createNode();

+	        this.expect('[');

+	        var elements = [];

+	        while (!this.match(']')) {

+	            if (this.match(',')) {

+	                this.nextToken();

+	                elements.push(null);

+	            }

+	            else {

+	                if (this.match('...')) {

+	                    elements.push(this.parseBindingRestElement(params, kind));

+	                    break;

+	                }

+	                else {

+	                    elements.push(this.parsePatternWithDefault(params, kind));

+	                }

+	                if (!this.match(']')) {

+	                    this.expect(',');

+	                }

+	            }

+	        }

+	        this.expect(']');

+	        return this.finalize(node, new Node.ArrayPattern(elements));

+	    };

+	    Parser.prototype.parsePropertyPattern = function (params, kind) {

+	        var node = this.createNode();

+	        var computed = false;

+	        var shorthand = false;

+	        var method = false;

+	        var key;

+	        var value;

+	        if (this.lookahead.type === 3 /* Identifier */) {

+	            var keyToken = this.lookahead;

+	            key = this.parseVariableIdentifier();

+	            var init = this.finalize(node, new Node.Identifier(keyToken.value));

+	            if (this.match('=')) {

+	                params.push(keyToken);

+	                shorthand = true;

+	                this.nextToken();

+	                var expr = this.parseAssignmentExpression();

+	                value = this.finalize(this.startNode(keyToken), new Node.AssignmentPattern(init, expr));

+	            }

+	            else if (!this.match(':')) {

+	                params.push(keyToken);

+	                shorthand = true;

+	                value = init;

+	            }

+	            else {

+	                this.expect(':');

+	                value = this.parsePatternWithDefault(params, kind);

+	            }

+	        }

+	        else {

+	            computed = this.match('[');

+	            key = this.parseObjectPropertyKey();

+	            this.expect(':');

+	            value = this.parsePatternWithDefault(params, kind);

+	        }

+	        return this.finalize(node, new Node.Property('init', key, computed, value, method, shorthand));

+	    };

+	    Parser.prototype.parseObjectPattern = function (params, kind) {

+	        var node = this.createNode();

+	        var properties = [];

+	        this.expect('{');

+	        while (!this.match('}')) {

+	            properties.push(this.parsePropertyPattern(params, kind));

+	            if (!this.match('}')) {

+	                this.expect(',');

+	            }

+	        }

+	        this.expect('}');

+	        return this.finalize(node, new Node.ObjectPattern(properties));

+	    };

+	    Parser.prototype.parsePattern = function (params, kind) {

+	        var pattern;

+	        if (this.match('[')) {

+	            pattern = this.parseArrayPattern(params, kind);

+	        }

+	        else if (this.match('{')) {

+	            pattern = this.parseObjectPattern(params, kind);

+	        }

+	        else {

+	            if (this.matchKeyword('let') && (kind === 'const' || kind === 'let')) {

+	                this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.LetInLexicalBinding);

+	            }

+	            params.push(this.lookahead);

+	            pattern = this.parseVariableIdentifier(kind);

+	        }

+	        return pattern;

+	    };

+	    Parser.prototype.parsePatternWithDefault = function (params, kind) {

+	        var startToken = this.lookahead;

+	        var pattern = this.parsePattern(params, kind);

+	        if (this.match('=')) {

+	            this.nextToken();

+	            var previousAllowYield = this.context.allowYield;

+	            this.context.allowYield = true;

+	            var right = this.isolateCoverGrammar(this.parseAssignmentExpression);

+	            this.context.allowYield = previousAllowYield;

+	            pattern = this.finalize(this.startNode(startToken), new Node.AssignmentPattern(pattern, right));

+	        }

+	        return pattern;

+	    };

+	    // https://tc39.github.io/ecma262/#sec-variable-statement

+	    Parser.prototype.parseVariableIdentifier = function (kind) {

+	        var node = this.createNode();

+	        var token = this.nextToken();

+	        if (token.type === 4 /* Keyword */ && token.value === 'yield') {

+	            if (this.context.strict) {

+	                this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);

+	            }

+	            else if (!this.context.allowYield) {

+	                this.throwUnexpectedToken(token);

+	            }

+	        }

+	        else if (token.type !== 3 /* Identifier */) {

+	            if (this.context.strict && token.type === 4 /* Keyword */ && this.scanner.isStrictModeReservedWord(token.value)) {

+	                this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);

+	            }

+	            else {

+	                if (this.context.strict || token.value !== 'let' || kind !== 'var') {

+	                    this.throwUnexpectedToken(token);

+	                }

+	            }

+	        }

+	        else if ((this.context.isModule || this.context.await) && token.type === 3 /* Identifier */ && token.value === 'await') {

+	            this.tolerateUnexpectedToken(token);

+	        }

+	        return this.finalize(node, new Node.Identifier(token.value));

+	    };

+	    Parser.prototype.parseVariableDeclaration = function (options) {

+	        var node = this.createNode();

+	        var params = [];

+	        var id = this.parsePattern(params, 'var');

+	        if (this.context.strict && id.type === syntax_1.Syntax.Identifier) {

+	            if (this.scanner.isRestrictedWord(id.name)) {

+	                this.tolerateError(messages_1.Messages.StrictVarName);

+	            }

+	        }

+	        var init = null;

+	        if (this.match('=')) {

+	            this.nextToken();

+	            init = this.isolateCoverGrammar(this.parseAssignmentExpression);

+	        }

+	        else if (id.type !== syntax_1.Syntax.Identifier && !options.inFor) {

+	            this.expect('=');

+	        }

+	        return this.finalize(node, new Node.VariableDeclarator(id, init));

+	    };

+	    Parser.prototype.parseVariableDeclarationList = function (options) {

+	        var opt = { inFor: options.inFor };

+	        var list = [];

+	        list.push(this.parseVariableDeclaration(opt));

+	        while (this.match(',')) {

+	            this.nextToken();

+	            list.push(this.parseVariableDeclaration(opt));

+	        }

+	        return list;

+	    };

+	    Parser.prototype.parseVariableStatement = function () {

+	        var node = this.createNode();

+	        this.expectKeyword('var');

+	        var declarations = this.parseVariableDeclarationList({ inFor: false });

+	        this.consumeSemicolon();

+	        return this.finalize(node, new Node.VariableDeclaration(declarations, 'var'));

+	    };

+	    // https://tc39.github.io/ecma262/#sec-empty-statement

+	    Parser.prototype.parseEmptyStatement = function () {

+	        var node = this.createNode();

+	        this.expect(';');

+	        return this.finalize(node, new Node.EmptyStatement());

+	    };

+	    // https://tc39.github.io/ecma262/#sec-expression-statement

+	    Parser.prototype.parseExpressionStatement = function () {

+	        var node = this.createNode();

+	        var expr = this.parseExpression();

+	        this.consumeSemicolon();

+	        return this.finalize(node, new Node.ExpressionStatement(expr));

+	    };

+	    // https://tc39.github.io/ecma262/#sec-if-statement

+	    Parser.prototype.parseIfClause = function () {

+	        if (this.context.strict && this.matchKeyword('function')) {

+	            this.tolerateError(messages_1.Messages.StrictFunction);

+	        }

+	        return this.parseStatement();

+	    };

+	    Parser.prototype.parseIfStatement = function () {

+	        var node = this.createNode();

+	        var consequent;

+	        var alternate = null;

+	        this.expectKeyword('if');

+	        this.expect('(');

+	        var test = this.parseExpression();

+	        if (!this.match(')') && this.config.tolerant) {

+	            this.tolerateUnexpectedToken(this.nextToken());

+	            consequent = this.finalize(this.createNode(), new Node.EmptyStatement());

+	        }

+	        else {

+	            this.expect(')');

+	            consequent = this.parseIfClause();

+	            if (this.matchKeyword('else')) {

+	                this.nextToken();

+	                alternate = this.parseIfClause();

+	            }

+	        }

+	        return this.finalize(node, new Node.IfStatement(test, consequent, alternate));

+	    };

+	    // https://tc39.github.io/ecma262/#sec-do-while-statement

+	    Parser.prototype.parseDoWhileStatement = function () {

+	        var node = this.createNode();

+	        this.expectKeyword('do');

+	        var previousInIteration = this.context.inIteration;

+	        this.context.inIteration = true;

+	        var body = this.parseStatement();

+	        this.context.inIteration = previousInIteration;

+	        this.expectKeyword('while');

+	        this.expect('(');

+	        var test = this.parseExpression();

+	        if (!this.match(')') && this.config.tolerant) {

+	            this.tolerateUnexpectedToken(this.nextToken());

+	        }

+	        else {

+	            this.expect(')');

+	            if (this.match(';')) {

+	                this.nextToken();

+	            }

+	        }

+	        return this.finalize(node, new Node.DoWhileStatement(body, test));

+	    };

+	    // https://tc39.github.io/ecma262/#sec-while-statement

+	    Parser.prototype.parseWhileStatement = function () {

+	        var node = this.createNode();

+	        var body;

+	        this.expectKeyword('while');

+	        this.expect('(');

+	        var test = this.parseExpression();

+	        if (!this.match(')') && this.config.tolerant) {

+	            this.tolerateUnexpectedToken(this.nextToken());

+	            body = this.finalize(this.createNode(), new Node.EmptyStatement());

+	        }

+	        else {

+	            this.expect(')');

+	            var previousInIteration = this.context.inIteration;

+	            this.context.inIteration = true;

+	            body = this.parseStatement();

+	            this.context.inIteration = previousInIteration;

+	        }

+	        return this.finalize(node, new Node.WhileStatement(test, body));

+	    };

+	    // https://tc39.github.io/ecma262/#sec-for-statement

+	    // https://tc39.github.io/ecma262/#sec-for-in-and-for-of-statements

+	    Parser.prototype.parseForStatement = function () {

+	        var init = null;

+	        var test = null;

+	        var update = null;

+	        var forIn = true;

+	        var left, right;

+	        var node = this.createNode();

+	        this.expectKeyword('for');

+	        this.expect('(');

+	        if (this.match(';')) {

+	            this.nextToken();

+	        }

+	        else {

+	            if (this.matchKeyword('var')) {

+	                init = this.createNode();

+	                this.nextToken();

+	                var previousAllowIn = this.context.allowIn;

+	                this.context.allowIn = false;

+	                var declarations = this.parseVariableDeclarationList({ inFor: true });

+	                this.context.allowIn = previousAllowIn;

+	                if (declarations.length === 1 && this.matchKeyword('in')) {

+	                    var decl = declarations[0];

+	                    if (decl.init && (decl.id.type === syntax_1.Syntax.ArrayPattern || decl.id.type === syntax_1.Syntax.ObjectPattern || this.context.strict)) {

+	                        this.tolerateError(messages_1.Messages.ForInOfLoopInitializer, 'for-in');

+	                    }

+	                    init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var'));

+	                    this.nextToken();

+	                    left = init;

+	                    right = this.parseExpression();

+	                    init = null;

+	                }

+	                else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword('of')) {

+	                    init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var'));

+	                    this.nextToken();

+	                    left = init;

+	                    right = this.parseAssignmentExpression();

+	                    init = null;

+	                    forIn = false;

+	                }

+	                else {

+	                    init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var'));

+	                    this.expect(';');

+	                }

+	            }

+	            else if (this.matchKeyword('const') || this.matchKeyword('let')) {

+	                init = this.createNode();

+	                var kind = this.nextToken().value;

+	                if (!this.context.strict && this.lookahead.value === 'in') {

+	                    init = this.finalize(init, new Node.Identifier(kind));

+	                    this.nextToken();

+	                    left = init;

+	                    right = this.parseExpression();

+	                    init = null;

+	                }

+	                else {

+	                    var previousAllowIn = this.context.allowIn;

+	                    this.context.allowIn = false;

+	                    var declarations = this.parseBindingList(kind, { inFor: true });

+	                    this.context.allowIn = previousAllowIn;

+	                    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();

+	                        init = null;

+	                    }

+	                    else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword('of')) {

+	                        init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));

+	                        this.nextToken();

+	                        left = init;

+	                        right = this.parseAssignmentExpression();

+	                        init = null;

+	                        forIn = false;

+	                    }

+	                    else {

+	                        this.consumeSemicolon();

+	                        init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));

+	                    }

+	                }

+	            }

+	            else {

+	                var initStartToken = this.lookahead;

+	                var previousAllowIn = this.context.allowIn;

+	                this.context.allowIn = false;

+	                init = this.inheritCoverGrammar(this.parseAssignmentExpression);

+	                this.context.allowIn = previousAllowIn;

+	                if (this.matchKeyword('in')) {

+	                    if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {

+	                        this.tolerateError(messages_1.Messages.InvalidLHSInForIn);

+	                    }

+	                    this.nextToken();

+	                    this.reinterpretExpressionAsPattern(init);

+	                    left = init;

+	                    right = this.parseExpression();

+	                    init = null;

+	                }

+	                else if (this.matchContextualKeyword('of')) {

+	                    if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {

+	                        this.tolerateError(messages_1.Messages.InvalidLHSInForLoop);

+	                    }

+	                    this.nextToken();

+	                    this.reinterpretExpressionAsPattern(init);

+	                    left = init;

+	                    right = this.parseAssignmentExpression();

+	                    init = null;

+	                    forIn = false;

+	                }

+	                else {

+	                    if (this.match(',')) {

+	                        var initSeq = [init];

+	                        while (this.match(',')) {

+	                            this.nextToken();

+	                            initSeq.push(this.isolateCoverGrammar(this.parseAssignmentExpression));

+	                        }

+	                        init = this.finalize(this.startNode(initStartToken), new Node.SequenceExpression(initSeq));

+	                    }

+	                    this.expect(';');

+	                }

+	            }

+	        }

+	        if (typeof left === 'undefined') {

+	            if (!this.match(';')) {

+	                test = this.parseExpression();

+	            }

+	            this.expect(';');

+	            if (!this.match(')')) {

+	                update = this.parseExpression();

+	            }

+	        }

+	        var body;

+	        if (!this.match(')') && this.config.tolerant) {

+	            this.tolerateUnexpectedToken(this.nextToken());

+	            body = this.finalize(this.createNode(), new Node.EmptyStatement());

+	        }

+	        else {

+	            this.expect(')');

+	            var previousInIteration = this.context.inIteration;

+	            this.context.inIteration = true;

+	            body = this.isolateCoverGrammar(this.parseStatement);

+	            this.context.inIteration = previousInIteration;

+	        }

+	        return (typeof left === 'undefined') ?

+	            this.finalize(node, new Node.ForStatement(init, test, update, body)) :

+	            forIn ? this.finalize(node, new Node.ForInStatement(left, right, body)) :

+	                this.finalize(node, new Node.ForOfStatement(left, right, body));

+	    };

+	    // https://tc39.github.io/ecma262/#sec-continue-statement

+	    Parser.prototype.parseContinueStatement = function () {

+	        var node = this.createNode();

+	        this.expectKeyword('continue');

+	        var label = null;

+	        if (this.lookahead.type === 3 /* Identifier */ && !this.hasLineTerminator) {

+	            var id = this.parseVariableIdentifier();

+	            label = id;

+	            var key = '$' + id.name;

+	            if (!Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) {

+	                this.throwError(messages_1.Messages.UnknownLabel, id.name);

+	            }

+	        }

+	        this.consumeSemicolon();

+	        if (label === null && !this.context.inIteration) {

+	            this.throwError(messages_1.Messages.IllegalContinue);

+	        }

+	        return this.finalize(node, new Node.ContinueStatement(label));

+	    };

+	    // https://tc39.github.io/ecma262/#sec-break-statement

+	    Parser.prototype.parseBreakStatement = function () {

+	        var node = this.createNode();

+	        this.expectKeyword('break');

+	        var label = null;

+	        if (this.lookahead.type === 3 /* Identifier */ && !this.hasLineTerminator) {

+	            var id = this.parseVariableIdentifier();

+	            var key = '$' + id.name;

+	            if (!Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) {

+	                this.throwError(messages_1.Messages.UnknownLabel, id.name);

+	            }

+	            label = id;

+	        }

+	        this.consumeSemicolon();

+	        if (label === null && !this.context.inIteration && !this.context.inSwitch) {

+	            this.throwError(messages_1.Messages.IllegalBreak);

+	        }

+	        return this.finalize(node, new Node.BreakStatement(label));

+	    };

+	    // https://tc39.github.io/ecma262/#sec-return-statement

+	    Parser.prototype.parseReturnStatement = function () {

+	        if (!this.context.inFunctionBody) {

+	            this.tolerateError(messages_1.Messages.IllegalReturn);

+	        }

+	        var node = this.createNode();

+	        this.expectKeyword('return');

+	        var hasArgument = !this.match(';') && !this.match('}') &&

+	            !this.hasLineTerminator && this.lookahead.type !== 2 /* EOF */;

+	        var argument = hasArgument ? this.parseExpression() : null;

+	        this.consumeSemicolon();

+	        return this.finalize(node, new Node.ReturnStatement(argument));

+	    };

+	    // https://tc39.github.io/ecma262/#sec-with-statement

+	    Parser.prototype.parseWithStatement = function () {

+	        if (this.context.strict) {

+	            this.tolerateError(messages_1.Messages.StrictModeWith);

+	        }

+	        var node = this.createNode();

+	        var body;

+	        this.expectKeyword('with');

+	        this.expect('(');

+	        var object = this.parseExpression();

+	        if (!this.match(')') && this.config.tolerant) {

+	            this.tolerateUnexpectedToken(this.nextToken());

+	            body = this.finalize(this.createNode(), new Node.EmptyStatement());

+	        }

+	        else {

+	            this.expect(')');

+	            body = this.parseStatement();

+	        }

+	        return this.finalize(node, new Node.WithStatement(object, body));

+	    };

+	    // https://tc39.github.io/ecma262/#sec-switch-statement

+	    Parser.prototype.parseSwitchCase = function () {

+	        var node = this.createNode();

+	        var test;

+	        if (this.matchKeyword('default')) {

+	            this.nextToken();

+	            test = null;

+	        }

+	        else {

+	            this.expectKeyword('case');

+	            test = this.parseExpression();

+	        }

+	        this.expect(':');

+	        var consequent = [];

+	        while (true) {

+	            if (this.match('}') || this.matchKeyword('default') || this.matchKeyword('case')) {

+	                break;

+	            }

+	            consequent.push(this.parseStatementListItem());

+	        }

+	        return this.finalize(node, new Node.SwitchCase(test, consequent));

+	    };

+	    Parser.prototype.parseSwitchStatement = function () {

+	        var node = this.createNode();

+	        this.expectKeyword('switch');

+	        this.expect('(');

+	        var discriminant = this.parseExpression();

+	        this.expect(')');

+	        var previousInSwitch = this.context.inSwitch;

+	        this.context.inSwitch = true;

+	        var cases = [];

+	        var defaultFound = false;

+	        this.expect('{');

+	        while (true) {

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

+	                break;

+	            }

+	            var clause = this.parseSwitchCase();

+	            if (clause.test === null) {

+	                if (defaultFound) {

+	                    this.throwError(messages_1.Messages.MultipleDefaultsInSwitch);

+	                }

+	                defaultFound = true;

+	            }

+	            cases.push(clause);

+	        }

+	        this.expect('}');

+	        this.context.inSwitch = previousInSwitch;

+	        return this.finalize(node, new Node.SwitchStatement(discriminant, cases));

+	    };

+	    // https://tc39.github.io/ecma262/#sec-labelled-statements

+	    Parser.prototype.parseLabelledStatement = function () {

+	        var node = this.createNode();

+	        var expr = this.parseExpression();

+	        var statement;

+	        if ((expr.type === syntax_1.Syntax.Identifier) && this.match(':')) {

+	            this.nextToken();

+	            var id = expr;

+	            var key = '$' + id.name;

+	            if (Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) {

+	                this.throwError(messages_1.Messages.Redeclaration, 'Label', id.name);

+	            }

+	            this.context.labelSet[key] = true;

+	            var body = void 0;

+	            if (this.matchKeyword('class')) {

+	                this.tolerateUnexpectedToken(this.lookahead);

+	                body = this.parseClassDeclaration();

+	            }

+	            else if (this.matchKeyword('function')) {

+	                var token = this.lookahead;

+	                var declaration = this.parseFunctionDeclaration();

+	                if (this.context.strict) {

+	                    this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunction);

+	                }

+	                else if (declaration.generator) {

+	                    this.tolerateUnexpectedToken(token, messages_1.Messages.GeneratorInLegacyContext);

+	                }

+	                body = declaration;

+	            }

+	            else {

+	                body = this.parseStatement();

+	            }

+	            delete this.context.labelSet[key];

+	            statement = new Node.LabeledStatement(id, body);

+	        }

+	        else {

+	            this.consumeSemicolon();

+	            statement = new Node.ExpressionStatement(expr);

+	        }

+	        return this.finalize(node, statement);

+	    };

+	    // https://tc39.github.io/ecma262/#sec-throw-statement

+	    Parser.prototype.parseThrowStatement = function () {

+	        var node = this.createNode();

+	        this.expectKeyword('throw');

+	        if (this.hasLineTerminator) {

+	            this.throwError(messages_1.Messages.NewlineAfterThrow);

+	        }

+	        var argument = this.parseExpression();

+	        this.consumeSemicolon();

+	        return this.finalize(node, new Node.ThrowStatement(argument));

+	    };

+	    // https://tc39.github.io/ecma262/#sec-try-statement

+	    Parser.prototype.parseCatchClause = function () {

+	        var node = this.createNode();

+	        this.expectKeyword('catch');

+	        this.expect('(');

+	        if (this.match(')')) {

+	            this.throwUnexpectedToken(this.lookahead);

+	        }

+	        var params = [];

+	        var param = this.parsePattern(params);

+	        var paramMap = {};

+	        for (var i = 0; i < params.length; i++) {

+	            var key = '$' + params[i].value;

+	            if (Object.prototype.hasOwnProperty.call(paramMap, key)) {

+	                this.tolerateError(messages_1.Messages.DuplicateBinding, params[i].value);

+	            }

+	            paramMap[key] = true;

+	        }

+	        if (this.context.strict && param.type === syntax_1.Syntax.Identifier) {

+	            if (this.scanner.isRestrictedWord(param.name)) {

+	                this.tolerateError(messages_1.Messages.StrictCatchVariable);

+	            }

+	        }

+	        this.expect(')');

+	        var body = this.parseBlock();

+	        return this.finalize(node, new Node.CatchClause(param, body));

+	    };

+	    Parser.prototype.parseFinallyClause = function () {

+	        this.expectKeyword('finally');

+	        return this.parseBlock();

+	    };

+	    Parser.prototype.parseTryStatement = function () {

+	        var node = this.createNode();

+	        this.expectKeyword('try');

+	        var block = this.parseBlock();

+	        var handler = this.matchKeyword('catch') ? this.parseCatchClause() : null;

+	        var finalizer = this.matchKeyword('finally') ? this.parseFinallyClause() : null;

+	        if (!handler && !finalizer) {

+	            this.throwError(messages_1.Messages.NoCatchOrFinally);

+	        }

+	        return this.finalize(node, new Node.TryStatement(block, handler, finalizer));

+	    };

+	    // https://tc39.github.io/ecma262/#sec-debugger-statement

+	    Parser.prototype.parseDebuggerStatement = function () {

+	        var node = this.createNode();

+	        this.expectKeyword('debugger');

+	        this.consumeSemicolon();

+	        return this.finalize(node, new Node.DebuggerStatement());

+	    };

+	    // https://tc39.github.io/ecma262/#sec-ecmascript-language-statements-and-declarations

+	    Parser.prototype.parseStatement = function () {

+	        var statement;

+	        switch (this.lookahead.type) {

+	            case 1 /* BooleanLiteral */:

+	            case 5 /* NullLiteral */:

+	            case 6 /* NumericLiteral */:

+	            case 8 /* StringLiteral */:

+	            case 10 /* Template */:

+	            case 9 /* RegularExpression */:

+	                statement = this.parseExpressionStatement();

+	                break;

+	            case 7 /* Punctuator */:

+	                var value = this.lookahead.value;

+	                if (value === '{') {

+	                    statement = this.parseBlock();

+	                }

+	                else if (value === '(') {

+	                    statement = this.parseExpressionStatement();

+	                }

+	                else if (value === ';') {

+	                    statement = this.parseEmptyStatement();

+	                }

+	                else {

+	                    statement = this.parseExpressionStatement();

+	                }

+	                break;

+	            case 3 /* Identifier */:

+	                statement = this.matchAsyncFunction() ? this.parseFunctionDeclaration() : this.parseLabelledStatement();

+	                break;

+	            case 4 /* Keyword */:

+	                switch (this.lookahead.value) {

+	                    case 'break':

+	                        statement = this.parseBreakStatement();

+	                        break;

+	                    case 'continue':

+	                        statement = this.parseContinueStatement();

+	                        break;

+	                    case 'debugger':

+	                        statement = this.parseDebuggerStatement();

+	                        break;

+	                    case 'do':

+	                        statement = this.parseDoWhileStatement();

+	                        break;

+	                    case 'for':

+	                        statement = this.parseForStatement();

+	                        break;

+	                    case 'function':

+	                        statement = this.parseFunctionDeclaration();

+	                        break;

+	                    case 'if':

+	                        statement = this.parseIfStatement();

+	                        break;

+	                    case 'return':

+	                        statement = this.parseReturnStatement();

+	                        break;

+	                    case 'switch':

+	                        statement = this.parseSwitchStatement();

+	                        break;

+	                    case 'throw':

+	                        statement = this.parseThrowStatement();

+	                        break;

+	                    case 'try':

+	                        statement = this.parseTryStatement();

+	                        break;

+	                    case 'var':

+	                        statement = this.parseVariableStatement();

+	                        break;

+	                    case 'while':

+	                        statement = this.parseWhileStatement();

+	                        break;

+	                    case 'with':

+	                        statement = this.parseWithStatement();

+	                        break;

+	                    default:

+	                        statement = this.parseExpressionStatement();

+	                        break;

+	                }

+	                break;

+	            default:

+	                statement = this.throwUnexpectedToken(this.lookahead);

+	        }

+	        return statement;

+	    };

+	    // https://tc39.github.io/ecma262/#sec-function-definitions

+	    Parser.prototype.parseFunctionSourceElements = function () {

+	        var node = this.createNode();

+	        this.expect('{');

+	        var body = this.parseDirectivePrologues();

+	        var previousLabelSet = this.context.labelSet;

+	        var previousInIteration = this.context.inIteration;

+	        var previousInSwitch = this.context.inSwitch;

+	        var previousInFunctionBody = this.context.inFunctionBody;

+	        this.context.labelSet = {};

+	        this.context.inIteration = false;

+	        this.context.inSwitch = false;

+	        this.context.inFunctionBody = true;

+	        while (this.lookahead.type !== 2 /* EOF */) {

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

+	                break;

+	            }

+	            body.push(this.parseStatementListItem());

+	        }

+	        this.expect('}');

+	        this.context.labelSet = previousLabelSet;

+	        this.context.inIteration = previousInIteration;

+	        this.context.inSwitch = previousInSwitch;

+	        this.context.inFunctionBody = previousInFunctionBody;

+	        return this.finalize(node, new Node.BlockStatement(body));

+	    };

+	    Parser.prototype.validateParam = function (options, param, name) {

+	        var key = '$' + name;

+	        if (this.context.strict) {

+	            if (this.scanner.isRestrictedWord(name)) {

+	                options.stricted = param;

+	                options.message = messages_1.Messages.StrictParamName;

+	            }

+	            if (Object.prototype.hasOwnProperty.call(options.paramSet, key)) {

+	                options.stricted = param;

+	                options.message = messages_1.Messages.StrictParamDupe;

+	            }

+	        }

+	        else if (!options.firstRestricted) {

+	            if (this.scanner.isRestrictedWord(name)) {

+	                options.firstRestricted = param;

+	                options.message = messages_1.Messages.StrictParamName;

+	            }

+	            else if (this.scanner.isStrictModeReservedWord(name)) {

+	                options.firstRestricted = param;

+	                options.message = messages_1.Messages.StrictReservedWord;

+	            }

+	            else if (Object.prototype.hasOwnProperty.call(options.paramSet, key)) {

+	                options.stricted = param;

+	                options.message = messages_1.Messages.StrictParamDupe;

+	            }

+	        }

+	        /* istanbul ignore next */

+	        if (typeof Object.defineProperty === 'function') {

+	            Object.defineProperty(options.paramSet, key, { value: true, enumerable: true, writable: true, configurable: true });

+	        }

+	        else {

+	            options.paramSet[key] = true;

+	        }

+	    };

+	    Parser.prototype.parseRestElement = function (params) {

+	        var node = this.createNode();

+	        this.expect('...');

+	        var arg = this.parsePattern(params);

+	        if (this.match('=')) {

+	            this.throwError(messages_1.Messages.DefaultRestParameter);

+	        }

+	        if (!this.match(')')) {

+	            this.throwError(messages_1.Messages.ParameterAfterRestParameter);

+	        }

+	        return this.finalize(node, new Node.RestElement(arg));

+	    };

+	    Parser.prototype.parseFormalParameter = function (options) {

+	        var params = [];

+	        var param = this.match('...') ? this.parseRestElement(params) : this.parsePatternWithDefault(params);

+	        for (var i = 0; i < params.length; i++) {

+	            this.validateParam(options, params[i], params[i].value);

+	        }

+	        options.simple = options.simple && (param instanceof Node.Identifier);

+	        options.params.push(param);

+	    };

+	    Parser.prototype.parseFormalParameters = function (firstRestricted) {

+	        var options;

+	        options = {

+	            simple: true,

+	            params: [],

+	            firstRestricted: firstRestricted

+	        };

+	        this.expect('(');

+	        if (!this.match(')')) {

+	            options.paramSet = {};

+	            while (this.lookahead.type !== 2 /* EOF */) {

+	                this.parseFormalParameter(options);

+	                if (this.match(')')) {

+	                    break;

+	                }

+	                this.expect(',');

+	                if (this.match(')')) {

+	                    break;

+	                }

+	            }

+	        }

+	        this.expect(')');

+	        return {

+	            simple: options.simple,

+	            params: options.params,

+	            stricted: options.stricted,

+	            firstRestricted: options.firstRestricted,

+	            message: options.message

+	        };

+	    };

+	    Parser.prototype.matchAsyncFunction = function () {

+	        var match = this.matchContextualKeyword('async');

+	        if (match) {

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

+	            this.scanner.scanComments();

+	            var next = this.scanner.lex();

+	            this.scanner.restoreState(state);

+	            match = (state.lineNumber === next.lineNumber) && (next.type === 4 /* Keyword */) && (next.value === 'function');

+	        }

+	        return match;

+	    };

+	    Parser.prototype.parseFunctionDeclaration = function (identifierIsOptional) {

+	        var node = this.createNode();

+	        var isAsync = this.matchContextualKeyword('async');

+	        if (isAsync) {

+	            this.nextToken();

+	        }

+	        this.expectKeyword('function');

+	        var isGenerator = isAsync ? false : this.match('*');

+	        if (isGenerator) {

+	            this.nextToken();

+	        }

+	        var message;

+	        var id = null;

+	        var firstRestricted = null;

+	        if (!identifierIsOptional || !this.match('(')) {

+	            var token = this.lookahead;

+	            id = this.parseVariableIdentifier();

+	            if (this.context.strict) {

+	                if (this.scanner.isRestrictedWord(token.value)) {

+	                    this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunctionName);

+	                }

+	            }

+	            else {

+	                if (this.scanner.isRestrictedWord(token.value)) {

+	                    firstRestricted = token;

+	                    message = messages_1.Messages.StrictFunctionName;

+	                }

+	                else if (this.scanner.isStrictModeReservedWord(token.value)) {

+	                    firstRestricted = token;

+	                    message = messages_1.Messages.StrictReservedWord;

+	                }

+	            }

+	        }

+	        var previousAllowAwait = this.context.await;

+	        var previousAllowYield = this.context.allowYield;

+	        this.context.await = isAsync;

+	        this.context.allowYield = !isGenerator;

+	        var formalParameters = this.parseFormalParameters(firstRestricted);

+	        var params = formalParameters.params;

+	        var stricted = formalParameters.stricted;

+	        firstRestricted = formalParameters.firstRestricted;

+	        if (formalParameters.message) {

+	            message = formalParameters.message;

+	        }

+	        var previousStrict = this.context.strict;

+	        var previousAllowStrictDirective = this.context.allowStrictDirective;

+	        this.context.allowStrictDirective = formalParameters.simple;

+	        var body = this.parseFunctionSourceElements();

+	        if (this.context.strict && firstRestricted) {

+	            this.throwUnexpectedToken(firstRestricted, message);

+	        }

+	        if (this.context.strict && stricted) {

+	            this.tolerateUnexpectedToken(stricted, message);

+	        }

+	        this.context.strict = previousStrict;

+	        this.context.allowStrictDirective = previousAllowStrictDirective;

+	        this.context.await = previousAllowAwait;

+	        this.context.allowYield = previousAllowYield;

+	        return isAsync ? this.finalize(node, new Node.AsyncFunctionDeclaration(id, params, body)) :

+	            this.finalize(node, new Node.FunctionDeclaration(id, params, body, isGenerator));

+	    };

+	    Parser.prototype.parseFunctionExpression = function () {

+	        var node = this.createNode();

+	        var isAsync = this.matchContextualKeyword('async');

+	        if (isAsync) {

+	            this.nextToken();

+	        }

+	        this.expectKeyword('function');

+	        var isGenerator = isAsync ? false : this.match('*');

+	        if (isGenerator) {

+	            this.nextToken();

+	        }

+	        var message;

+	        var id = null;

+	        var firstRestricted;

+	        var previousAllowAwait = this.context.await;

+	        var previousAllowYield = this.context.allowYield;

+	        this.context.await = isAsync;

+	        this.context.allowYield = !isGenerator;

+	        if (!this.match('(')) {

+	            var token = this.lookahead;

+	            id = (!this.context.strict && !isGenerator && this.matchKeyword('yield')) ? this.parseIdentifierName() : this.parseVariableIdentifier();

+	            if (this.context.strict) {

+	                if (this.scanner.isRestrictedWord(token.value)) {

+	                    this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunctionName);

+	                }

+	            }

+	            else {

+	                if (this.scanner.isRestrictedWord(token.value)) {

+	                    firstRestricted = token;

+	                    message = messages_1.Messages.StrictFunctionName;

+	                }

+	                else if (this.scanner.isStrictModeReservedWord(token.value)) {

+	                    firstRestricted = token;

+	                    message = messages_1.Messages.StrictReservedWord;

+	                }

+	            }

+	        }

+	        var formalParameters = this.parseFormalParameters(firstRestricted);

+	        var params = formalParameters.params;

+	        var stricted = formalParameters.stricted;

+	        firstRestricted = formalParameters.firstRestricted;

+	        if (formalParameters.message) {

+	            message = formalParameters.message;

+	        }

+	        var previousStrict = this.context.strict;

+	        var previousAllowStrictDirective = this.context.allowStrictDirective;

+	        this.context.allowStrictDirective = formalParameters.simple;

+	        var body = this.parseFunctionSourceElements();

+	        if (this.context.strict && firstRestricted) {

+	            this.throwUnexpectedToken(firstRestricted, message);

+	        }

+	        if (this.context.strict && stricted) {

+	            this.tolerateUnexpectedToken(stricted, message);

+	        }

+	        this.context.strict = previousStrict;

+	        this.context.allowStrictDirective = previousAllowStrictDirective;

+	        this.context.await = previousAllowAwait;

+	        this.context.allowYield = previousAllowYield;

+	        return isAsync ? this.finalize(node, new Node.AsyncFunctionExpression(id, params, body)) :

+	            this.finalize(node, new Node.FunctionExpression(id, params, body, isGenerator));

+	    };

+	    // https://tc39.github.io/ecma262/#sec-directive-prologues-and-the-use-strict-directive

+	    Parser.prototype.parseDirective = function () {

+	        var token = this.lookahead;

+	        var node = this.createNode();

+	        var expr = this.parseExpression();

+	        var directive = (expr.type === syntax_1.Syntax.Literal) ? this.getTokenRaw(token).slice(1, -1) : null;

+	        this.consumeSemicolon();

+	        return this.finalize(node, directive ? new Node.Directive(expr, directive) : new Node.ExpressionStatement(expr));

+	    };

+	    Parser.prototype.parseDirectivePrologues = function () {

+	        var firstRestricted = null;

+	        var body = [];

+	        while (true) {

+	            var token = this.lookahead;

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

+	                break;

+	            }

+	            var statement = this.parseDirective();

+	            body.push(statement);

+	            var directive = statement.directive;

+	            if (typeof directive !== 'string') {

+	                break;

+	            }

+	            if (directive === 'use strict') {

+	                this.context.strict = true;

+	                if (firstRestricted) {

+	                    this.tolerateUnexpectedToken(firstRestricted, messages_1.Messages.StrictOctalLiteral);

+	                }

+	                if (!this.context.allowStrictDirective) {

+	                    this.tolerateUnexpectedToken(token, messages_1.Messages.IllegalLanguageModeDirective);

+	                }

+	            }

+	            else {

+	                if (!firstRestricted && token.octal) {

+	                    firstRestricted = token;

+	                }

+	            }

+	        }

+	        return body;

+	    };

+	    // https://tc39.github.io/ecma262/#sec-method-definitions

+	    Parser.prototype.qualifiedPropertyName = function (token) {

+	        switch (token.type) {

+	            case 3 /* Identifier */:

+	            case 8 /* StringLiteral */:

+	            case 1 /* BooleanLiteral */:

+	            case 5 /* NullLiteral */:

+	            case 6 /* NumericLiteral */:

+	            case 4 /* Keyword */:

+	                return true;

+	            case 7 /* Punctuator */:

+	                return token.value === '[';

+	            default:

+	                break;

+	        }

+	        return false;

+	    };

+	    Parser.prototype.parseGetterMethod = function () {

+	        var node = this.createNode();

+	        var isGenerator = false;

+	        var previousAllowYield = this.context.allowYield;

+	        this.context.allowYield = false;

+	        var formalParameters = this.parseFormalParameters();

+	        if (formalParameters.params.length > 0) {

+	            this.tolerateError(messages_1.Messages.BadGetterArity);

+	        }

+	        var method = this.parsePropertyMethod(formalParameters);

+	        this.context.allowYield = previousAllowYield;

+	        return this.finalize(node, new Node.FunctionExpression(null, formalParameters.params, method, isGenerator));

+	    };

+	    Parser.prototype.parseSetterMethod = function () {

+	        var node = this.createNode();

+	        var isGenerator = false;

+	        var previousAllowYield = this.context.allowYield;

+	        this.context.allowYield = false;

+	        var formalParameters = this.parseFormalParameters();

+	        if (formalParameters.params.length !== 1) {

+	            this.tolerateError(messages_1.Messages.BadSetterArity);

+	        }

+	        else if (formalParameters.params[0] instanceof Node.RestElement) {

+	            this.tolerateError(messages_1.Messages.BadSetterRestParameter);

+	        }

+	        var method = this.parsePropertyMethod(formalParameters);

+	        this.context.allowYield = previousAllowYield;

+	        return this.finalize(node, new Node.FunctionExpression(null, formalParameters.params, method, isGenerator));

+	    };

+	    Parser.prototype.parseGeneratorMethod = function () {

+	        var node = this.createNode();

+	        var isGenerator = true;

+	        var previousAllowYield = this.context.allowYield;

+	        this.context.allowYield = true;

+	        var params = this.parseFormalParameters();

+	        this.context.allowYield = false;

+	        var method = this.parsePropertyMethod(params);

+	        this.context.allowYield = previousAllowYield;

+	        return this.finalize(node, new Node.FunctionExpression(null, params.params, method, isGenerator));

+	    };

+	    // https://tc39.github.io/ecma262/#sec-generator-function-definitions

+	    Parser.prototype.isStartOfExpression = function () {

+	        var start = true;

+	        var value = this.lookahead.value;

+	        switch (this.lookahead.type) {

+	            case 7 /* Punctuator */:

+	                start = (value === '[') || (value === '(') || (value === '{') ||

+	                    (value === '+') || (value === '-') ||

+	                    (value === '!') || (value === '~') ||

+	                    (value === '++') || (value === '--') ||

+	                    (value === '/') || (value === '/='); // regular expression literal

+	                break;

+	            case 4 /* Keyword */:

+	                start = (value === 'class') || (value === 'delete') ||

+	                    (value === 'function') || (value === 'let') || (value === 'new') ||

+	                    (value === 'super') || (value === 'this') || (value === 'typeof') ||

+	                    (value === 'void') || (value === 'yield');

+	                break;

+	            default:

+	                break;

+	        }

+	        return start;

+	    };

+	    Parser.prototype.parseYieldExpression = function () {

+	        var node = this.createNode();

+	        this.expectKeyword('yield');

+	        var argument = null;

+	        var delegate = false;

+	        if (!this.hasLineTerminator) {

+	            var previousAllowYield = this.context.allowYield;

+	            this.context.allowYield = false;

+	            delegate = this.match('*');

+	            if (delegate) {

+	                this.nextToken();

+	                argument = this.parseAssignmentExpression();

+	            }

+	            else if (this.isStartOfExpression()) {

+	                argument = this.parseAssignmentExpression();

+	            }

+	            this.context.allowYield = previousAllowYield;

+	        }

+	        return this.finalize(node, new Node.YieldExpression(argument, delegate));

+	    };

+	    // https://tc39.github.io/ecma262/#sec-class-definitions

+	    Parser.prototype.parseClassElement = function (hasConstructor) {

+	        var token = this.lookahead;

+	        var node = this.createNode();

+	        var kind = '';

+	        var key = null;

+	        var value = null;

+	        var computed = false;

+	        var method = false;

+	        var isStatic = false;

+	        var isAsync = false;

+	        if (this.match('*')) {

+	            this.nextToken();

+	        }

+	        else {

+	            computed = this.match('[');

+	            key = this.parseObjectPropertyKey();

+	            var id = key;

+	            if (id.name === 'static' && (this.qualifiedPropertyName(this.lookahead) || this.match('*'))) {

+	                token = this.lookahead;

+	                isStatic = true;

+	                computed = this.match('[');

+	                if (this.match('*')) {

+	                    this.nextToken();

+	                }

+	                else {

+	                    key = this.parseObjectPropertyKey();

+	                }

+	            }

+	            if ((token.type === 3 /* Identifier */) && !this.hasLineTerminator && (token.value === 'async')) {

+	                var punctuator = this.lookahead.value;

+	                if (punctuator !== ':' && punctuator !== '(' && punctuator !== '*') {

+	                    isAsync = true;

+	                    token = this.lookahead;

+	                    key = this.parseObjectPropertyKey();

+	                    if (token.type === 3 /* Identifier */) {

+	                        if (token.value === 'get' || token.value === 'set') {

+	                            this.tolerateUnexpectedToken(token);

+	                        }

+	                        else if (token.value === 'constructor') {

+	                            this.tolerateUnexpectedToken(token, messages_1.Messages.ConstructorIsAsync);

+	                        }

+	                    }

+	                }

+	            }

+	        }

+	        var lookaheadPropertyKey = this.qualifiedPropertyName(this.lookahead);

+	        if (token.type === 3 /* Identifier */) {

+	            if (token.value === 'get' && lookaheadPropertyKey) {

+	                kind = 'get';

+	                computed = this.match('[');

+	                key = this.parseObjectPropertyKey();

+	                this.context.allowYield = false;

+	                value = this.parseGetterMethod();

+	            }

+	            else if (token.value === 'set' && lookaheadPropertyKey) {

+	                kind = 'set';

+	                computed = this.match('[');

+	                key = this.parseObjectPropertyKey();

+	                value = this.parseSetterMethod();

+	            }

+	        }

+	        else if (token.type === 7 /* Punctuator */ && token.value === '*' && lookaheadPropertyKey) {

+	            kind = 'init';

+	            computed = this.match('[');

+	            key = this.parseObjectPropertyKey();

+	            value = this.parseGeneratorMethod();

+	            method = true;

+	        }

+	        if (!kind && key && this.match('(')) {

+	            kind = 'init';

+	            value = isAsync ? this.parsePropertyMethodAsyncFunction() : this.parsePropertyMethodFunction();

+	            method = true;

+	        }

+	        if (!kind) {

+	            this.throwUnexpectedToken(this.lookahead);

+	        }

+	        if (kind === 'init') {

+	            kind = 'method';

+	        }

+	        if (!computed) {

+	            if (isStatic && this.isPropertyKey(key, 'prototype')) {

+	                this.throwUnexpectedToken(token, messages_1.Messages.StaticPrototype);

+	            }

+	            if (!isStatic && this.isPropertyKey(key, 'constructor')) {

+	                if (kind !== 'method' || !method || (value && value.generator)) {

+	                    this.throwUnexpectedToken(token, messages_1.Messages.ConstructorSpecialMethod);

+	                }

+	                if (hasConstructor.value) {

+	                    this.throwUnexpectedToken(token, messages_1.Messages.DuplicateConstructor);

+	                }

+	                else {

+	                    hasConstructor.value = true;

+	                }

+	                kind = 'constructor';

+	            }

+	        }

+	        return this.finalize(node, new Node.MethodDefinition(key, computed, value, kind, isStatic));

+	    };

+	    Parser.prototype.parseClassElementList = function () {

+	        var body = [];

+	        var hasConstructor = { value: false };

+	        this.expect('{');

+	        while (!this.match('}')) {

+	            if (this.match(';')) {

+	                this.nextToken();

+	            }

+	            else {

+	                body.push(this.parseClassElement(hasConstructor));

+	            }

+	        }

+	        this.expect('}');

+	        return body;

+	    };

+	    Parser.prototype.parseClassBody = function () {

+	        var node = this.createNode();

+	        var elementList = this.parseClassElementList();

+	        return this.finalize(node, new Node.ClassBody(elementList));

+	    };

+	    Parser.prototype.parseClassDeclaration = function (identifierIsOptional) {

+	        var node = this.createNode();

+	        var previousStrict = this.context.strict;

+	        this.context.strict = true;

+	        this.expectKeyword('class');

+	        var id = (identifierIsOptional && (this.lookahead.type !== 3 /* Identifier */)) ? null : this.parseVariableIdentifier();

+	        var superClass = null;

+	        if (this.matchKeyword('extends')) {

+	            this.nextToken();

+	            superClass = this.isolateCoverGrammar(this.parseLeftHandSideExpressionAllowCall);

+	        }

+	        var classBody = this.parseClassBody();

+	        this.context.strict = previousStrict;

+	        return this.finalize(node, new Node.ClassDeclaration(id, superClass, classBody));

+	    };

+	    Parser.prototype.parseClassExpression = function () {

+	        var node = this.createNode();

+	        var previousStrict = this.context.strict;

+	        this.context.strict = true;

+	        this.expectKeyword('class');

+	        var id = (this.lookahead.type === 3 /* Identifier */) ? this.parseVariableIdentifier() : null;

+	        var superClass = null;

+	        if (this.matchKeyword('extends')) {

+	            this.nextToken();

+	            superClass = this.isolateCoverGrammar(this.parseLeftHandSideExpressionAllowCall);

+	        }

+	        var classBody = this.parseClassBody();

+	        this.context.strict = previousStrict;

+	        return this.finalize(node, new Node.ClassExpression(id, superClass, classBody));

+	    };

+	    // https://tc39.github.io/ecma262/#sec-scripts

+	    // https://tc39.github.io/ecma262/#sec-modules

+	    Parser.prototype.parseModule = function () {

+	        this.context.strict = true;

+	        this.context.isModule = true;

+	        var node = this.createNode();

+	        var body = this.parseDirectivePrologues();

+	        while (this.lookahead.type !== 2 /* EOF */) {

+	            body.push(this.parseStatementListItem());

+	        }

+	        return this.finalize(node, new Node.Module(body));

+	    };

+	    Parser.prototype.parseScript = function () {

+	        var node = this.createNode();

+	        var body = this.parseDirectivePrologues();

+	        while (this.lookahead.type !== 2 /* EOF */) {

+	            body.push(this.parseStatementListItem());

+	        }

+	        return this.finalize(node, new Node.Script(body));

+	    };

+	    // https://tc39.github.io/ecma262/#sec-imports

+	    Parser.prototype.parseModuleSpecifier = function () {

+	        var node = this.createNode();

+	        if (this.lookahead.type !== 8 /* StringLiteral */) {

+	            this.throwError(messages_1.Messages.InvalidModuleSpecifier);

+	        }

+	        var token = this.nextToken();

+	        var raw = this.getTokenRaw(token);

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

+	    };

+	    // import {<foo as bar>} ...;

+	    Parser.prototype.parseImportSpecifier = function () {

+	        var node = this.createNode();

+	        var imported;

+	        var local;

+	        if (this.lookahead.type === 3 /* Identifier */) {

+	            imported = this.parseVariableIdentifier();

+	            local = imported;

+	            if (this.matchContextualKeyword('as')) {

+	                this.nextToken();

+	                local = this.parseVariableIdentifier();

+	            }

+	        }

+	        else {

+	            imported = this.parseIdentifierName();

+	            local = imported;

+	            if (this.matchContextualKeyword('as')) {

+	                this.nextToken();

+	                local = this.parseVariableIdentifier();

+	            }

+	            else {

+	                this.throwUnexpectedToken(this.nextToken());

+	            }

+	        }

+	        return this.finalize(node, new Node.ImportSpecifier(local, imported));

+	    };

+	    // {foo, bar as bas}

+	    Parser.prototype.parseNamedImports = function () {

+	        this.expect('{');

+	        var specifiers = [];

+	        while (!this.match('}')) {

+	            specifiers.push(this.parseImportSpecifier());

+	            if (!this.match('}')) {

+	                this.expect(',');

+	            }

+	        }

+	        this.expect('}');

+	        return specifiers;

+	    };

+	    // import <foo> ...;

+	    Parser.prototype.parseImportDefaultSpecifier = function () {

+	        var node = this.createNode();

+	        var local = this.parseIdentifierName();

+	        return this.finalize(node, new Node.ImportDefaultSpecifier(local));

+	    };

+	    // import <* as foo> ...;

+	    Parser.prototype.parseImportNamespaceSpecifier = function () {

+	        var node = this.createNode();

+	        this.expect('*');

+	        if (!this.matchContextualKeyword('as')) {

+	            this.throwError(messages_1.Messages.NoAsAfterImportNamespace);

+	        }

+	        this.nextToken();

+	        var local = this.parseIdentifierName();

+	        return this.finalize(node, new Node.ImportNamespaceSpecifier(local));

+	    };

+	    Parser.prototype.parseImportDeclaration = function () {

+	        if (this.context.inFunctionBody) {

+	            this.throwError(messages_1.Messages.IllegalImportDeclaration);

+	        }

+	        var node = this.createNode();

+	        this.expectKeyword('import');

+	        var src;

+	        var specifiers = [];

+	        if (this.lookahead.type === 8 /* StringLiteral */) {

+	            // import 'foo';

+	            src = this.parseModuleSpecifier();

+	        }

+	        else {

+	            if (this.match('{')) {

+	                // import {bar}

+	                specifiers = specifiers.concat(this.parseNamedImports());

+	            }

+	            else if (this.match('*')) {

+	                // import * as foo

+	                specifiers.push(this.parseImportNamespaceSpecifier());

+	            }

+	            else if (this.isIdentifierName(this.lookahead) && !this.matchKeyword('default')) {

+	                // import foo

+	                specifiers.push(this.parseImportDefaultSpecifier());

+	                if (this.match(',')) {

+	                    this.nextToken();

+	                    if (this.match('*')) {

+	                        // import foo, * as foo

+	                        specifiers.push(this.parseImportNamespaceSpecifier());

+	                    }

+	                    else if (this.match('{')) {

+	                        // import foo, {bar}

+	                        specifiers = specifiers.concat(this.parseNamedImports());

+	                    }

+	                    else {

+	                        this.throwUnexpectedToken(this.lookahead);

+	                    }

+	                }

+	            }

+	            else {

+	                this.throwUnexpectedToken(this.nextToken());

+	            }

+	            if (!this.matchContextualKeyword('from')) {

+	                var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;

+	                this.throwError(message, this.lookahead.value);

+	            }

+	            this.nextToken();

+	            src = this.parseModuleSpecifier();

+	        }

+	        this.consumeSemicolon();

+	        return this.finalize(node, new Node.ImportDeclaration(specifiers, src));

+	    };

+	    // https://tc39.github.io/ecma262/#sec-exports

+	    Parser.prototype.parseExportSpecifier = function () {

+	        var node = this.createNode();

+	        var local = this.parseIdentifierName();

+	        var exported = local;

+	        if (this.matchContextualKeyword('as')) {

+	            this.nextToken();

+	            exported = this.parseIdentifierName();

+	        }

+	        return this.finalize(node, new Node.ExportSpecifier(local, exported));

+	    };

+	    Parser.prototype.parseExportDeclaration = function () {

+	        if (this.context.inFunctionBody) {

+	            this.throwError(messages_1.Messages.IllegalExportDeclaration);

+	        }

+	        var node = this.createNode();

+	        this.expectKeyword('export');

+	        var exportDeclaration;

+	        if (this.matchKeyword('default')) {

+	            // export default ...

+	            this.nextToken();

+	            if (this.matchKeyword('function')) {

+	                // export default function foo () {}

+	                // export default function () {}

+	                var declaration = this.parseFunctionDeclaration(true);

+	                exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));

+	            }

+	            else if (this.matchKeyword('class')) {

+	                // export default class foo {}

+	                var declaration = this.parseClassDeclaration(true);

+	                exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));

+	            }

+	            else if (this.matchContextualKeyword('async')) {

+	                // export default async function f () {}

+	                // export default async function () {}

+	                // export default async x => x

+	                var declaration = this.matchAsyncFunction() ? this.parseFunctionDeclaration(true) : this.parseAssignmentExpression();

+	                exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));

+	            }

+	            else {

+	                if (this.matchContextualKeyword('from')) {

+	                    this.throwError(messages_1.Messages.UnexpectedToken, this.lookahead.value);

+	                }

+	                // export default {};

+	                // export default [];

+	                // export default (1 + 2);

+	                var declaration = this.match('{') ? this.parseObjectInitializer() :

+	                    this.match('[') ? this.parseArrayInitializer() : this.parseAssignmentExpression();

+	                this.consumeSemicolon();

+	                exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));

+	            }

+	        }

+	        else if (this.match('*')) {

+	            // export * from 'foo';

+	            this.nextToken();

+	            if (!this.matchContextualKeyword('from')) {

+	                var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;

+	                this.throwError(message, this.lookahead.value);

+	            }

+	            this.nextToken();

+	            var src = this.parseModuleSpecifier();

+	            this.consumeSemicolon();

+	            exportDeclaration = this.finalize(node, new Node.ExportAllDeclaration(src));

+	        }

+	        else if (this.lookahead.type === 4 /* Keyword */) {

+	            // export var f = 1;

+	            var declaration = void 0;

+	            switch (this.lookahead.value) {

+	                case 'let':

+	                case 'const':

+	                    declaration = this.parseLexicalDeclaration({ inFor: false });

+	                    break;

+	                case 'var':

+	                case 'class':

+	                case 'function':

+	                    declaration = this.parseStatementListItem();

+	                    break;

+	                default:

+	                    this.throwUnexpectedToken(this.lookahead);

+	            }

+	            exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(declaration, [], null));

+	        }

+	        else if (this.matchAsyncFunction()) {

+	            var declaration = this.parseFunctionDeclaration();

+	            exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(declaration, [], null));

+	        }

+	        else {

+	            var specifiers = [];

+	            var source = null;

+	            var isExportFromIdentifier = false;

+	            this.expect('{');

+	            while (!this.match('}')) {

+	                isExportFromIdentifier = isExportFromIdentifier || this.matchKeyword('default');

+	                specifiers.push(this.parseExportSpecifier());

+	                if (!this.match('}')) {

+	                    this.expect(',');

+	                }

+	            }

+	            this.expect('}');

+	            if (this.matchContextualKeyword('from')) {

+	                // export {default} from 'foo';

+	                // export {foo} from 'foo';

+	                this.nextToken();

+	                source = this.parseModuleSpecifier();

+	                this.consumeSemicolon();

+	            }

+	            else if (isExportFromIdentifier) {

+	                // export {default}; // missing fromClause

+	                var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;

+	                this.throwError(message, this.lookahead.value);

+	            }

+	            else {

+	                // export {foo};

+	                this.consumeSemicolon();

+	            }

+	            exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(null, specifiers, source));

+	        }

+	        return exportDeclaration;

+	    };

+	    return Parser;

+	}());

+	exports.Parser = Parser;

+
+
+/***/ },
+/* 9 */
+/***/ function(module, exports) {
+
+	"use strict";

+	// Ensure the condition is true, otherwise throw an error.

+	// This is only to have a better contract semantic, i.e. another safety net

+	// to catch a logic error. The condition shall be fulfilled in normal case.

+	// Do NOT use this to enforce a certain condition on any user input.

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

+	function assert(condition, message) {

+	    /* istanbul ignore if */

+	    if (!condition) {

+	        throw new Error('ASSERT: ' + message);

+	    }

+	}

+	exports.assert = assert;

+
+
+/***/ },
+/* 10 */
+/***/ function(module, exports) {
+
+	"use strict";

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

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

+	var ErrorHandler = (function () {

+	    function ErrorHandler() {

+	        this.errors = [];

+	        this.tolerant = false;

+	    }

+	    ErrorHandler.prototype.recordError = function (error) {

+	        this.errors.push(error);

+	    };

+	    ErrorHandler.prototype.tolerate = function (error) {

+	        if (this.tolerant) {

+	            this.recordError(error);

+	        }

+	        else {

+	            throw error;

+	        }

+	    };

+	    ErrorHandler.prototype.constructError = function (msg, column) {

+	        var error = new Error(msg);

+	        try {

+	            throw error;

+	        }

+	        catch (base) {

+	            /* istanbul ignore else */

+	            if (Object.create && Object.defineProperty) {

+	                error = Object.create(base);

+	                Object.defineProperty(error, 'column', { value: column });

+	            }

+	        }

+	        /* istanbul ignore next */

+	        return error;

+	    };

+	    ErrorHandler.prototype.createError = function (index, line, col, description) {

+	        var msg = 'Line ' + line + ': ' + description;

+	        var error = this.constructError(msg, col);

+	        error.index = index;

+	        error.lineNumber = line;

+	        error.description = description;

+	        return error;

+	    };

+	    ErrorHandler.prototype.throwError = function (index, line, col, description) {

+	        throw this.createError(index, line, col, description);

+	    };

+	    ErrorHandler.prototype.tolerateError = function (index, line, col, description) {

+	        var error = this.createError(index, line, col, description);

+	        if (this.tolerant) {

+	            this.recordError(error);

+	        }

+	        else {

+	            throw error;

+	        }

+	    };

+	    return ErrorHandler;

+	}());

+	exports.ErrorHandler = ErrorHandler;

+
+
+/***/ },
+/* 11 */
+/***/ function(module, exports) {
+
+	"use strict";

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

+	// Error messages should be identical to V8.

+	exports.Messages = {

+	    BadGetterArity: 'Getter must not have any formal parameters',

+	    BadSetterArity: 'Setter must have exactly one formal parameter',

+	    BadSetterRestParameter: 'Setter function argument must not be a rest parameter',

+	    ConstructorIsAsync: 'Class constructor may not be an async method',

+	    ConstructorSpecialMethod: 'Class constructor may not be an accessor',

+	    DeclarationMissingInitializer: 'Missing initializer in %0 declaration',

+	    DefaultRestParameter: 'Unexpected token =',

+	    DuplicateBinding: 'Duplicate binding %0',

+	    DuplicateConstructor: 'A class may only have one constructor',

+	    DuplicateProtoProperty: 'Duplicate __proto__ fields are not allowed in object literals',

+	    ForInOfLoopInitializer: '%0 loop variable declaration may not have an initializer',

+	    GeneratorInLegacyContext: 'Generator declarations are not allowed in legacy contexts',

+	    IllegalBreak: 'Illegal break statement',

+	    IllegalContinue: 'Illegal continue statement',

+	    IllegalExportDeclaration: 'Unexpected token',

+	    IllegalImportDeclaration: 'Unexpected token',

+	    IllegalLanguageModeDirective: 'Illegal \'use strict\' directive in function with non-simple parameter list',

+	    IllegalReturn: 'Illegal return statement',

+	    InvalidEscapedReservedWord: 'Keyword must not contain escaped characters',

+	    InvalidHexEscapeSequence: 'Invalid hexadecimal escape sequence',

+	    InvalidLHSInAssignment: 'Invalid left-hand side in assignment',

+	    InvalidLHSInForIn: 'Invalid left-hand side in for-in',

+	    InvalidLHSInForLoop: 'Invalid left-hand side in for-loop',

+	    InvalidModuleSpecifier: 'Unexpected token',

+	    InvalidRegExp: 'Invalid regular expression',

+	    LetInLexicalBinding: 'let is disallowed as a lexically bound name',

+	    MissingFromClause: 'Unexpected token',

+	    MultipleDefaultsInSwitch: 'More than one default clause in switch statement',

+	    NewlineAfterThrow: 'Illegal newline after throw',

+	    NoAsAfterImportNamespace: 'Unexpected token',

+	    NoCatchOrFinally: 'Missing catch or finally after try',

+	    ParameterAfterRestParameter: 'Rest parameter must be last formal parameter',

+	    Redeclaration: '%0 \'%1\' has already been declared',

+	    StaticPrototype: 'Classes may not have static property named prototype',

+	    StrictCatchVariable: 'Catch variable may not be eval or arguments in strict mode',

+	    StrictDelete: 'Delete of an unqualified identifier in strict mode.',

+	    StrictFunction: 'In strict mode code, functions can only be declared at top level or inside a block',

+	    StrictFunctionName: 'Function name may not be eval or arguments in strict mode',

+	    StrictLHSAssignment: 'Assignment to eval or arguments is not allowed in strict mode',

+	    StrictLHSPostfix: 'Postfix increment/decrement may not have eval or arguments operand in strict mode',

+	    StrictLHSPrefix: 'Prefix increment/decrement may not have eval or arguments operand in strict mode',

+	    StrictModeWith: 'Strict mode code may not include a with statement',

+	    StrictOctalLiteral: 'Octal literals are not allowed in strict mode.',

+	    StrictParamDupe: 'Strict mode function may not have duplicate parameter names',

+	    StrictParamName: 'Parameter name eval or arguments is not allowed in strict mode',

+	    StrictReservedWord: 'Use of future reserved word in strict mode',

+	    StrictVarName: 'Variable name may not be eval or arguments in strict mode',

+	    TemplateOctalLiteral: 'Octal literals are not allowed in template strings.',

+	    UnexpectedEOS: 'Unexpected end of input',

+	    UnexpectedIdentifier: 'Unexpected identifier',

+	    UnexpectedNumber: 'Unexpected number',

+	    UnexpectedReserved: 'Unexpected reserved word',

+	    UnexpectedString: 'Unexpected string',

+	    UnexpectedTemplate: 'Unexpected quasi %0',

+	    UnexpectedToken: 'Unexpected token %0',

+	    UnexpectedTokenIllegal: 'Unexpected token ILLEGAL',

+	    UnknownLabel: 'Undefined label \'%0\'',

+	    UnterminatedRegExp: 'Invalid regular expression: missing /'

+	};

+
+
+/***/ },
+/* 12 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";

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

+	var assert_1 = __webpack_require__(9);

+	var character_1 = __webpack_require__(4);

+	var messages_1 = __webpack_require__(11);

+	function hexValue(ch) {

+	    return '0123456789abcdef'.indexOf(ch.toLowerCase());

+	}

+	function octalValue(ch) {

+	    return '01234567'.indexOf(ch);

+	}

+	var Scanner = (function () {

+	    function Scanner(code, handler) {

+	        this.source = code;

+	        this.errorHandler = handler;

+	        this.trackComment = false;

+	        this.length = code.length;

+	        this.index = 0;

+	        this.lineNumber = (code.length > 0) ? 1 : 0;

+	        this.lineStart = 0;

+	        this.curlyStack = [];

+	    }

+	    Scanner.prototype.saveState = function () {

+	        return {

+	            index: this.index,

+	            lineNumber: this.lineNumber,

+	            lineStart: this.lineStart

+	        };

+	    };

+	    Scanner.prototype.restoreState = function (state) {

+	        this.index = state.index;

+	        this.lineNumber = state.lineNumber;

+	        this.lineStart = state.lineStart;

+	    };

+	    Scanner.prototype.eof = function () {

+	        return this.index >= this.length;

+	    };

+	    Scanner.prototype.throwUnexpectedToken = function (message) {

+	        if (message === void 0) { message = messages_1.Messages.UnexpectedTokenIllegal; }

+	        return this.errorHandler.throwError(this.index, this.lineNumber, this.index - this.lineStart + 1, message);

+	    };

+	    Scanner.prototype.tolerateUnexpectedToken = function (message) {

+	        if (message === void 0) { message = messages_1.Messages.UnexpectedTokenIllegal; }

+	        this.errorHandler.tolerateError(this.index, this.lineNumber, this.index - this.lineStart + 1, message);

+	    };

+	    // https://tc39.github.io/ecma262/#sec-comments

+	    Scanner.prototype.skipSingleLineComment = function (offset) {

+	        var comments = [];

+	        var start, loc;

+	        if (this.trackComment) {

+	            comments = [];

+	            start = this.index - offset;

+	            loc = {

+	                start: {

+	                    line: this.lineNumber,

+	                    column: this.index - this.lineStart - offset

+	                },

+	                end: {}

+	            };

+	        }

+	        while (!this.eof()) {

+	            var ch = this.source.charCodeAt(this.index);

+	            ++this.index;

+	            if (character_1.Character.isLineTerminator(ch)) {

+	                if (this.trackComment) {

+	                    loc.end = {

+	                        line: this.lineNumber,

+	                        column: this.index - this.lineStart - 1

+	                    };

+	                    var entry = {

+	                        multiLine: false,

+	                        slice: [start + offset, this.index - 1],

+	                        range: [start, this.index - 1],

+	                        loc: loc

+	                    };

+	                    comments.push(entry);

+	                }

+	                if (ch === 13 && this.source.charCodeAt(this.index) === 10) {

+	                    ++this.index;

+	                }

+	                ++this.lineNumber;

+	                this.lineStart = this.index;

+	                return comments;

+	            }

+	        }

+	        if (this.trackComment) {

+	            loc.end = {

+	                line: this.lineNumber,

+	                column: this.index - this.lineStart

+	            };

+	            var entry = {

+	                multiLine: false,

+	                slice: [start + offset, this.index],

+	                range: [start, this.index],

+	                loc: loc

+	            };

+	            comments.push(entry);

+	        }

+	        return comments;

+	    };

+	    Scanner.prototype.skipMultiLineComment = function () {

+	        var comments = [];

+	        var start, loc;

+	        if (this.trackComment) {

+	            comments = [];

+	            start = this.index - 2;

+	            loc = {

+	                start: {

+	                    line: this.lineNumber,

+	                    column: this.index - this.lineStart - 2

+	                },

+	                end: {}

+	            };

+	        }

+	        while (!this.eof()) {

+	            var ch = this.source.charCodeAt(this.index);

+	            if (character_1.Character.isLineTerminator(ch)) {

+	                if (ch === 0x0D && this.source.charCodeAt(this.index + 1) === 0x0A) {

+	                    ++this.index;

+	                }

+	                ++this.lineNumber;

+	                ++this.index;

+	                this.lineStart = this.index;

+	            }

+	            else if (ch === 0x2A) {

+	                // Block comment ends with '*/'.

+	                if (this.source.charCodeAt(this.index + 1) === 0x2F) {

+	                    this.index += 2;

+	                    if (this.trackComment) {

+	                        loc.end = {

+	                            line: this.lineNumber,

+	                            column: this.index - this.lineStart

+	                        };

+	                        var entry = {

+	                            multiLine: true,

+	                            slice: [start + 2, this.index - 2],

+	                            range: [start, this.index],

+	                            loc: loc

+	                        };

+	                        comments.push(entry);

+	                    }

+	                    return comments;

+	                }

+	                ++this.index;

+	            }

+	            else {

+	                ++this.index;

+	            }

+	        }

+	        // Ran off the end of the file - the whole thing is a comment

+	        if (this.trackComment) {

+	            loc.end = {

+	                line: this.lineNumber,

+	                column: this.index - this.lineStart

+	            };

+	            var entry = {

+	                multiLine: true,

+	                slice: [start + 2, this.index],

+	                range: [start, this.index],

+	                loc: loc

+	            };

+	            comments.push(entry);

+	        }

+	        this.tolerateUnexpectedToken();

+	        return comments;

+	    };

+	    Scanner.prototype.scanComments = function () {

+	        var comments;

+	        if (this.trackComment) {

+	            comments = [];

+	        }

+	        var start = (this.index === 0);

+	        while (!this.eof()) {

+	            var ch = this.source.charCodeAt(this.index);

+	            if (character_1.Character.isWhiteSpace(ch)) {

+	                ++this.index;

+	            }

+	            else if (character_1.Character.isLineTerminator(ch)) {

+	                ++this.index;

+	                if (ch === 0x0D && this.source.charCodeAt(this.index) === 0x0A) {

+	                    ++this.index;

+	                }

+	                ++this.lineNumber;

+	                this.lineStart = this.index;

+	                start = true;

+	            }

+	            else if (ch === 0x2F) {

+	                ch = this.source.charCodeAt(this.index + 1);

+	                if (ch === 0x2F) {

+	                    this.index += 2;

+	                    var comment = this.skipSingleLineComment(2);

+	                    if (this.trackComment) {

+	                        comments = comments.concat(comment);

+	                    }

+	                    start = true;

+	                }

+	                else if (ch === 0x2A) {

+	                    this.index += 2;

+	                    var comment = this.skipMultiLineComment();

+	                    if (this.trackComment) {

+	                        comments = comments.concat(comment);

+	                    }

+	                }

+	                else {

+	                    break;

+	                }

+	            }

+	            else if (start && ch === 0x2D) {

+	                // U+003E is '>'

+	                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) {

+	                        comments = comments.concat(comment);

+	                    }

+	                }

+	                else {

+	                    break;

+	                }

+	            }

+	            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) {

+	                        comments = comments.concat(comment);

+	                    }

+	                }

+	                else {

+	                    break;

+	                }

+	            }

+	            else {

+	                break;

+	            }

+	        }

+	        return comments;

+	    };

+	    // https://tc39.github.io/ecma262/#sec-future-reserved-words

+	    Scanner.prototype.isFutureReservedWord = function (id) {

+	        switch (id) {

+	            case 'enum':

+	            case 'export':

+	            case 'import':

+	            case 'super':

+	                return true;

+	            default:

+	                return false;

+	        }

+	    };

+	    Scanner.prototype.isStrictModeReservedWord = function (id) {

+	        switch (id) {

+	            case 'implements':

+	            case 'interface':

+	            case 'package':

+	            case 'private':

+	            case 'protected':

+	            case 'public':

+	            case 'static':

+	            case 'yield':

+	            case 'let':

+	                return true;

+	            default:

+	                return false;

+	        }

+	    };

+	    Scanner.prototype.isRestrictedWord = function (id) {

+	        return id === 'eval' || id === 'arguments';

+	    };

+	    // https://tc39.github.io/ecma262/#sec-keywords

+	    Scanner.prototype.isKeyword = function (id) {

+	        switch (id.length) {

+	            case 2:

+	                return (id === 'if') || (id === 'in') || (id === 'do');

+	            case 3:

+	                return (id === 'var') || (id === 'for') || (id === 'new') ||

+	                    (id === 'try') || (id === 'let');

+	            case 4:

+	                return (id === 'this') || (id === 'else') || (id === 'case') ||

+	                    (id === 'void') || (id === 'with') || (id === 'enum');

+	            case 5:

+	                return (id === 'while') || (id === 'break') || (id === 'catch') ||

+	                    (id === 'throw') || (id === 'const') || (id === 'yield') ||

+	                    (id === 'class') || (id === 'super');

+	            case 6:

+	                return (id === 'return') || (id === 'typeof') || (id === 'delete') ||

+	                    (id === 'switch') || (id === 'export') || (id === 'import');

+	            case 7:

+	                return (id === 'default') || (id === 'finally') || (id === 'extends');

+	            case 8:

+	                return (id === 'function') || (id === 'continue') || (id === 'debugger');

+	            case 10:

+	                return (id === 'instanceof');

+	            default:

+	                return false;

+	        }

+	    };

+	    Scanner.prototype.codePointAt = function (i) {

+	        var cp = this.source.charCodeAt(i);

+	        if (cp >= 0xD800 && cp <= 0xDBFF) {

+	            var second = this.source.charCodeAt(i + 1);

+	            if (second >= 0xDC00 && second <= 0xDFFF) {

+	                var first = cp;

+	                cp = (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;

+	            }

+	        }

+	        return cp;

+	    };

+	    Scanner.prototype.scanHexEscape = function (prefix) {

+	        var len = (prefix === 'u') ? 4 : 2;

+	        var code = 0;

+	        for (var i = 0; i < len; ++i) {

+	            if (!this.eof() && character_1.Character.isHexDigit(this.source.charCodeAt(this.index))) {

+	                code = code * 16 + hexValue(this.source[this.index++]);

+	            }

+	            else {

+	                return null;

+	            }

+	        }

+	        return String.fromCharCode(code);

+	    };

+	    Scanner.prototype.scanUnicodeCodePointEscape = function () {

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

+	        var code = 0;

+	        // At least, one hex digit is required.

+	        if (ch === '}') {

+	            this.throwUnexpectedToken();

+	        }

+	        while (!this.eof()) {

+	            ch = this.source[this.index++];

+	            if (!character_1.Character.isHexDigit(ch.charCodeAt(0))) {

+	                break;

+	            }

+	            code = code * 16 + hexValue(ch);

+	        }

+	        if (code > 0x10FFFF || ch !== '}') {

+	            this.throwUnexpectedToken();

+	        }

+	        return character_1.Character.fromCodePoint(code);

+	    };

+	    Scanner.prototype.getIdentifier = function () {

+	        var start = this.index++;

+	        while (!this.eof()) {

+	            var ch = this.source.charCodeAt(this.index);

+	            if (ch === 0x5C) {

+	                // Blackslash (U+005C) marks Unicode escape sequence.

+	                this.index = start;

+	                return this.getComplexIdentifier();

+	            }

+	            else if (ch >= 0xD800 && ch < 0xDFFF) {

+	                // Need to handle surrogate pairs.

+	                this.index = start;

+	                return this.getComplexIdentifier();

+	            }

+	            if (character_1.Character.isIdentifierPart(ch)) {

+	                ++this.index;

+	            }

+	            else {

+	                break;

+	            }

+	        }

+	        return this.source.slice(start, this.index);

+	    };

+	    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.

+	        var ch;

+	        if (cp === 0x5C) {

+	            if (this.source.charCodeAt(this.index) !== 0x75) {

+	                this.throwUnexpectedToken();

+	            }

+	            ++this.index;

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

+	                ++this.index;

+	                ch = this.scanUnicodeCodePointEscape();

+	            }

+	            else {

+	                ch = this.scanHexEscape('u');

+	                if (ch === null || ch === '\\' || !character_1.Character.isIdentifierStart(ch.charCodeAt(0))) {

+	                    this.throwUnexpectedToken();

+	                }

+	            }

+	            id = ch;

+	        }

+	        while (!this.eof()) {

+	            cp = this.codePointAt(this.index);

+	            if (!character_1.Character.isIdentifierPart(cp)) {

+	                break;

+	            }

+	            ch = character_1.Character.fromCodePoint(cp);

+	            id += ch;

+	            this.index += ch.length;

+	            // '\u' (U+005C, U+0075) denotes an escaped character.

+	            if (cp === 0x5C) {

+	                id = id.substr(0, id.length - 1);

+	                if (this.source.charCodeAt(this.index) !== 0x75) {

+	                    this.throwUnexpectedToken();

+	                }

+	                ++this.index;

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

+	                    ++this.index;

+	                    ch = this.scanUnicodeCodePointEscape();

+	                }

+	                else {

+	                    ch = this.scanHexEscape('u');

+	                    if (ch === null || ch === '\\' || !character_1.Character.isIdentifierPart(ch.charCodeAt(0))) {

+	                        this.throwUnexpectedToken();

+	                    }

+	                }

+	                id += ch;

+	            }

+	        }

+	        return id;

+	    };

+	    Scanner.prototype.octalToDecimal = function (ch) {

+	        // \0 is not octal escape sequence

+	        var octal = (ch !== '0');

+	        var code = octalValue(ch);

+	        if (!this.eof() && character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) {

+	            octal = true;

+	            code = code * 8 + octalValue(this.source[this.index++]);

+	            // 3 digits are only allowed when string starts

+	            // with 0, 1, 2, 3

+	            if ('0123'.indexOf(ch) >= 0 && !this.eof() && character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) {

+	                code = code * 8 + octalValue(this.source[this.index++]);

+	            }

+	        }

+	        return {

+	            code: code,

+	            octal: octal

+	        };

+	    };

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

+	    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();

+	        // There is no keyword or literal with only one character.

+	        // Thus, it must be an identifier.

+	        if (id.length === 1) {

+	            type = 3 /* Identifier */;

+	        }

+	        else if (this.isKeyword(id)) {

+	            type = 4 /* Keyword */;

+	        }

+	        else if (id === 'null') {

+	            type = 5 /* NullLiteral */;

+	        }

+	        else if (id === 'true' || id === 'false') {

+	            type = 1 /* BooleanLiteral */;

+	        }

+	        else {

+	            type = 3 /* Identifier */;

+	        }

+	        if (type !== 3 /* Identifier */ && (start + id.length !== this.index)) {

+	            var restore = this.index;

+	            this.index = start;

+	            this.tolerateUnexpectedToken(messages_1.Messages.InvalidEscapedReservedWord);

+	            this.index = restore;

+	        }

+	        return {

+	            type: type,

+	            value: id,

+	            lineNumber: this.lineNumber,

+	            lineStart: this.lineStart,

+	            start: start,

+	            end: this.index

+	        };

+	    };

+	    // https://tc39.github.io/ecma262/#sec-punctuators

+	    Scanner.prototype.scanPunctuator = function () {

+	        var start = this.index;

+	        // Check for most common single-character punctuators.

+	        var str = this.source[this.index];

+	        switch (str) {

+	            case '(':

+	            case '{':

+	                if (str === '{') {

+	                    this.curlyStack.push('{');

+	                }

+	                ++this.index;

+	                break;

+	            case '.':

+	                ++this.index;

+	                if (this.source[this.index] === '.' && this.source[this.index + 1] === '.') {

+	                    // Spread operator: ...

+	                    this.index += 2;

+	                    str = '...';

+	                }

+	                break;

+	            case '}':

+	                ++this.index;

+	                this.curlyStack.pop();

+	                break;

+	            case ')':

+	            case ';':

+	            case ',':

+	            case '[':

+	            case ']':

+	            case ':':

+	            case '?':

+	            case '~':

+	                ++this.index;

+	                break;

+	            default:

+	                // 4-character punctuator.

+	                str = this.source.substr(this.index, 4);

+	                if (str === '>>>=') {

+	                    this.index += 4;

+	                }

+	                else {

+	                    // 3-character punctuators.

+	                    str = str.substr(0, 3);

+	                    if (str === '===' || str === '!==' || str === '>>>' ||

+	                        str === '<<=' || str === '>>=' || str === '**=') {

+	                        this.index += 3;

+	                    }

+	                    else {

+	                        // 2-character punctuators.

+	                        str = str.substr(0, 2);

+	                        if (str === '&&' || str === '||' || str === '==' || str === '!=' ||

+	                            str === '+=' || str === '-=' || str === '*=' || str === '/=' ||

+	                            str === '++' || str === '--' || str === '<<' || str === '>>' ||

+	                            str === '&=' || str === '|=' || str === '^=' || str === '%=' ||

+	                            str === '<=' || str === '>=' || str === '=>' || str === '**') {

+	                            this.index += 2;

+	                        }

+	                        else {

+	                            // 1-character punctuators.

+	                            str = this.source[this.index];

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

+	                                ++this.index;

+	                            }

+	                        }

+	                    }

+	                }

+	        }

+	        if (this.index === start) {

+	            this.throwUnexpectedToken();

+	        }

+	        return {

+	            type: 7 /* Punctuator */,

+	            value: str,

+	            lineNumber: this.lineNumber,

+	            lineStart: this.lineStart,

+	            start: start,

+	            end: this.index

+	        };

+	    };

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

+	    Scanner.prototype.scanHexLiteral = function (start) {

+	        var num = '';

+	        while (!this.eof()) {

+	            if (!character_1.Character.isHexDigit(this.source.charCodeAt(this.index))) {

+	                break;

+	            }

+	            num += this.source[this.index++];

+	        }

+	        if (num.length === 0) {

+	            this.throwUnexpectedToken();

+	        }

+	        if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index))) {

+	            this.throwUnexpectedToken();

+	        }

+	        return {

+	            type: 6 /* NumericLiteral */,

+	            value: parseInt('0x' + num, 16),

+	            lineNumber: this.lineNumber,

+	            lineStart: this.lineStart,

+	            start: start,

+	            end: this.index

+	        };

+	    };

+	    Scanner.prototype.scanBinaryLiteral = function (start) {

+	        var num = '';

+	        var ch;

+	        while (!this.eof()) {

+	            ch = this.source[this.index];

+	            if (ch !== '0' && ch !== '1') {

+	                break;

+	            }

+	            num += this.source[this.index++];

+	        }

+	        if (num.length === 0) {

+	            // only 0b or 0B

+	            this.throwUnexpectedToken();

+	        }

+	        if (!this.eof()) {

+	            ch = this.source.charCodeAt(this.index);

+	            /* istanbul ignore else */

+	            if (character_1.Character.isIdentifierStart(ch) || character_1.Character.isDecimalDigit(ch)) {

+	                this.throwUnexpectedToken();

+	            }

+	        }

+	        return {

+	            type: 6 /* NumericLiteral */,

+	            value: parseInt(num, 2),

+	            lineNumber: this.lineNumber,

+	            lineStart: this.lineStart,

+	            start: start,

+	            end: this.index

+	        };

+	    };

+	    Scanner.prototype.scanOctalLiteral = function (prefix, start) {

+	        var num = '';

+	        var octal = false;

+	        if (character_1.Character.isOctalDigit(prefix.charCodeAt(0))) {

+	            octal = true;

+	            num = '0' + this.source[this.index++];

+	        }

+	        else {

+	            ++this.index;

+	        }

+	        while (!this.eof()) {

+	            if (!character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) {

+	                break;

+	            }

+	            num += this.source[this.index++];

+	        }

+	        if (!octal && num.length === 0) {

+	            // only 0o or 0O

+	            this.throwUnexpectedToken();

+	        }

+	        if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index)) || character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {

+	            this.throwUnexpectedToken();

+	        }

+	        return {

+	            type: 6 /* NumericLiteral */,

+	            value: parseInt(num, 8),

+	            octal: octal,

+	            lineNumber: this.lineNumber,

+	            lineStart: this.lineStart,

+	            start: start,

+	            end: this.index

+	        };

+	    };

+	    Scanner.prototype.isImplicitOctalLiteral = function () {

+	        // Implicit octal, unless there is a non-octal digit.

+	        // (Annex B.1.1 on Numeric Literals)

+	        for (var i = this.index + 1; i < this.length; ++i) {

+	            var ch = this.source[i];

+	            if (ch === '8' || ch === '9') {

+	                return false;

+	            }

+	            if (!character_1.Character.isOctalDigit(ch.charCodeAt(0))) {

+	                return true;

+	            }

+	        }

+	        return true;

+	    };

+	    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 = '';

+	        if (ch !== '.') {

+	            num = this.source[this.index++];

+	            ch = this.source[this.index];

+	            // Hex number starts with '0x'.

+	            // Octal number starts with '0'.

+	            // Octal number in ES6 starts with '0o'.

+	            // Binary number in ES6 starts with '0b'.

+	            if (num === '0') {

+	                if (ch === 'x' || ch === 'X') {

+	                    ++this.index;

+	                    return this.scanHexLiteral(start);

+	                }

+	                if (ch === 'b' || ch === 'B') {

+	                    ++this.index;

+	                    return this.scanBinaryLiteral(start);

+	                }

+	                if (ch === 'o' || ch === 'O') {

+	                    return this.scanOctalLiteral(ch, start);

+	                }

+	                if (ch && character_1.Character.isOctalDigit(ch.charCodeAt(0))) {

+	                    if (this.isImplicitOctalLiteral()) {

+	                        return this.scanOctalLiteral(ch, start);

+	                    }

+	                }

+	            }

+	            while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {

+	                num += this.source[this.index++];

+	            }

+	            ch = this.source[this.index];

+	        }

+	        if (ch === '.') {

+	            num += this.source[this.index++];

+	            while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {

+	                num += this.source[this.index++];

+	            }

+	            ch = this.source[this.index];

+	        }

+	        if (ch === 'e' || ch === 'E') {

+	            num += this.source[this.index++];

+	            ch = this.source[this.index];

+	            if (ch === '+' || ch === '-') {

+	                num += this.source[this.index++];

+	            }

+	            if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {

+	                while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {

+	                    num += this.source[this.index++];

+	                }

+	            }

+	            else {

+	                this.throwUnexpectedToken();

+	            }

+	        }

+	        if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index))) {

+	            this.throwUnexpectedToken();

+	        }

+	        return {

+	            type: 6 /* NumericLiteral */,

+	            value: parseFloat(num),

+	            lineNumber: this.lineNumber,

+	            lineStart: this.lineStart,

+	            start: start,

+	            end: this.index

+	        };

+	    };

+	    // https://tc39.github.io/ecma262/#sec-literals-string-literals

+	    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;

+	        var octal = false;

+	        var str = '';

+	        while (!this.eof()) {

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

+	            if (ch === quote) {

+	                quote = '';

+	                break;

+	            }

+	            else if (ch === '\\') {

+	                ch = this.source[this.index++];

+	                if (!ch || !character_1.Character.isLineTerminator(ch.charCodeAt(0))) {

+	                    switch (ch) {

+	                        case 'u':

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

+	                                ++this.index;

+	                                str += this.scanUnicodeCodePointEscape();

+	                            }

+	                            else {

+	                                var unescaped_1 = this.scanHexEscape(ch);

+	                                if (unescaped_1 === null) {

+	                                    this.throwUnexpectedToken();

+	                                }

+	                                str += unescaped_1;

+	                            }

+	                            break;

+	                        case 'x':

+	                            var unescaped = this.scanHexEscape(ch);

+	                            if (unescaped === null) {

+	                                this.throwUnexpectedToken(messages_1.Messages.InvalidHexEscapeSequence);

+	                            }

+	                            str += unescaped;

+	                            break;

+	                        case 'n':

+	                            str += '\n';

+	                            break;

+	                        case 'r':

+	                            str += '\r';

+	                            break;

+	                        case 't':

+	                            str += '\t';

+	                            break;

+	                        case 'b':

+	                            str += '\b';

+	                            break;

+	                        case 'f':

+	                            str += '\f';

+	                            break;

+	                        case 'v':

+	                            str += '\x0B';

+	                            break;

+	                        case '8':

+	                        case '9':

+	                            str += ch;

+	                            this.tolerateUnexpectedToken();

+	                            break;

+	                        default:

+	                            if (ch && character_1.Character.isOctalDigit(ch.charCodeAt(0))) {

+	                                var octToDec = this.octalToDecimal(ch);

+	                                octal = octToDec.octal || octal;

+	                                str += String.fromCharCode(octToDec.code);

+	                            }

+	                            else {

+	                                str += ch;

+	                            }

+	                            break;

+	                    }

+	                }

+	                else {

+	                    ++this.lineNumber;

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

+	                        ++this.index;

+	                    }

+	                    this.lineStart = this.index;

+	                }

+	            }

+	            else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {

+	                break;

+	            }

+	            else {

+	                str += ch;

+	            }

+	        }

+	        if (quote !== '') {

+	            this.index = start;

+	            this.throwUnexpectedToken();

+	        }

+	        return {

+	            type: 8 /* StringLiteral */,

+	            value: str,

+	            octal: octal,

+	            lineNumber: this.lineNumber,

+	            lineStart: this.lineStart,

+	            start: start,

+	            end: this.index

+	        };

+	    };

+	    // https://tc39.github.io/ecma262/#sec-template-literal-lexical-components

+	    Scanner.prototype.scanTemplate = function () {

+	        var cooked = '';

+	        var terminated = false;

+	        var start = this.index;

+	        var head = (this.source[start] === '`');

+	        var tail = false;

+	        var rawOffset = 2;

+	        ++this.index;

+	        while (!this.eof()) {

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

+	            if (ch === '`') {

+	                rawOffset = 1;

+	                tail = true;

+	                terminated = true;

+	                break;

+	            }

+	            else if (ch === '$') {

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

+	                    this.curlyStack.push('${');

+	                    ++this.index;

+	                    terminated = true;

+	                    break;

+	                }

+	                cooked += ch;

+	            }

+	            else if (ch === '\\') {

+	                ch = this.source[this.index++];

+	                if (!character_1.Character.isLineTerminator(ch.charCodeAt(0))) {

+	                    switch (ch) {

+	                        case 'n':

+	                            cooked += '\n';

+	                            break;

+	                        case 'r':

+	                            cooked += '\r';

+	                            break;

+	                        case 't':

+	                            cooked += '\t';

+	                            break;

+	                        case 'u':

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

+	                                ++this.index;

+	                                cooked += this.scanUnicodeCodePointEscape();

+	                            }

+	                            else {

+	                                var restore = this.index;

+	                                var unescaped_2 = this.scanHexEscape(ch);

+	                                if (unescaped_2 !== null) {

+	                                    cooked += unescaped_2;

+	                                }

+	                                else {

+	                                    this.index = restore;

+	                                    cooked += ch;

+	                                }

+	                            }

+	                            break;

+	                        case 'x':

+	                            var unescaped = this.scanHexEscape(ch);

+	                            if (unescaped === null) {

+	                                this.throwUnexpectedToken(messages_1.Messages.InvalidHexEscapeSequence);

+	                            }

+	                            cooked += unescaped;

+	                            break;

+	                        case 'b':

+	                            cooked += '\b';

+	                            break;

+	                        case 'f':

+	                            cooked += '\f';

+	                            break;

+	                        case 'v':

+	                            cooked += '\v';

+	                            break;

+	                        default:

+	                            if (ch === '0') {

+	                                if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {

+	                                    // Illegal: \01 \02 and so on

+	                                    this.throwUnexpectedToken(messages_1.Messages.TemplateOctalLiteral);

+	                                }

+	                                cooked += '\0';

+	                            }

+	                            else if (character_1.Character.isOctalDigit(ch.charCodeAt(0))) {

+	                                // Illegal: \1 \2

+	                                this.throwUnexpectedToken(messages_1.Messages.TemplateOctalLiteral);

+	                            }

+	                            else {

+	                                cooked += ch;

+	                            }

+	                            break;

+	                    }

+	                }

+	                else {

+	                    ++this.lineNumber;

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

+	                        ++this.index;

+	                    }

+	                    this.lineStart = this.index;

+	                }

+	            }

+	            else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {

+	                ++this.lineNumber;

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

+	                    ++this.index;

+	                }

+	                this.lineStart = this.index;

+	                cooked += '\n';

+	            }

+	            else {

+	                cooked += ch;

+	            }

+	        }

+	        if (!terminated) {

+	            this.throwUnexpectedToken();

+	        }

+	        if (!head) {

+	            this.curlyStack.pop();

+	        }

+	        return {

+	            type: 10 /* Template */,

+	            value: this.source.slice(start + 1, this.index - rawOffset),

+	            cooked: cooked,

+	            head: head,

+	            tail: tail,

+	            lineNumber: this.lineNumber,

+	            lineStart: this.lineStart,

+	            start: start,

+	            end: this.index

+	        };

+	    };

+	    // https://tc39.github.io/ecma262/#sec-literals-regular-expression-literals

+	    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

+	        // scenarios. For example, `[\u{1044f}-\u{10440}]` is an invalid

+	        // pattern that would not be detected by this substitution.

+	        var astralSubstitute = '\uFFFF';

+	        var tmp = pattern;

+	        var self = this;

+	        if (flags.indexOf('u') >= 0) {

+	            tmp = tmp

+	                .replace(/\\u\{([0-9a-fA-F]+)\}|\\u([a-fA-F0-9]{4})/g, function ($0, $1, $2) {

+	                var codePoint = parseInt($1 || $2, 16);

+	                if (codePoint > 0x10FFFF) {

+	                    self.throwUnexpectedToken(messages_1.Messages.InvalidRegExp);

+	                }

+	                if (codePoint <= 0xFFFF) {

+	                    return String.fromCharCode(codePoint);

+	                }

+	                return astralSubstitute;

+	            })

+	                .replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, astralSubstitute);

+	        }

+	        // First, detect invalid regular expressions.

+	        try {

+	            RegExp(tmp);

+	        }

+	        catch (e) {

+	            this.throwUnexpectedToken(messages_1.Messages.InvalidRegExp);

+	        }

+	        // Return a regular expression object for this pattern-flag pair, or

+	        // `null` in case the current environment doesn't support the flags it

+	        // uses.

+	        try {

+	            return new RegExp(pattern, flags);

+	        }

+	        catch (exception) {

+	            /* istanbul ignore next */

+	            return null;

+	        }

+	    };

+	    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;

+	        var terminated = false;

+	        while (!this.eof()) {

+	            ch = this.source[this.index++];

+	            str += ch;

+	            if (ch === '\\') {

+	                ch = this.source[this.index++];

+	                // https://tc39.github.io/ecma262/#sec-literals-regular-expression-literals

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

+	                    this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp);

+	                }

+	                str += ch;

+	            }

+	            else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {

+	                this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp);

+	            }

+	            else if (classMarker) {

+	                if (ch === ']') {

+	                    classMarker = false;

+	                }

+	            }

+	            else {

+	                if (ch === '/') {

+	                    terminated = true;

+	                    break;

+	                }

+	                else if (ch === '[') {

+	                    classMarker = true;

+	                }

+	            }

+	        }

+	        if (!terminated) {

+	            this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp);

+	        }

+	        // Exclude leading and trailing slash.

+	        return str.substr(1, str.length - 2);

+	    };

+	    Scanner.prototype.scanRegExpFlags = function () {

+	        var str = '';

+	        var flags = '';

+	        while (!this.eof()) {

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

+	            if (!character_1.Character.isIdentifierPart(ch.charCodeAt(0))) {

+	                break;

+	            }

+	            ++this.index;

+	            if (ch === '\\' && !this.eof()) {

+	                ch = this.source[this.index];

+	                if (ch === 'u') {

+	                    ++this.index;

+	                    var restore = this.index;

+	                    var char = this.scanHexEscape('u');

+	                    if (char !== null) {

+	                        flags += char;

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

+	                            str += this.source[restore];

+	                        }

+	                    }

+	                    else {

+	                        this.index = restore;

+	                        flags += 'u';

+	                        str += '\\u';

+	                    }

+	                    this.tolerateUnexpectedToken();

+	                }

+	                else {

+	                    str += '\\';

+	                    this.tolerateUnexpectedToken();

+	                }

+	            }

+	            else {

+	                flags += ch;

+	                str += ch;

+	            }

+	        }

+	        return flags;

+	    };

+	    Scanner.prototype.scanRegExp = function () {

+	        var start = this.index;

+	        var pattern = this.scanRegExpBody();

+	        var flags = this.scanRegExpFlags();

+	        var value = this.testRegExp(pattern, flags);

+	        return {

+	            type: 9 /* RegularExpression */,

+	            value: '',

+	            pattern: pattern,

+	            flags: flags,

+	            regex: value,

+	            lineNumber: this.lineNumber,

+	            lineStart: this.lineStart,

+	            start: start,

+	            end: this.index

+	        };

+	    };

+	    Scanner.prototype.lex = function () {

+	        if (this.eof()) {

+	            return {

+	                type: 2 /* EOF */,

+	                value: '',

+	                lineNumber: this.lineNumber,

+	                lineStart: this.lineStart,

+	                start: this.index,

+	                end: this.index

+	            };

+	        }

+	        var cp = this.source.charCodeAt(this.index);

+	        if (character_1.Character.isIdentifierStart(cp)) {

+	            return this.scanIdentifier();

+	        }

+	        // Very common: ( and ) and ;

+	        if (cp === 0x28 || cp === 0x29 || cp === 0x3B) {

+	            return this.scanPunctuator();

+	        }

+	        // String literal starts with single quote (U+0027) or double quote (U+0022).

+	        if (cp === 0x27 || cp === 0x22) {

+	            return this.scanStringLiteral();

+	        }

+	        // Dot (.) U+002E can also start a floating-point number, hence the need

+	        // to check the next character.

+	        if (cp === 0x2E) {

+	            if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index + 1))) {

+	                return this.scanNumericLiteral();

+	            }

+	            return this.scanPunctuator();

+	        }

+	        if (character_1.Character.isDecimalDigit(cp)) {

+	            return this.scanNumericLiteral();

+	        }

+	        // Template literals start with ` (U+0060) for template head

+	        // or } (U+007D) for template middle or template tail.

+	        if (cp === 0x60 || (cp === 0x7D && this.curlyStack[this.curlyStack.length - 1] === '${')) {

+	            return this.scanTemplate();

+	        }

+	        // Possible identifier start in a surrogate pair.

+	        if (cp >= 0xD800 && cp < 0xDFFF) {

+	            if (character_1.Character.isIdentifierStart(this.codePointAt(this.index))) {

+	                return this.scanIdentifier();

+	            }

+	        }

+	        return this.scanPunctuator();

+	    };

+	    return Scanner;

+	}());

+	exports.Scanner = Scanner;

+
+
+/***/ },
+/* 13 */
+/***/ function(module, exports) {
+
+	"use strict";

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

+	exports.TokenName = {};

+	exports.TokenName[1 /* BooleanLiteral */] = 'Boolean';

+	exports.TokenName[2 /* EOF */] = '<end>';

+	exports.TokenName[3 /* Identifier */] = 'Identifier';

+	exports.TokenName[4 /* Keyword */] = 'Keyword';

+	exports.TokenName[5 /* NullLiteral */] = 'Null';

+	exports.TokenName[6 /* NumericLiteral */] = 'Numeric';

+	exports.TokenName[7 /* Punctuator */] = 'Punctuator';

+	exports.TokenName[8 /* StringLiteral */] = 'String';

+	exports.TokenName[9 /* RegularExpression */] = 'RegularExpression';

+	exports.TokenName[10 /* Template */] = 'Template';

+
+
+/***/ },
+/* 14 */
+/***/ function(module, exports) {
+
+	"use strict";

+	// Generated by generate-xhtml-entities.js. DO NOT MODIFY!

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

+	exports.XHTMLEntities = {

+	    quot: '\u0022',

+	    amp: '\u0026',

+	    apos: '\u0027',

+	    gt: '\u003E',

+	    nbsp: '\u00A0',

+	    iexcl: '\u00A1',

+	    cent: '\u00A2',

+	    pound: '\u00A3',

+	    curren: '\u00A4',

+	    yen: '\u00A5',

+	    brvbar: '\u00A6',

+	    sect: '\u00A7',

+	    uml: '\u00A8',

+	    copy: '\u00A9',

+	    ordf: '\u00AA',

+	    laquo: '\u00AB',

+	    not: '\u00AC',

+	    shy: '\u00AD',

+	    reg: '\u00AE',

+	    macr: '\u00AF',

+	    deg: '\u00B0',

+	    plusmn: '\u00B1',

+	    sup2: '\u00B2',

+	    sup3: '\u00B3',

+	    acute: '\u00B4',

+	    micro: '\u00B5',

+	    para: '\u00B6',

+	    middot: '\u00B7',

+	    cedil: '\u00B8',

+	    sup1: '\u00B9',

+	    ordm: '\u00BA',

+	    raquo: '\u00BB',

+	    frac14: '\u00BC',

+	    frac12: '\u00BD',

+	    frac34: '\u00BE',

+	    iquest: '\u00BF',

+	    Agrave: '\u00C0',

+	    Aacute: '\u00C1',

+	    Acirc: '\u00C2',

+	    Atilde: '\u00C3',

+	    Auml: '\u00C4',

+	    Aring: '\u00C5',

+	    AElig: '\u00C6',

+	    Ccedil: '\u00C7',

+	    Egrave: '\u00C8',

+	    Eacute: '\u00C9',

+	    Ecirc: '\u00CA',

+	    Euml: '\u00CB',

+	    Igrave: '\u00CC',

+	    Iacute: '\u00CD',

+	    Icirc: '\u00CE',

+	    Iuml: '\u00CF',

+	    ETH: '\u00D0',

+	    Ntilde: '\u00D1',

+	    Ograve: '\u00D2',

+	    Oacute: '\u00D3',

+	    Ocirc: '\u00D4',

+	    Otilde: '\u00D5',

+	    Ouml: '\u00D6',

+	    times: '\u00D7',

+	    Oslash: '\u00D8',

+	    Ugrave: '\u00D9',

+	    Uacute: '\u00DA',

+	    Ucirc: '\u00DB',

+	    Uuml: '\u00DC',

+	    Yacute: '\u00DD',

+	    THORN: '\u00DE',

+	    szlig: '\u00DF',

+	    agrave: '\u00E0',

+	    aacute: '\u00E1',

+	    acirc: '\u00E2',

+	    atilde: '\u00E3',

+	    auml: '\u00E4',

+	    aring: '\u00E5',

+	    aelig: '\u00E6',

+	    ccedil: '\u00E7',

+	    egrave: '\u00E8',

+	    eacute: '\u00E9',

+	    ecirc: '\u00EA',

+	    euml: '\u00EB',

+	    igrave: '\u00EC',

+	    iacute: '\u00ED',

+	    icirc: '\u00EE',

+	    iuml: '\u00EF',

+	    eth: '\u00F0',

+	    ntilde: '\u00F1',

+	    ograve: '\u00F2',

+	    oacute: '\u00F3',

+	    ocirc: '\u00F4',

+	    otilde: '\u00F5',

+	    ouml: '\u00F6',

+	    divide: '\u00F7',

+	    oslash: '\u00F8',

+	    ugrave: '\u00F9',

+	    uacute: '\u00FA',

+	    ucirc: '\u00FB',

+	    uuml: '\u00FC',

+	    yacute: '\u00FD',

+	    thorn: '\u00FE',

+	    yuml: '\u00FF',

+	    OElig: '\u0152',

+	    oelig: '\u0153',

+	    Scaron: '\u0160',

+	    scaron: '\u0161',

+	    Yuml: '\u0178',

+	    fnof: '\u0192',

+	    circ: '\u02C6',

+	    tilde: '\u02DC',

+	    Alpha: '\u0391',

+	    Beta: '\u0392',

+	    Gamma: '\u0393',

+	    Delta: '\u0394',

+	    Epsilon: '\u0395',

+	    Zeta: '\u0396',

+	    Eta: '\u0397',

+	    Theta: '\u0398',

+	    Iota: '\u0399',

+	    Kappa: '\u039A',

+	    Lambda: '\u039B',

+	    Mu: '\u039C',

+	    Nu: '\u039D',

+	    Xi: '\u039E',

+	    Omicron: '\u039F',

+	    Pi: '\u03A0',

+	    Rho: '\u03A1',

+	    Sigma: '\u03A3',

+	    Tau: '\u03A4',

+	    Upsilon: '\u03A5',

+	    Phi: '\u03A6',

+	    Chi: '\u03A7',

+	    Psi: '\u03A8',

+	    Omega: '\u03A9',

+	    alpha: '\u03B1',

+	    beta: '\u03B2',

+	    gamma: '\u03B3',

+	    delta: '\u03B4',

+	    epsilon: '\u03B5',

+	    zeta: '\u03B6',

+	    eta: '\u03B7',

+	    theta: '\u03B8',

+	    iota: '\u03B9',

+	    kappa: '\u03BA',

+	    lambda: '\u03BB',

+	    mu: '\u03BC',

+	    nu: '\u03BD',

+	    xi: '\u03BE',

+	    omicron: '\u03BF',

+	    pi: '\u03C0',

+	    rho: '\u03C1',

+	    sigmaf: '\u03C2',

+	    sigma: '\u03C3',

+	    tau: '\u03C4',

+	    upsilon: '\u03C5',

+	    phi: '\u03C6',

+	    chi: '\u03C7',

+	    psi: '\u03C8',

+	    omega: '\u03C9',

+	    thetasym: '\u03D1',

+	    upsih: '\u03D2',

+	    piv: '\u03D6',

+	    ensp: '\u2002',

+	    emsp: '\u2003',

+	    thinsp: '\u2009',

+	    zwnj: '\u200C',

+	    zwj: '\u200D',

+	    lrm: '\u200E',

+	    rlm: '\u200F',

+	    ndash: '\u2013',

+	    mdash: '\u2014',

+	    lsquo: '\u2018',

+	    rsquo: '\u2019',

+	    sbquo: '\u201A',

+	    ldquo: '\u201C',

+	    rdquo: '\u201D',

+	    bdquo: '\u201E',

+	    dagger: '\u2020',

+	    Dagger: '\u2021',

+	    bull: '\u2022',

+	    hellip: '\u2026',

+	    permil: '\u2030',

+	    prime: '\u2032',

+	    Prime: '\u2033',

+	    lsaquo: '\u2039',

+	    rsaquo: '\u203A',

+	    oline: '\u203E',

+	    frasl: '\u2044',

+	    euro: '\u20AC',

+	    image: '\u2111',

+	    weierp: '\u2118',

+	    real: '\u211C',

+	    trade: '\u2122',

+	    alefsym: '\u2135',

+	    larr: '\u2190',

+	    uarr: '\u2191',

+	    rarr: '\u2192',

+	    darr: '\u2193',

+	    harr: '\u2194',

+	    crarr: '\u21B5',

+	    lArr: '\u21D0',

+	    uArr: '\u21D1',

+	    rArr: '\u21D2',

+	    dArr: '\u21D3',

+	    hArr: '\u21D4',

+	    forall: '\u2200',

+	    part: '\u2202',

+	    exist: '\u2203',

+	    empty: '\u2205',

+	    nabla: '\u2207',

+	    isin: '\u2208',

+	    notin: '\u2209',

+	    ni: '\u220B',

+	    prod: '\u220F',

+	    sum: '\u2211',

+	    minus: '\u2212',

+	    lowast: '\u2217',

+	    radic: '\u221A',

+	    prop: '\u221D',

+	    infin: '\u221E',

+	    ang: '\u2220',

+	    and: '\u2227',

+	    or: '\u2228',

+	    cap: '\u2229',

+	    cup: '\u222A',

+	    int: '\u222B',

+	    there4: '\u2234',

+	    sim: '\u223C',

+	    cong: '\u2245',

+	    asymp: '\u2248',

+	    ne: '\u2260',

+	    equiv: '\u2261',

+	    le: '\u2264',

+	    ge: '\u2265',

+	    sub: '\u2282',

+	    sup: '\u2283',

+	    nsub: '\u2284',

+	    sube: '\u2286',

+	    supe: '\u2287',

+	    oplus: '\u2295',

+	    otimes: '\u2297',

+	    perp: '\u22A5',

+	    sdot: '\u22C5',

+	    lceil: '\u2308',

+	    rceil: '\u2309',

+	    lfloor: '\u230A',

+	    rfloor: '\u230B',

+	    loz: '\u25CA',

+	    spades: '\u2660',

+	    clubs: '\u2663',

+	    hearts: '\u2665',

+	    diams: '\u2666',

+	    lang: '\u27E8',

+	    rang: '\u27E9'

+	};

+
+
+/***/ },
+/* 15 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";

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

+	var error_handler_1 = __webpack_require__(10);

+	var scanner_1 = __webpack_require__(12);

+	var token_1 = __webpack_require__(13);

+	var Reader = (function () {

+	    function Reader() {

+	        this.values = [];

+	        this.curly = this.paren = -1;

+	    }

+	    // A function following one of those tokens is an expression.

+	    Reader.prototype.beforeFunctionExpression = function (t) {

+	        return ['(', '{', '[', 'in', 'typeof', 'instanceof', 'new',

+	            'return', 'case', 'delete', 'throw', 'void',

+	            // assignment operators

+	            '=', '+=', '-=', '*=', '**=', '/=', '%=', '<<=', '>>=', '>>>=',

+	            '&=', '|=', '^=', ',',

+	            // binary/unary operators

+	            '+', '-', '*', '**', '/', '%', '++', '--', '<<', '>>', '>>>', '&',

+	            '|', '^', '!', '~', '&&', '||', '?', ':', '===', '==', '>=',

+	            '<=', '<', '>', '!=', '!=='].indexOf(t) >= 0;

+	    };

+	    // Determine if forward slash (/) is an operator or part of a regular expression

+	    // https://github.com/mozilla/sweet.js/wiki/design

+	    Reader.prototype.isRegexStart = function () {

+	        var previous = this.values[this.values.length - 1];

+	        var regex = (previous !== null);

+	        switch (previous) {

+	            case 'this':

+	            case ']':

+	                regex = false;

+	                break;

+	            case ')':

+	                var keyword = this.values[this.paren - 1];

+	                regex = (keyword === 'if' || keyword === 'while' || keyword === 'for' || keyword === 'with');

+	                break;

+	            case '}':

+	                // Dividing a function by anything makes little sense,

+	                // but we have to check for that.

+	                regex = false;

+	                if (this.values[this.curly - 3] === 'function') {

+	                    // Anonymous function, e.g. function(){} /42

+	                    var check = this.values[this.curly - 4];

+	                    regex = check ? !this.beforeFunctionExpression(check) : false;

+	                }

+	                else if (this.values[this.curly - 4] === 'function') {

+	                    // Named function, e.g. function f(){} /42/

+	                    var check = this.values[this.curly - 5];

+	                    regex = check ? !this.beforeFunctionExpression(check) : true;

+	                }

+	                break;

+	            default:

+	                break;

+	        }

+	        return regex;

+	    };

+	    Reader.prototype.push = function (token) {

+	        if (token.type === 7 /* Punctuator */ || token.type === 4 /* Keyword */) {

+	            if (token.value === '{') {

+	                this.curly = this.values.length;

+	            }

+	            else if (token.value === '(') {

+	                this.paren = this.values.length;

+	            }

+	            this.values.push(token.value);

+	        }

+	        else {

+	            this.values.push(null);

+	        }

+	    };

+	    return Reader;

+	}());

+	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);

+	        this.scanner.trackComment = config ? (typeof config.comment === 'boolean' && config.comment) : false;

+	        this.trackRange = config ? (typeof config.range === 'boolean' && config.range) : false;

+	        this.trackLoc = config ? (typeof config.loc === 'boolean' && config.loc) : false;

+	        this.buffer = [];

+	        this.reader = new Reader();

+	    }

+	    Tokenizer.prototype.errors = function () {

+	        return this.errorHandler.errors;

+	    };

+	    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) {

+	                    var e = comments[i];

+	                    var value = this.scanner.source.slice(e.slice[0], e.slice[1]);

+	                    var comment = {

+	                        type: e.multiLine ? 'BlockComment' : 'LineComment',

+	                        value: value

+	                    };

+	                    if (this.trackRange) {

+	                        comment.range = e.range;

+	                    }

+	                    if (this.trackLoc) {

+	                        comment.loc = e.loc;

+	                    }

+	                    this.buffer.push(comment);

+	                }

+	            }

+	            if (!this.scanner.eof()) {

+	                var loc = void 0;

+	                if (this.trackLoc) {

+	                    loc = {

+	                        start: {

+	                            line: this.scanner.lineNumber,

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

+	                        },

+	                        end: {}

+	                    };

+	                }

+	                var startRegex = (this.scanner.source[this.scanner.index] === '/') && this.reader.isRegexStart();

+	                var token = startRegex ? this.scanner.scanRegExp() : this.scanner.lex();

+	                this.reader.push(token);

+	                var entry = {

+	                    type: token_1.TokenName[token.type],

+	                    value: this.scanner.source.slice(token.start, token.end)

+	                };

+	                if (this.trackRange) {

+	                    entry.range = [token.start, token.end];

+	                }

+	                if (this.trackLoc) {

+	                    loc.end = {

+	                        line: this.scanner.lineNumber,

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

+	                    };

+	                    entry.loc = loc;

+	                }

+	                if (token.type === 9 /* RegularExpression */) {

+	                    var pattern = token.pattern;

+	                    var flags = token.flags;

+	                    entry.regex = { pattern: pattern, flags: flags };

+	                }

+	                this.buffer.push(entry);

+	            }

+	        }

+	        return this.buffer.shift();

+	    };

+	    return Tokenizer;

+	}());

+	exports.Tokenizer = Tokenizer;

+
+
+/***/ }
+/******/ ])
+});
+;
+/*global define, Reflect */
+
+/*
+ * xpcshell has a smaller stack on linux and windows (1MB vs 9MB on mac),
+ * and the recursive nature of esprima can cause it to overflow pretty
+ * quickly. So favor it built in Reflect parser:
+ * https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API
+ */
+define('esprimaAdapter', ['./esprima', 'env'], function (esprima, env) {
+    if (env.get() === 'xpconnect' && typeof Reflect !== 'undefined') {
+        return Reflect;
+    } else {
+        return esprima;
+    }
+});
+(function webpackUniversalModuleDefinition(root, factory) {
+var exports, module;
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define('source-map', [], factory);
+	else if(typeof exports === 'object')
+		exports["sourceMap"] = factory();
+	else
+		root["sourceMap"] = 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
+/******/ 		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__) {
+
+	/*
+	 * Copyright 2009-2011 Mozilla Foundation and contributors
+	 * Licensed under the New BSD license. See LICENSE.txt or:
+	 * http://opensource.org/licenses/BSD-3-Clause
+	 */
+	exports.SourceMapGenerator = __webpack_require__(1).SourceMapGenerator;
+	exports.SourceMapConsumer = __webpack_require__(7).SourceMapConsumer;
+	exports.SourceNode = __webpack_require__(10).SourceNode;
+
+
+/***/ },
+/* 1 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* -*- Mode: js; js-indent-level: 2; -*- */
+	/*
+	 * Copyright 2011 Mozilla Foundation and contributors
+	 * Licensed under the New BSD license. See LICENSE or:
+	 * http://opensource.org/licenses/BSD-3-Clause
+	 */
+
+	var base64VLQ = __webpack_require__(2);
+	var util = __webpack_require__(4);
+	var ArraySet = __webpack_require__(5).ArraySet;
+	var MappingList = __webpack_require__(6).MappingList;
+
+	/**
+	 * An instance of the SourceMapGenerator represents a source map which is
+	 * being built incrementally. You may pass an object with the following
+	 * properties:
+	 *
+	 *   - file: The filename of the generated source.
+	 *   - sourceRoot: A root for all relative URLs in this source map.
+	 */
+	function SourceMapGenerator(aArgs) {
+	  if (!aArgs) {
+	    aArgs = {};
+	  }
+	  this._file = util.getArg(aArgs, 'file', null);
+	  this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);
+	  this._skipValidation = util.getArg(aArgs, 'skipValidation', false);
+	  this._sources = new ArraySet();
+	  this._names = new ArraySet();
+	  this._mappings = new MappingList();
+	  this._sourcesContents = null;
+	}
+
+	SourceMapGenerator.prototype._version = 3;
+
+	/**
+	 * Creates a new SourceMapGenerator based on a SourceMapConsumer
+	 *
+	 * @param aSourceMapConsumer The SourceMap.
+	 */
+	SourceMapGenerator.fromSourceMap =
+	  function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {
+	    var sourceRoot = aSourceMapConsumer.sourceRoot;
+	    var generator = new SourceMapGenerator({
+	      file: aSourceMapConsumer.file,
+	      sourceRoot: sourceRoot
+	    });
+	    aSourceMapConsumer.eachMapping(function (mapping) {
+	      var newMapping = {
+	        generated: {
+	          line: mapping.generatedLine,
+	          column: mapping.generatedColumn
+	        }
+	      };
+
+	      if (mapping.source != null) {
+	        newMapping.source = mapping.source;
+	        if (sourceRoot != null) {
+	          newMapping.source = util.relative(sourceRoot, newMapping.source);
+	        }
+
+	        newMapping.original = {
+	          line: mapping.originalLine,
+	          column: mapping.originalColumn
+	        };
+
+	        if (mapping.name != null) {
+	          newMapping.name = mapping.name;
+	        }
+	      }
+
+	      generator.addMapping(newMapping);
+	    });
+	    aSourceMapConsumer.sources.forEach(function (sourceFile) {
+	      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+	      if (content != null) {
+	        generator.setSourceContent(sourceFile, content);
+	      }
+	    });
+	    return generator;
+	  };
+
+	/**
+	 * Add a single mapping from original source line and column to the generated
+	 * source's line and column for this source map being created. The mapping
+	 * object should have the following properties:
+	 *
+	 *   - generated: An object with the generated line and column positions.
+	 *   - original: An object with the original line and column positions.
+	 *   - source: The original source file (relative to the sourceRoot).
+	 *   - name: An optional original token name for this mapping.
+	 */
+	SourceMapGenerator.prototype.addMapping =
+	  function SourceMapGenerator_addMapping(aArgs) {
+	    var generated = util.getArg(aArgs, 'generated');
+	    var original = util.getArg(aArgs, 'original', null);
+	    var source = util.getArg(aArgs, 'source', null);
+	    var name = util.getArg(aArgs, 'name', null);
+
+	    if (!this._skipValidation) {
+	      this._validateMapping(generated, original, source, name);
+	    }
+
+	    if (source != null) {
+	      source = String(source);
+	      if (!this._sources.has(source)) {
+	        this._sources.add(source);
+	      }
+	    }
+
+	    if (name != null) {
+	      name = String(name);
+	      if (!this._names.has(name)) {
+	        this._names.add(name);
+	      }
+	    }
+
+	    this._mappings.add({
+	      generatedLine: generated.line,
+	      generatedColumn: generated.column,
+	      originalLine: original != null && original.line,
+	      originalColumn: original != null && original.column,
+	      source: source,
+	      name: name
+	    });
+	  };
+
+	/**
+	 * Set the source content for a source file.
+	 */
+	SourceMapGenerator.prototype.setSourceContent =
+	  function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
+	    var source = aSourceFile;
+	    if (this._sourceRoot != null) {
+	      source = util.relative(this._sourceRoot, source);
+	    }
+
+	    if (aSourceContent != null) {
+	      // Add the source content to the _sourcesContents map.
+	      // Create a new _sourcesContents map if the property is null.
+	      if (!this._sourcesContents) {
+	        this._sourcesContents = Object.create(null);
+	      }
+	      this._sourcesContents[util.toSetString(source)] = aSourceContent;
+	    } else if (this._sourcesContents) {
+	      // Remove the source file from the _sourcesContents map.
+	      // If the _sourcesContents map is empty, set the property to null.
+	      delete this._sourcesContents[util.toSetString(source)];
+	      if (Object.keys(this._sourcesContents).length === 0) {
+	        this._sourcesContents = null;
+	      }
+	    }
+	  };
+
+	/**
+	 * Applies the mappings of a sub-source-map for a specific source file to the
+	 * source map being generated. Each mapping to the supplied source file is
+	 * rewritten using the supplied source map. Note: The resolution for the
+	 * resulting mappings is the minimium of this map and the supplied map.
+	 *
+	 * @param aSourceMapConsumer The source map to be applied.
+	 * @param aSourceFile Optional. The filename of the source file.
+	 *        If omitted, SourceMapConsumer's file property will be used.
+	 * @param aSourceMapPath Optional. The dirname of the path to the source map
+	 *        to be applied. If relative, it is relative to the SourceMapConsumer.
+	 *        This parameter is needed when the two source maps aren't in the same
+	 *        directory, and the source map to be applied contains relative source
+	 *        paths. If so, those relative source paths need to be rewritten
+	 *        relative to the SourceMapGenerator.
+	 */
+	SourceMapGenerator.prototype.applySourceMap =
+	  function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
+	    var sourceFile = aSourceFile;
+	    // If aSourceFile is omitted, we will use the file property of the SourceMap
+	    if (aSourceFile == null) {
+	      if (aSourceMapConsumer.file == null) {
+	        throw new Error(
+	          'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +
+	          'or the source map\'s "file" property. Both were omitted.'
+	        );
+	      }
+	      sourceFile = aSourceMapConsumer.file;
+	    }
+	    var sourceRoot = this._sourceRoot;
+	    // Make "sourceFile" relative if an absolute Url is passed.
+	    if (sourceRoot != null) {
+	      sourceFile = util.relative(sourceRoot, sourceFile);
+	    }
+	    // Applying the SourceMap can add and remove items from the sources and
+	    // the names array.
+	    var newSources = new ArraySet();
+	    var newNames = new ArraySet();
+
+	    // Find mappings for the "sourceFile"
+	    this._mappings.unsortedForEach(function (mapping) {
+	      if (mapping.source === sourceFile && mapping.originalLine != null) {
+	        // Check if it can be mapped by the source map, then update the mapping.
+	        var original = aSourceMapConsumer.originalPositionFor({
+	          line: mapping.originalLine,
+	          column: mapping.originalColumn
+	        });
+	        if (original.source != null) {
+	          // Copy mapping
+	          mapping.source = original.source;
+	          if (aSourceMapPath != null) {
+	            mapping.source = util.join(aSourceMapPath, mapping.source)
+	          }
+	          if (sourceRoot != null) {
+	            mapping.source = util.relative(sourceRoot, mapping.source);
+	          }
+	          mapping.originalLine = original.line;
+	          mapping.originalColumn = original.column;
+	          if (original.name != null) {
+	            mapping.name = original.name;
+	          }
+	        }
+	      }
+
+	      var source = mapping.source;
+	      if (source != null && !newSources.has(source)) {
+	        newSources.add(source);
+	      }
+
+	      var name = mapping.name;
+	      if (name != null && !newNames.has(name)) {
+	        newNames.add(name);
+	      }
+
+	    }, this);
+	    this._sources = newSources;
+	    this._names = newNames;
+
+	    // Copy sourcesContents of applied map.
+	    aSourceMapConsumer.sources.forEach(function (sourceFile) {
+	      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+	      if (content != null) {
+	        if (aSourceMapPath != null) {
+	          sourceFile = util.join(aSourceMapPath, sourceFile);
+	        }
+	        if (sourceRoot != null) {
+	          sourceFile = util.relative(sourceRoot, sourceFile);
+	        }
+	        this.setSourceContent(sourceFile, content);
+	      }
+	    }, this);
+	  };
+
+	/**
+	 * A mapping can have one of the three levels of data:
+	 *
+	 *   1. Just the generated position.
+	 *   2. The Generated position, original position, and original source.
+	 *   3. Generated and original position, original source, as well as a name
+	 *      token.
+	 *
+	 * To maintain consistency, we validate that any new mapping being added falls
+	 * in to one of these categories.
+	 */
+	SourceMapGenerator.prototype._validateMapping =
+	  function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,
+	                                              aName) {
+	    if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
+	        && aGenerated.line > 0 && aGenerated.column >= 0
+	        && !aOriginal && !aSource && !aName) {
+	      // Case 1.
+	      return;
+	    }
+	    else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
+	             && aOriginal && 'line' in aOriginal && 'column' in aOriginal
+	             && aGenerated.line > 0 && aGenerated.column >= 0
+	             && aOriginal.line > 0 && aOriginal.column >= 0
+	             && aSource) {
+	      // Cases 2 and 3.
+	      return;
+	    }
+	    else {
+	      throw new Error('Invalid mapping: ' + JSON.stringify({
+	        generated: aGenerated,
+	        source: aSource,
+	        original: aOriginal,
+	        name: aName
+	      }));
+	    }
+	  };
+
+	/**
+	 * Serialize the accumulated mappings in to the stream of base 64 VLQs
+	 * specified by the source map format.
+	 */
+	SourceMapGenerator.prototype._serializeMappings =
+	  function SourceMapGenerator_serializeMappings() {
+	    var previousGeneratedColumn = 0;
+	    var previousGeneratedLine = 1;
+	    var previousOriginalColumn = 0;
+	    var previousOriginalLine = 0;
+	    var previousName = 0;
+	    var previousSource = 0;
+	    var result = '';
+	    var next;
+	    var mapping;
+	    var nameIdx;
+	    var sourceIdx;
+
+	    var mappings = this._mappings.toArray();
+	    for (var i = 0, len = mappings.length; i < len; i++) {
+	      mapping = mappings[i];
+	      next = ''
+
+	      if (mapping.generatedLine !== previousGeneratedLine) {
+	        previousGeneratedColumn = 0;
+	        while (mapping.generatedLine !== previousGeneratedLine) {
+	          next += ';';
+	          previousGeneratedLine++;
+	        }
+	      }
+	      else {
+	        if (i > 0) {
+	          if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {
+	            continue;
+	          }
+	          next += ',';
+	        }
+	      }
+
+	      next += base64VLQ.encode(mapping.generatedColumn
+	                                 - previousGeneratedColumn);
+	      previousGeneratedColumn = mapping.generatedColumn;
+
+	      if (mapping.source != null) {
+	        sourceIdx = this._sources.indexOf(mapping.source);
+	        next += base64VLQ.encode(sourceIdx - previousSource);
+	        previousSource = sourceIdx;
+
+	        // lines are stored 0-based in SourceMap spec version 3
+	        next += base64VLQ.encode(mapping.originalLine - 1
+	                                   - previousOriginalLine);
+	        previousOriginalLine = mapping.originalLine - 1;
+
+	        next += base64VLQ.encode(mapping.originalColumn
+	                                   - previousOriginalColumn);
+	        previousOriginalColumn = mapping.originalColumn;
+
+	        if (mapping.name != null) {
+	          nameIdx = this._names.indexOf(mapping.name);
+	          next += base64VLQ.encode(nameIdx - previousName);
+	          previousName = nameIdx;
+	        }
+	      }
+
+	      result += next;
+	    }
+
+	    return result;
+	  };
+
+	SourceMapGenerator.prototype._generateSourcesContent =
+	  function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
+	    return aSources.map(function (source) {
+	      if (!this._sourcesContents) {
+	        return null;
+	      }
+	      if (aSourceRoot != null) {
+	        source = util.relative(aSourceRoot, source);
+	      }
+	      var key = util.toSetString(source);
+	      return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)
+	        ? this._sourcesContents[key]
+	        : null;
+	    }, this);
+	  };
+
+	/**
+	 * Externalize the source map.
+	 */
+	SourceMapGenerator.prototype.toJSON =
+	  function SourceMapGenerator_toJSON() {
+	    var map = {
+	      version: this._version,
+	      sources: this._sources.toArray(),
+	      names: this._names.toArray(),
+	      mappings: this._serializeMappings()
+	    };
+	    if (this._file != null) {
+	      map.file = this._file;
+	    }
+	    if (this._sourceRoot != null) {
+	      map.sourceRoot = this._sourceRoot;
+	    }
+	    if (this._sourcesContents) {
+	      map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
+	    }
+
+	    return map;
+	  };
+
+	/**
+	 * Render the source map being generated to a string.
+	 */
+	SourceMapGenerator.prototype.toString =
+	  function SourceMapGenerator_toString() {
+	    return JSON.stringify(this.toJSON());
+	  };
+
+	exports.SourceMapGenerator = SourceMapGenerator;
+
+
+/***/ },
+/* 2 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* -*- Mode: js; js-indent-level: 2; -*- */
+	/*
+	 * Copyright 2011 Mozilla Foundation and contributors
+	 * Licensed under the New BSD license. See LICENSE or:
+	 * http://opensource.org/licenses/BSD-3-Clause
+	 *
+	 * Based on the Base 64 VLQ implementation in Closure Compiler:
+	 * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java
+	 *
+	 * Copyright 2011 The Closure Compiler Authors. All rights reserved.
+	 * 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.
+	 *  * Neither the name of Google Inc. nor the names of its
+	 *    contributors may be used to endorse or promote products derived
+	 *    from this software without specific prior written permission.
+	 *
+	 * 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 THE COPYRIGHT
+	 * OWNER OR CONTRIBUTORS 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.
+	 */
+
+	var base64 = __webpack_require__(3);
+
+	// A single base 64 digit can contain 6 bits of data. For the base 64 variable
+	// length quantities we use in the source map spec, the first bit is the sign,
+	// the next four bits are the actual value, and the 6th bit is the
+	// continuation bit. The continuation bit tells us whether there are more
+	// digits in this value following this digit.
+	//
+	//   Continuation
+	//   |    Sign
+	//   |    |
+	//   V    V
+	//   101011
+
+	var VLQ_BASE_SHIFT = 5;
+
+	// binary: 100000
+	var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
+
+	// binary: 011111
+	var VLQ_BASE_MASK = VLQ_BASE - 1;
+
+	// binary: 100000
+	var VLQ_CONTINUATION_BIT = VLQ_BASE;
+
+	/**
+	 * Converts from a two-complement value to a value where the sign bit is
+	 * placed in the least significant bit.  For example, as decimals:
+	 *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
+	 *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
+	 */
+	function toVLQSigned(aValue) {
+	  return aValue < 0
+	    ? ((-aValue) << 1) + 1
+	    : (aValue << 1) + 0;
+	}
+
+	/**
+	 * Converts to a two-complement value from a value where the sign bit is
+	 * placed in the least significant bit.  For example, as decimals:
+	 *   2 (10 binary) becomes 1, 3 (11 binary) becomes -1
+	 *   4 (100 binary) becomes 2, 5 (101 binary) becomes -2
+	 */
+	function fromVLQSigned(aValue) {
+	  var isNegative = (aValue & 1) === 1;
+	  var shifted = aValue >> 1;
+	  return isNegative
+	    ? -shifted
+	    : shifted;
+	}
+
+	/**
+	 * Returns the base 64 VLQ encoded value.
+	 */
+	exports.encode = function base64VLQ_encode(aValue) {
+	  var encoded = "";
+	  var digit;
+
+	  var vlq = toVLQSigned(aValue);
+
+	  do {
+	    digit = vlq & VLQ_BASE_MASK;
+	    vlq >>>= VLQ_BASE_SHIFT;
+	    if (vlq > 0) {
+	      // There are still more digits in this value, so we must make sure the
+	      // continuation bit is marked.
+	      digit |= VLQ_CONTINUATION_BIT;
+	    }
+	    encoded += base64.encode(digit);
+	  } while (vlq > 0);
+
+	  return encoded;
+	};
+
+	/**
+	 * Decodes the next base 64 VLQ value from the given string and returns the
+	 * value and the rest of the string via the out parameter.
+	 */
+	exports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {
+	  var strLen = aStr.length;
+	  var result = 0;
+	  var shift = 0;
+	  var continuation, digit;
+
+	  do {
+	    if (aIndex >= strLen) {
+	      throw new Error("Expected more digits in base 64 VLQ value.");
+	    }
+
+	    digit = base64.decode(aStr.charCodeAt(aIndex++));
+	    if (digit === -1) {
+	      throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));
+	    }
+
+	    continuation = !!(digit & VLQ_CONTINUATION_BIT);
+	    digit &= VLQ_BASE_MASK;
+	    result = result + (digit << shift);
+	    shift += VLQ_BASE_SHIFT;
+	  } while (continuation);
+
+	  aOutParam.value = fromVLQSigned(result);
+	  aOutParam.rest = aIndex;
+	};
+
+
+/***/ },
+/* 3 */
+/***/ function(module, exports) {
+
+	/* -*- Mode: js; js-indent-level: 2; -*- */
+	/*
+	 * Copyright 2011 Mozilla Foundation and contributors
+	 * Licensed under the New BSD license. See LICENSE or:
+	 * http://opensource.org/licenses/BSD-3-Clause
+	 */
+
+	var intToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');
+
+	/**
+	 * Encode an integer in the range of 0 to 63 to a single base 64 digit.
+	 */
+	exports.encode = function (number) {
+	  if (0 <= number && number < intToCharMap.length) {
+	    return intToCharMap[number];
+	  }
+	  throw new TypeError("Must be between 0 and 63: " + number);
+	};
+
+	/**
+	 * Decode a single base 64 character code digit to an integer. Returns -1 on
+	 * failure.
+	 */
+	exports.decode = function (charCode) {
+	  var bigA = 65;     // 'A'
+	  var bigZ = 90;     // 'Z'
+
+	  var littleA = 97;  // 'a'
+	  var littleZ = 122; // 'z'
+
+	  var zero = 48;     // '0'
+	  var nine = 57;     // '9'
+
+	  var plus = 43;     // '+'
+	  var slash = 47;    // '/'
+
+	  var littleOffset = 26;
+	  var numberOffset = 52;
+
+	  // 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ
+	  if (bigA <= charCode && charCode <= bigZ) {
+	    return (charCode - bigA);
+	  }
+
+	  // 26 - 51: abcdefghijklmnopqrstuvwxyz
+	  if (littleA <= charCode && charCode <= littleZ) {
+	    return (charCode - littleA + littleOffset);
+	  }
+
+	  // 52 - 61: 0123456789
+	  if (zero <= charCode && charCode <= nine) {
+	    return (charCode - zero + numberOffset);
+	  }
+
+	  // 62: +
+	  if (charCode == plus) {
+	    return 62;
+	  }
+
+	  // 63: /
+	  if (charCode == slash) {
+	    return 63;
+	  }
+
+	  // Invalid base64 digit.
+	  return -1;
+	};
+
+
+/***/ },
+/* 4 */
+/***/ function(module, exports) {
+
+	/* -*- Mode: js; js-indent-level: 2; -*- */
+	/*
+	 * Copyright 2011 Mozilla Foundation and contributors
+	 * Licensed under the New BSD license. See LICENSE or:
+	 * http://opensource.org/licenses/BSD-3-Clause
+	 */
+
+	/**
+	 * This is a helper function for getting values from parameter/options
+	 * objects.
+	 *
+	 * @param args The object we are extracting values from
+	 * @param name The name of the property we are getting.
+	 * @param defaultValue An optional value to return if the property is missing
+	 * from the object. If this is not specified and the property is missing, an
+	 * error will be thrown.
+	 */
+	function getArg(aArgs, aName, aDefaultValue) {
+	  if (aName in aArgs) {
+	    return aArgs[aName];
+	  } else if (arguments.length === 3) {
+	    return aDefaultValue;
+	  } else {
+	    throw new Error('"' + aName + '" is a required argument.');
+	  }
+	}
+	exports.getArg = getArg;
+
+	var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.]*)(?::(\d+))?(\S*)$/;
+	var dataUrlRegexp = /^data:.+\,.+$/;
+
+	function urlParse(aUrl) {
+	  var match = aUrl.match(urlRegexp);
+	  if (!match) {
+	    return null;
+	  }
+	  return {
+	    scheme: match[1],
+	    auth: match[2],
+	    host: match[3],
+	    port: match[4],
+	    path: match[5]
+	  };
+	}
+	exports.urlParse = urlParse;
+
+	function urlGenerate(aParsedUrl) {
+	  var url = '';
+	  if (aParsedUrl.scheme) {
+	    url += aParsedUrl.scheme + ':';
+	  }
+	  url += '//';
+	  if (aParsedUrl.auth) {
+	    url += aParsedUrl.auth + '@';
+	  }
+	  if (aParsedUrl.host) {
+	    url += aParsedUrl.host;
+	  }
+	  if (aParsedUrl.port) {
+	    url += ":" + aParsedUrl.port
+	  }
+	  if (aParsedUrl.path) {
+	    url += aParsedUrl.path;
+	  }
+	  return url;
+	}
+	exports.urlGenerate = urlGenerate;
+
+	/**
+	 * Normalizes a path, or the path portion of a URL:
+	 *
+	 * - Replaces consequtive slashes with one slash.
+	 * - Removes unnecessary '.' parts.
+	 * - Removes unnecessary '<dir>/..' parts.
+	 *
+	 * Based on code in the Node.js 'path' core module.
+	 *
+	 * @param aPath The path or url to normalize.
+	 */
+	function normalize(aPath) {
+	  var path = aPath;
+	  var url = urlParse(aPath);
+	  if (url) {
+	    if (!url.path) {
+	      return aPath;
+	    }
+	    path = url.path;
+	  }
+	  var isAbsolute = exports.isAbsolute(path);
+
+	  var parts = path.split(/\/+/);
+	  for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
+	    part = parts[i];
+	    if (part === '.') {
+	      parts.splice(i, 1);
+	    } else if (part === '..') {
+	      up++;
+	    } else if (up > 0) {
+	      if (part === '') {
+	        // The first part is blank if the path is absolute. Trying to go
+	        // above the root is a no-op. Therefore we can remove all '..' parts
+	        // directly after the root.
+	        parts.splice(i + 1, up);
+	        up = 0;
+	      } else {
+	        parts.splice(i, 2);
+	        up--;
+	      }
+	    }
+	  }
+	  path = parts.join('/');
+
+	  if (path === '') {
+	    path = isAbsolute ? '/' : '.';
+	  }
+
+	  if (url) {
+	    url.path = path;
+	    return urlGenerate(url);
+	  }
+	  return path;
+	}
+	exports.normalize = normalize;
+
+	/**
+	 * Joins two paths/URLs.
+	 *
+	 * @param aRoot The root path or URL.
+	 * @param aPath The path or URL to be joined with the root.
+	 *
+	 * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
+	 *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended
+	 *   first.
+	 * - Otherwise aPath is a path. If aRoot is a URL, then its path portion
+	 *   is updated with the result and aRoot is returned. Otherwise the result
+	 *   is returned.
+	 *   - If aPath is absolute, the result is aPath.
+	 *   - Otherwise the two paths are joined with a slash.
+	 * - Joining for example 'http://' and 'www.example.com' is also supported.
+	 */
+	function join(aRoot, aPath) {
+	  if (aRoot === "") {
+	    aRoot = ".";
+	  }
+	  if (aPath === "") {
+	    aPath = ".";
+	  }
+	  var aPathUrl = urlParse(aPath);
+	  var aRootUrl = urlParse(aRoot);
+	  if (aRootUrl) {
+	    aRoot = aRootUrl.path || '/';
+	  }
+
+	  // `join(foo, '//www.example.org')`
+	  if (aPathUrl && !aPathUrl.scheme) {
+	    if (aRootUrl) {
+	      aPathUrl.scheme = aRootUrl.scheme;
+	    }
+	    return urlGenerate(aPathUrl);
+	  }
+
+	  if (aPathUrl || aPath.match(dataUrlRegexp)) {
+	    return aPath;
+	  }
+
+	  // `join('http://', 'www.example.com')`
+	  if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
+	    aRootUrl.host = aPath;
+	    return urlGenerate(aRootUrl);
+	  }
+
+	  var joined = aPath.charAt(0) === '/'
+	    ? aPath
+	    : normalize(aRoot.replace(/\/+$/, '') + '/' + aPath);
+
+	  if (aRootUrl) {
+	    aRootUrl.path = joined;
+	    return urlGenerate(aRootUrl);
+	  }
+	  return joined;
+	}
+	exports.join = join;
+
+	exports.isAbsolute = function (aPath) {
+	  return aPath.charAt(0) === '/' || !!aPath.match(urlRegexp);
+	};
+
+	/**
+	 * Make a path relative to a URL or another path.
+	 *
+	 * @param aRoot The root path or URL.
+	 * @param aPath The path or URL to be made relative to aRoot.
+	 */
+	function relative(aRoot, aPath) {
+	  if (aRoot === "") {
+	    aRoot = ".";
+	  }
+
+	  aRoot = aRoot.replace(/\/$/, '');
+
+	  // It is possible for the path to be above the root. In this case, simply
+	  // checking whether the root is a prefix of the path won't work. Instead, we
+	  // need to remove components from the root one by one, until either we find
+	  // a prefix that fits, or we run out of components to remove.
+	  var level = 0;
+	  while (aPath.indexOf(aRoot + '/') !== 0) {
+	    var index = aRoot.lastIndexOf("/");
+	    if (index < 0) {
+	      return aPath;
+	    }
+
+	    // If the only part of the root that is left is the scheme (i.e. http://,
+	    // file:///, etc.), one or more slashes (/), or simply nothing at all, we
+	    // have exhausted all components, so the path is not relative to the root.
+	    aRoot = aRoot.slice(0, index);
+	    if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
+	      return aPath;
+	    }
+
+	    ++level;
+	  }
+
+	  // Make sure we add a "../" for each component we removed from the root.
+	  return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
+	}
+	exports.relative = relative;
+
+	var supportsNullProto = (function () {
+	  var obj = Object.create(null);
+	  return !('__proto__' in obj);
+	}());
+
+	function identity (s) {
+	  return s;
+	}
+
+	/**
+	 * Because behavior goes wacky when you set `__proto__` on objects, we
+	 * have to prefix all the strings in our set with an arbitrary character.
+	 *
+	 * See https://github.com/mozilla/source-map/pull/31 and
+	 * https://github.com/mozilla/source-map/issues/30
+	 *
+	 * @param String aStr
+	 */
+	function toSetString(aStr) {
+	  if (isProtoString(aStr)) {
+	    return '$' + aStr;
+	  }
+
+	  return aStr;
+	}
+	exports.toSetString = supportsNullProto ? identity : toSetString;
+
+	function fromSetString(aStr) {
+	  if (isProtoString(aStr)) {
+	    return aStr.slice(1);
+	  }
+
+	  return aStr;
+	}
+	exports.fromSetString = supportsNullProto ? identity : fromSetString;
+
+	function isProtoString(s) {
+	  if (!s) {
+	    return false;
+	  }
+
+	  var length = s.length;
+
+	  if (length < 9 /* "__proto__".length */) {
+	    return false;
+	  }
+
+	  if (s.charCodeAt(length - 1) !== 95  /* '_' */ ||
+	      s.charCodeAt(length - 2) !== 95  /* '_' */ ||
+	      s.charCodeAt(length - 3) !== 111 /* 'o' */ ||
+	      s.charCodeAt(length - 4) !== 116 /* 't' */ ||
+	      s.charCodeAt(length - 5) !== 111 /* 'o' */ ||
+	      s.charCodeAt(length - 6) !== 114 /* 'r' */ ||
+	      s.charCodeAt(length - 7) !== 112 /* 'p' */ ||
+	      s.charCodeAt(length - 8) !== 95  /* '_' */ ||
+	      s.charCodeAt(length - 9) !== 95  /* '_' */) {
+	    return false;
+	  }
+
+	  for (var i = length - 10; i >= 0; i--) {
+	    if (s.charCodeAt(i) !== 36 /* '$' */) {
+	      return false;
+	    }
+	  }
+
+	  return true;
+	}
+
+	/**
+	 * Comparator between two mappings where the original positions are compared.
+	 *
+	 * Optionally pass in `true` as `onlyCompareGenerated` to consider two
+	 * mappings with the same original source/line/column, but different generated
+	 * line and column the same. Useful when searching for a mapping with a
+	 * stubbed out mapping.
+	 */
+	function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
+	  var cmp = mappingA.source - mappingB.source;
+	  if (cmp !== 0) {
+	    return cmp;
+	  }
+
+	  cmp = mappingA.originalLine - mappingB.originalLine;
+	  if (cmp !== 0) {
+	    return cmp;
+	  }
+
+	  cmp = mappingA.originalColumn - mappingB.originalColumn;
+	  if (cmp !== 0 || onlyCompareOriginal) {
+	    return cmp;
+	  }
+
+	  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+	  if (cmp !== 0) {
+	    return cmp;
+	  }
+
+	  cmp = mappingA.generatedLine - mappingB.generatedLine;
+	  if (cmp !== 0) {
+	    return cmp;
+	  }
+
+	  return mappingA.name - mappingB.name;
+	}
+	exports.compareByOriginalPositions = compareByOriginalPositions;
+
+	/**
+	 * Comparator between two mappings with deflated source and name indices where
+	 * the generated positions are compared.
+	 *
+	 * Optionally pass in `true` as `onlyCompareGenerated` to consider two
+	 * mappings with the same generated line and column, but different
+	 * source/name/original line and column the same. Useful when searching for a
+	 * mapping with a stubbed out mapping.
+	 */
+	function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
+	  var cmp = mappingA.generatedLine - mappingB.generatedLine;
+	  if (cmp !== 0) {
+	    return cmp;
+	  }
+
+	  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+	  if (cmp !== 0 || onlyCompareGenerated) {
+	    return cmp;
+	  }
+
+	  cmp = mappingA.source - mappingB.source;
+	  if (cmp !== 0) {
+	    return cmp;
+	  }
+
+	  cmp = mappingA.originalLine - mappingB.originalLine;
+	  if (cmp !== 0) {
+	    return cmp;
+	  }
+
+	  cmp = mappingA.originalColumn - mappingB.originalColumn;
+	  if (cmp !== 0) {
+	    return cmp;
+	  }
+
+	  return mappingA.name - mappingB.name;
+	}
+	exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
+
+	function strcmp(aStr1, aStr2) {
+	  if (aStr1 === aStr2) {
+	    return 0;
+	  }
+
+	  if (aStr1 > aStr2) {
+	    return 1;
+	  }
+
+	  return -1;
+	}
+
+	/**
+	 * Comparator between two mappings with inflated source and name strings where
+	 * the generated positions are compared.
+	 */
+	function compareByGeneratedPositionsInflated(mappingA, mappingB) {
+	  var cmp = mappingA.generatedLine - mappingB.generatedLine;
+	  if (cmp !== 0) {
+	    return cmp;
+	  }
+
+	  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+	  if (cmp !== 0) {
+	    return cmp;
+	  }
+
+	  cmp = strcmp(mappingA.source, mappingB.source);
+	  if (cmp !== 0) {
+	    return cmp;
+	  }
+
+	  cmp = mappingA.originalLine - mappingB.originalLine;
+	  if (cmp !== 0) {
+	    return cmp;
+	  }
+
+	  cmp = mappingA.originalColumn - mappingB.originalColumn;
+	  if (cmp !== 0) {
+	    return cmp;
+	  }
+
+	  return strcmp(mappingA.name, mappingB.name);
+	}
+	exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
+
+
+/***/ },
+/* 5 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* -*- Mode: js; js-indent-level: 2; -*- */
+	/*
+	 * Copyright 2011 Mozilla Foundation and contributors
+	 * Licensed under the New BSD license. See LICENSE or:
+	 * http://opensource.org/licenses/BSD-3-Clause
+	 */
+
+	var util = __webpack_require__(4);
+	var has = Object.prototype.hasOwnProperty;
+
+	/**
+	 * A data structure which is a combination of an array and a set. Adding a new
+	 * member is O(1), testing for membership is O(1), and finding the index of an
+	 * element is O(1). Removing elements from the set is not supported. Only
+	 * strings are supported for membership.
+	 */
+	function ArraySet() {
+	  this._array = [];
+	  this._set = Object.create(null);
+	}
+
+	/**
+	 * Static method for creating ArraySet instances from an existing array.
+	 */
+	ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
+	  var set = new ArraySet();
+	  for (var i = 0, len = aArray.length; i < len; i++) {
+	    set.add(aArray[i], aAllowDuplicates);
+	  }
+	  return set;
+	};
+
+	/**
+	 * Return how many unique items are in this ArraySet. If duplicates have been
+	 * added, than those do not count towards the size.
+	 *
+	 * @returns Number
+	 */
+	ArraySet.prototype.size = function ArraySet_size() {
+	  return Object.getOwnPropertyNames(this._set).length;
+	};
+
+	/**
+	 * Add the given string to this set.
+	 *
+	 * @param String aStr
+	 */
+	ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
+	  var sStr = util.toSetString(aStr);
+	  var isDuplicate = has.call(this._set, sStr);
+	  var idx = this._array.length;
+	  if (!isDuplicate || aAllowDuplicates) {
+	    this._array.push(aStr);
+	  }
+	  if (!isDuplicate) {
+	    this._set[sStr] = idx;
+	  }
+	};
+
+	/**
+	 * Is the given string a member of this set?
+	 *
+	 * @param String aStr
+	 */
+	ArraySet.prototype.has = function ArraySet_has(aStr) {
+	  var sStr = util.toSetString(aStr);
+	  return has.call(this._set, sStr);
+	};
+
+	/**
+	 * What is the index of the given string in the array?
+	 *
+	 * @param String aStr
+	 */
+	ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
+	  var sStr = util.toSetString(aStr);
+	  if (has.call(this._set, sStr)) {
+	    return this._set[sStr];
+	  }
+	  throw new Error('"' + aStr + '" is not in the set.');
+	};
+
+	/**
+	 * What is the element at the given index?
+	 *
+	 * @param Number aIdx
+	 */
+	ArraySet.prototype.at = function ArraySet_at(aIdx) {
+	  if (aIdx >= 0 && aIdx < this._array.length) {
+	    return this._array[aIdx];
+	  }
+	  throw new Error('No element indexed by ' + aIdx);
+	};
+
+	/**
+	 * Returns the array representation of this set (which has the proper indices
+	 * indicated by indexOf). Note that this is a copy of the internal array used
+	 * for storing the members so that no one can mess with internal state.
+	 */
+	ArraySet.prototype.toArray = function ArraySet_toArray() {
+	  return this._array.slice();
+	};
+
+	exports.ArraySet = ArraySet;
+
+
+/***/ },
+/* 6 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* -*- Mode: js; js-indent-level: 2; -*- */
+	/*
+	 * Copyright 2014 Mozilla Foundation and contributors
+	 * Licensed under the New BSD license. See LICENSE or:
+	 * http://opensource.org/licenses/BSD-3-Clause
+	 */
+
+	var util = __webpack_require__(4);
+
+	/**
+	 * Determine whether mappingB is after mappingA with respect to generated
+	 * position.
+	 */
+	function generatedPositionAfter(mappingA, mappingB) {
+	  // Optimized for most common case
+	  var lineA = mappingA.generatedLine;
+	  var lineB = mappingB.generatedLine;
+	  var columnA = mappingA.generatedColumn;
+	  var columnB = mappingB.generatedColumn;
+	  return lineB > lineA || lineB == lineA && columnB >= columnA ||
+	         util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
+	}
+
+	/**
+	 * A data structure to provide a sorted view of accumulated mappings in a
+	 * performance conscious manner. It trades a neglibable overhead in general
+	 * case for a large speedup in case of mappings being added in order.
+	 */
+	function MappingList() {
+	  this._array = [];
+	  this._sorted = true;
+	  // Serves as infimum
+	  this._last = {generatedLine: -1, generatedColumn: 0};
+	}
+
+	/**
+	 * Iterate through internal items. This method takes the same arguments that
+	 * `Array.prototype.forEach` takes.
+	 *
+	 * NOTE: The order of the mappings is NOT guaranteed.
+	 */
+	MappingList.prototype.unsortedForEach =
+	  function MappingList_forEach(aCallback, aThisArg) {
+	    this._array.forEach(aCallback, aThisArg);
+	  };
+
+	/**
+	 * Add the given source mapping.
+	 *
+	 * @param Object aMapping
+	 */
+	MappingList.prototype.add = function MappingList_add(aMapping) {
+	  if (generatedPositionAfter(this._last, aMapping)) {
+	    this._last = aMapping;
+	    this._array.push(aMapping);
+	  } else {
+	    this._sorted = false;
+	    this._array.push(aMapping);
+	  }
+	};
+
+	/**
+	 * Returns the flat, sorted array of mappings. The mappings are sorted by
+	 * generated position.
+	 *
+	 * WARNING: This method returns internal data without copying, for
+	 * performance. The return value must NOT be mutated, and should be treated as
+	 * an immutable borrow. If you want to take ownership, you must make your own
+	 * copy.
+	 */
+	MappingList.prototype.toArray = function MappingList_toArray() {
+	  if (!this._sorted) {
+	    this._array.sort(util.compareByGeneratedPositionsInflated);
+	    this._sorted = true;
+	  }
+	  return this._array;
+	};
+
+	exports.MappingList = MappingList;
+
+
+/***/ },
+/* 7 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* -*- Mode: js; js-indent-level: 2; -*- */
+	/*
+	 * Copyright 2011 Mozilla Foundation and contributors
+	 * Licensed under the New BSD license. See LICENSE or:
+	 * http://opensource.org/licenses/BSD-3-Clause
+	 */
+
+	var util = __webpack_require__(4);
+	var binarySearch = __webpack_require__(8);
+	var ArraySet = __webpack_require__(5).ArraySet;
+	var base64VLQ = __webpack_require__(2);
+	var quickSort = __webpack_require__(9).quickSort;
+
+	function SourceMapConsumer(aSourceMap) {
+	  var sourceMap = aSourceMap;
+	  if (typeof aSourceMap === 'string') {
+	    sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ''));
+	  }
+
+	  return sourceMap.sections != null
+	    ? new IndexedSourceMapConsumer(sourceMap)
+	    : new BasicSourceMapConsumer(sourceMap);
+	}
+
+	SourceMapConsumer.fromSourceMap = function(aSourceMap) {
+	  return BasicSourceMapConsumer.fromSourceMap(aSourceMap);
+	}
+
+	/**
+	 * The version of the source mapping spec that we are consuming.
+	 */
+	SourceMapConsumer.prototype._version = 3;
+
+	// `__generatedMappings` and `__originalMappings` are arrays that hold the
+	// parsed mapping coordinates from the source map's "mappings" attribute. They
+	// are lazily instantiated, accessed via the `_generatedMappings` and
+	// `_originalMappings` getters respectively, and we only parse the mappings
+	// and create these arrays once queried for a source location. We jump through
+	// these hoops because there can be many thousands of mappings, and parsing
+	// them is expensive, so we only want to do it if we must.
+	//
+	// Each object in the arrays is of the form:
+	//
+	//     {
+	//       generatedLine: The line number in the generated code,
+	//       generatedColumn: The column number in the generated code,
+	//       source: The path to the original source file that generated this
+	//               chunk of code,
+	//       originalLine: The line number in the original source that
+	//                     corresponds to this chunk of generated code,
+	//       originalColumn: The column number in the original source that
+	//                       corresponds to this chunk of generated code,
+	//       name: The name of the original symbol which generated this chunk of
+	//             code.
+	//     }
+	//
+	// All properties except for `generatedLine` and `generatedColumn` can be
+	// `null`.
+	//
+	// `_generatedMappings` is ordered by the generated positions.
+	//
+	// `_originalMappings` is ordered by the original positions.
+
+	SourceMapConsumer.prototype.__generatedMappings = null;
+	Object.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {
+	  get: function () {
+	    if (!this.__generatedMappings) {
+	      this._parseMappings(this._mappings, this.sourceRoot);
+	    }
+
+	    return this.__generatedMappings;
+	  }
+	});
+
+	SourceMapConsumer.prototype.__originalMappings = null;
+	Object.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {
+	  get: function () {
+	    if (!this.__originalMappings) {
+	      this._parseMappings(this._mappings, this.sourceRoot);
+	    }
+
+	    return this.__originalMappings;
+	  }
+	});
+
+	SourceMapConsumer.prototype._charIsMappingSeparator =
+	  function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
+	    var c = aStr.charAt(index);
+	    return c === ";" || c === ",";
+	  };
+
+	/**
+	 * Parse the mappings in a string in to a data structure which we can easily
+	 * query (the ordered arrays in the `this.__generatedMappings` and
+	 * `this.__originalMappings` properties).
+	 */
+	SourceMapConsumer.prototype._parseMappings =
+	  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
+	    throw new Error("Subclasses must implement _parseMappings");
+	  };
+
+	SourceMapConsumer.GENERATED_ORDER = 1;
+	SourceMapConsumer.ORIGINAL_ORDER = 2;
+
+	SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
+	SourceMapConsumer.LEAST_UPPER_BOUND = 2;
+
+	/**
+	 * Iterate over each mapping between an original source/line/column and a
+	 * generated line/column in this source map.
+	 *
+	 * @param Function aCallback
+	 *        The function that is called with each mapping.
+	 * @param Object aContext
+	 *        Optional. If specified, this object will be the value of `this` every
+	 *        time that `aCallback` is called.
+	 * @param aOrder
+	 *        Either `SourceMapConsumer.GENERATED_ORDER` or
+	 *        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
+	 *        iterate over the mappings sorted by the generated file's line/column
+	 *        order or the original's source/line/column order, respectively. Defaults to
+	 *        `SourceMapConsumer.GENERATED_ORDER`.
+	 */
+	SourceMapConsumer.prototype.eachMapping =
+	  function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
+	    var context = aContext || null;
+	    var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
+
+	    var mappings;
+	    switch (order) {
+	    case SourceMapConsumer.GENERATED_ORDER:
+	      mappings = this._generatedMappings;
+	      break;
+	    case SourceMapConsumer.ORIGINAL_ORDER:
+	      mappings = this._originalMappings;
+	      break;
+	    default:
+	      throw new Error("Unknown order of iteration.");
+	    }
+
+	    var sourceRoot = this.sourceRoot;
+	    mappings.map(function (mapping) {
+	      var source = mapping.source === null ? null : this._sources.at(mapping.source);
+	      if (source != null && sourceRoot != null) {
+	        source = util.join(sourceRoot, source);
+	      }
+	      return {
+	        source: source,
+	        generatedLine: mapping.generatedLine,
+	        generatedColumn: mapping.generatedColumn,
+	        originalLine: mapping.originalLine,
+	        originalColumn: mapping.originalColumn,
+	        name: mapping.name === null ? null : this._names.at(mapping.name)
+	      };
+	    }, this).forEach(aCallback, context);
+	  };
+
+	/**
+	 * Returns all generated line and column information for the original source,
+	 * line, and column provided. If no column is provided, returns all mappings
+	 * corresponding to a either the line we are searching for or the next
+	 * closest line that has any mappings. Otherwise, returns all mappings
+	 * corresponding to the given line and either the column we are searching for
+	 * or the next closest column that has any offsets.
+	 *
+	 * The only argument is an object with the following properties:
+	 *
+	 *   - source: The filename of the original source.
+	 *   - line: The line number in the original source.
+	 *   - column: Optional. the column number in the original source.
+	 *
+	 * and an array of objects is returned, each with the following properties:
+	 *
+	 *   - line: The line number in the generated source, or null.
+	 *   - column: The column number in the generated source, or null.
+	 */
+	SourceMapConsumer.prototype.allGeneratedPositionsFor =
+	  function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
+	    var line = util.getArg(aArgs, 'line');
+
+	    // When there is no exact match, BasicSourceMapConsumer.prototype._findMapping
+	    // returns the index of the closest mapping less than the needle. By
+	    // setting needle.originalColumn to 0, we thus find the last mapping for
+	    // the given line, provided such a mapping exists.
+	    var needle = {
+	      source: util.getArg(aArgs, 'source'),
+	      originalLine: line,
+	      originalColumn: util.getArg(aArgs, 'column', 0)
+	    };
+
+	    if (this.sourceRoot != null) {
+	      needle.source = util.relative(this.sourceRoot, needle.source);
+	    }
+	    if (!this._sources.has(needle.source)) {
+	      return [];
+	    }
+	    needle.source = this._sources.indexOf(needle.source);
+
+	    var mappings = [];
+
+	    var index = this._findMapping(needle,
+	                                  this._originalMappings,
+	                                  "originalLine",
+	                                  "originalColumn",
+	                                  util.compareByOriginalPositions,
+	                                  binarySearch.LEAST_UPPER_BOUND);
+	    if (index >= 0) {
+	      var mapping = this._originalMappings[index];
+
+	      if (aArgs.column === undefined) {
+	        var originalLine = mapping.originalLine;
+
+	        // Iterate until either we run out of mappings, or we run into
+	        // a mapping for a different line than the one we found. Since
+	        // mappings are sorted, this is guaranteed to find all mappings for
+	        // the line we found.
+	        while (mapping && mapping.originalLine === originalLine) {
+	          mappings.push({
+	            line: util.getArg(mapping, 'generatedLine', null),
+	            column: util.getArg(mapping, 'generatedColumn', null),
+	            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
+	          });
+
+	          mapping = this._originalMappings[++index];
+	        }
+	      } else {
+	        var originalColumn = mapping.originalColumn;
+
+	        // Iterate until either we run out of mappings, or we run into
+	        // a mapping for a different line than the one we were searching for.
+	        // Since mappings are sorted, this is guaranteed to find all mappings for
+	        // the line we are searching for.
+	        while (mapping &&
+	               mapping.originalLine === line &&
+	               mapping.originalColumn == originalColumn) {
+	          mappings.push({
+	            line: util.getArg(mapping, 'generatedLine', null),
+	            column: util.getArg(mapping, 'generatedColumn', null),
+	            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
+	          });
+
+	          mapping = this._originalMappings[++index];
+	        }
+	      }
+	    }
+
+	    return mappings;
+	  };
+
+	exports.SourceMapConsumer = SourceMapConsumer;
+
+	/**
+	 * A BasicSourceMapConsumer instance represents a parsed source map which we can
+	 * query for information about the original file positions by giving it a file
+	 * position in the generated source.
+	 *
+	 * The only parameter is the raw source map (either as a JSON string, or
+	 * already parsed to an object). According to the spec, source maps have the
+	 * following attributes:
+	 *
+	 *   - version: Which version of the source map spec this map is following.
+	 *   - sources: An array of URLs to the original source files.
+	 *   - names: An array of identifiers which can be referrenced by individual mappings.
+	 *   - sourceRoot: Optional. The URL root from which all sources are relative.
+	 *   - sourcesContent: Optional. An array of contents of the original source files.
+	 *   - mappings: A string of base64 VLQs which contain the actual mappings.
+	 *   - file: Optional. The generated file this source map is associated with.
+	 *
+	 * Here is an example source map, taken from the source map spec[0]:
+	 *
+	 *     {
+	 *       version : 3,
+	 *       file: "out.js",
+	 *       sourceRoot : "",
+	 *       sources: ["foo.js", "bar.js"],
+	 *       names: ["src", "maps", "are", "fun"],
+	 *       mappings: "AA,AB;;ABCDE;"
+	 *     }
+	 *
+	 * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
+	 */
+	function BasicSourceMapConsumer(aSourceMap) {
+	  var sourceMap = aSourceMap;
+	  if (typeof aSourceMap === 'string') {
+	    sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ''));
+	  }
+
+	  var version = util.getArg(sourceMap, 'version');
+	  var sources = util.getArg(sourceMap, 'sources');
+	  // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which
+	  // requires the array) to play nice here.
+	  var names = util.getArg(sourceMap, 'names', []);
+	  var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);
+	  var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);
+	  var mappings = util.getArg(sourceMap, 'mappings');
+	  var file = util.getArg(sourceMap, 'file', null);
+
+	  // Once again, Sass deviates from the spec and supplies the version as a
+	  // string rather than a number, so we use loose equality checking here.
+	  if (version != this._version) {
+	    throw new Error('Unsupported version: ' + version);
+	  }
+
+	  sources = sources
+	    .map(String)
+	    // Some source maps produce relative source paths like "./foo.js" instead of
+	    // "foo.js".  Normalize these first so that future comparisons will succeed.
+	    // See bugzil.la/1090768.
+	    .map(util.normalize)
+	    // Always ensure that absolute sources are internally stored relative to
+	    // the source root, if the source root is absolute. Not doing this would
+	    // be particularly problematic when the source root is a prefix of the
+	    // source (valid, but why??). See github issue #199 and bugzil.la/1188982.
+	    .map(function (source) {
+	      return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source)
+	        ? util.relative(sourceRoot, source)
+	        : source;
+	    });
+
+	  // Pass `true` below to allow duplicate names and sources. While source maps
+	  // are intended to be compressed and deduplicated, the TypeScript compiler
+	  // sometimes generates source maps with duplicates in them. See Github issue
+	  // #72 and bugzil.la/889492.
+	  this._names = ArraySet.fromArray(names.map(String), true);
+	  this._sources = ArraySet.fromArray(sources, true);
+
+	  this.sourceRoot = sourceRoot;
+	  this.sourcesContent = sourcesContent;
+	  this._mappings = mappings;
+	  this.file = file;
+	}
+
+	BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
+	BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;
+
+	/**
+	 * Create a BasicSourceMapConsumer from a SourceMapGenerator.
+	 *
+	 * @param SourceMapGenerator aSourceMap
+	 *        The source map that will be consumed.
+	 * @returns BasicSourceMapConsumer
+	 */
+	BasicSourceMapConsumer.fromSourceMap =
+	  function SourceMapConsumer_fromSourceMap(aSourceMap) {
+	    var smc = Object.create(BasicSourceMapConsumer.prototype);
+
+	    var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);
+	    var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);
+	    smc.sourceRoot = aSourceMap._sourceRoot;
+	    smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),
+	                                                            smc.sourceRoot);
+	    smc.file = aSourceMap._file;
+
+	    // Because we are modifying the entries (by converting string sources and
+	    // names to indices into the sources and names ArraySets), we have to make
+	    // a copy of the entry or else bad things happen. Shared mutable state
+	    // strikes again! See github issue #191.
+
+	    var generatedMappings = aSourceMap._mappings.toArray().slice();
+	    var destGeneratedMappings = smc.__generatedMappings = [];
+	    var destOriginalMappings = smc.__originalMappings = [];
+
+	    for (var i = 0, length = generatedMappings.length; i < length; i++) {
+	      var srcMapping = generatedMappings[i];
+	      var destMapping = new Mapping;
+	      destMapping.generatedLine = srcMapping.generatedLine;
+	      destMapping.generatedColumn = srcMapping.generatedColumn;
+
+	      if (srcMapping.source) {
+	        destMapping.source = sources.indexOf(srcMapping.source);
+	        destMapping.originalLine = srcMapping.originalLine;
+	        destMapping.originalColumn = srcMapping.originalColumn;
+
+	        if (srcMapping.name) {
+	          destMapping.name = names.indexOf(srcMapping.name);
+	        }
+
+	        destOriginalMappings.push(destMapping);
+	      }
+
+	      destGeneratedMappings.push(destMapping);
+	    }
+
+	    quickSort(smc.__originalMappings, util.compareByOriginalPositions);
+
+	    return smc;
+	  };
+
+	/**
+	 * The version of the source mapping spec that we are consuming.
+	 */
+	BasicSourceMapConsumer.prototype._version = 3;
+
+	/**
+	 * The list of original sources.
+	 */
+	Object.defineProperty(BasicSourceMapConsumer.prototype, 'sources', {
+	  get: function () {
+	    return this._sources.toArray().map(function (s) {
+	      return this.sourceRoot != null ? util.join(this.sourceRoot, s) : s;
+	    }, this);
+	  }
+	});
+
+	/**
+	 * Provide the JIT with a nice shape / hidden class.
+	 */
+	function Mapping() {
+	  this.generatedLine = 0;
+	  this.generatedColumn = 0;
+	  this.source = null;
+	  this.originalLine = null;
+	  this.originalColumn = null;
+	  this.name = null;
+	}
+
+	/**
+	 * Parse the mappings in a string in to a data structure which we can easily
+	 * query (the ordered arrays in the `this.__generatedMappings` and
+	 * `this.__originalMappings` properties).
+	 */
+	BasicSourceMapConsumer.prototype._parseMappings =
+	  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
+	    var generatedLine = 1;
+	    var previousGeneratedColumn = 0;
+	    var previousOriginalLine = 0;
+	    var previousOriginalColumn = 0;
+	    var previousSource = 0;
+	    var previousName = 0;
+	    var length = aStr.length;
+	    var index = 0;
+	    var cachedSegments = {};
+	    var temp = {};
+	    var originalMappings = [];
+	    var generatedMappings = [];
+	    var mapping, str, segment, end, value;
+
+	    while (index < length) {
+	      if (aStr.charAt(index) === ';') {
+	        generatedLine++;
+	        index++;
+	        previousGeneratedColumn = 0;
+	      }
+	      else if (aStr.charAt(index) === ',') {
+	        index++;
+	      }
+	      else {
+	        mapping = new Mapping();
+	        mapping.generatedLine = generatedLine;
+
+	        // Because each offset is encoded relative to the previous one,
+	        // many segments often have the same encoding. We can exploit this
+	        // fact by caching the parsed variable length fields of each segment,
+	        // allowing us to avoid a second parse if we encounter the same
+	        // segment again.
+	        for (end = index; end < length; end++) {
+	          if (this._charIsMappingSeparator(aStr, end)) {
+	            break;
+	          }
+	        }
+	        str = aStr.slice(index, end);
+
+	        segment = cachedSegments[str];
+	        if (segment) {
+	          index += str.length;
+	        } else {
+	          segment = [];
+	          while (index < end) {
+	            base64VLQ.decode(aStr, index, temp);
+	            value = temp.value;
+	            index = temp.rest;
+	            segment.push(value);
+	          }
+
+	          if (segment.length === 2) {
+	            throw new Error('Found a source, but no line and column');
+	          }
+
+	          if (segment.length === 3) {
+	            throw new Error('Found a source and line, but no column');
+	          }
+
+	          cachedSegments[str] = segment;
+	        }
+
+	        // Generated column.
+	        mapping.generatedColumn = previousGeneratedColumn + segment[0];
+	        previousGeneratedColumn = mapping.generatedColumn;
+
+	        if (segment.length > 1) {
+	          // Original source.
+	          mapping.source = previousSource + segment[1];
+	          previousSource += segment[1];
+
+	          // Original line.
+	          mapping.originalLine = previousOriginalLine + segment[2];
+	          previousOriginalLine = mapping.originalLine;
+	          // Lines are stored 0-based
+	          mapping.originalLine += 1;
+
+	          // Original column.
+	          mapping.originalColumn = previousOriginalColumn + segment[3];
+	          previousOriginalColumn = mapping.originalColumn;
+
+	          if (segment.length > 4) {
+	            // Original name.
+	            mapping.name = previousName + segment[4];
+	            previousName += segment[4];
+	          }
+	        }
+
+	        generatedMappings.push(mapping);
+	        if (typeof mapping.originalLine === 'number') {
+	          originalMappings.push(mapping);
+	        }
+	      }
+	    }
+
+	    quickSort(generatedMappings, util.compareByGeneratedPositionsDeflated);
+	    this.__generatedMappings = generatedMappings;
+
+	    quickSort(originalMappings, util.compareByOriginalPositions);
+	    this.__originalMappings = originalMappings;
+	  };
+
+	/**
+	 * Find the mapping that best matches the hypothetical "needle" mapping that
+	 * we are searching for in the given "haystack" of mappings.
+	 */
+	BasicSourceMapConsumer.prototype._findMapping =
+	  function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,
+	                                         aColumnName, aComparator, aBias) {
+	    // To return the position we are searching for, we must first find the
+	    // mapping for the given position and then return the opposite position it
+	    // points to. Because the mappings are sorted, we can use binary search to
+	    // find the best mapping.
+
+	    if (aNeedle[aLineName] <= 0) {
+	      throw new TypeError('Line must be greater than or equal to 1, got '
+	                          + aNeedle[aLineName]);
+	    }
+	    if (aNeedle[aColumnName] < 0) {
+	      throw new TypeError('Column must be greater than or equal to 0, got '
+	                          + aNeedle[aColumnName]);
+	    }
+
+	    return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
+	  };
+
+	/**
+	 * Compute the last column for each generated mapping. The last column is
+	 * inclusive.
+	 */
+	BasicSourceMapConsumer.prototype.computeColumnSpans =
+	  function SourceMapConsumer_computeColumnSpans() {
+	    for (var index = 0; index < this._generatedMappings.length; ++index) {
+	      var mapping = this._generatedMappings[index];
+
+	      // Mappings do not contain a field for the last generated columnt. We
+	      // can come up with an optimistic estimate, however, by assuming that
+	      // mappings are contiguous (i.e. given two consecutive mappings, the
+	      // first mapping ends where the second one starts).
+	      if (index + 1 < this._generatedMappings.length) {
+	        var nextMapping = this._generatedMappings[index + 1];
+
+	        if (mapping.generatedLine === nextMapping.generatedLine) {
+	          mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
+	          continue;
+	        }
+	      }
+
+	      // The last mapping for each line spans the entire line.
+	      mapping.lastGeneratedColumn = Infinity;
+	    }
+	  };
+
+	/**
+	 * Returns the original source, line, and column information for the generated
+	 * source's line and column positions provided. The only argument is an object
+	 * with the following properties:
+	 *
+	 *   - line: The line number in the generated source.
+	 *   - column: The column number in the generated source.
+	 *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
+	 *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
+	 *     closest element that is smaller than or greater than the one we are
+	 *     searching for, respectively, if the exact element cannot be found.
+	 *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
+	 *
+	 * and an object is returned with the following properties:
+	 *
+	 *   - source: The original source file, or null.
+	 *   - line: The line number in the original source, or null.
+	 *   - column: The column number in the original source, or null.
+	 *   - name: The original identifier, or null.
+	 */
+	BasicSourceMapConsumer.prototype.originalPositionFor =
+	  function SourceMapConsumer_originalPositionFor(aArgs) {
+	    var needle = {
+	      generatedLine: util.getArg(aArgs, 'line'),
+	      generatedColumn: util.getArg(aArgs, 'column')
+	    };
+
+	    var index = this._findMapping(
+	      needle,
+	      this._generatedMappings,
+	      "generatedLine",
+	      "generatedColumn",
+	      util.compareByGeneratedPositionsDeflated,
+	      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)
+	    );
+
+	    if (index >= 0) {
+	      var mapping = this._generatedMappings[index];
+
+	      if (mapping.generatedLine === needle.generatedLine) {
+	        var source = util.getArg(mapping, 'source', null);
+	        if (source !== null) {
+	          source = this._sources.at(source);
+	          if (this.sourceRoot != null) {
+	            source = util.join(this.sourceRoot, source);
+	          }
+	        }
+	        var name = util.getArg(mapping, 'name', null);
+	        if (name !== null) {
+	          name = this._names.at(name);
+	        }
+	        return {
+	          source: source,
+	          line: util.getArg(mapping, 'originalLine', null),
+	          column: util.getArg(mapping, 'originalColumn', null),
+	          name: name
+	        };
+	      }
+	    }
+
+	    return {
+	      source: null,
+	      line: null,
+	      column: null,
+	      name: null
+	    };
+	  };
+
+	/**
+	 * Return true if we have the source content for every source in the source
+	 * map, false otherwise.
+	 */
+	BasicSourceMapConsumer.prototype.hasContentsOfAllSources =
+	  function BasicSourceMapConsumer_hasContentsOfAllSources() {
+	    if (!this.sourcesContent) {
+	      return false;
+	    }
+	    return this.sourcesContent.length >= this._sources.size() &&
+	      !this.sourcesContent.some(function (sc) { return sc == null; });
+	  };
+
+	/**
+	 * Returns the original source content. The only argument is the url of the
+	 * original source file. Returns null if no original source content is
+	 * available.
+	 */
+	BasicSourceMapConsumer.prototype.sourceContentFor =
+	  function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
+	    if (!this.sourcesContent) {
+	      return null;
+	    }
+
+	    if (this.sourceRoot != null) {
+	      aSource = util.relative(this.sourceRoot, aSource);
+	    }
+
+	    if (this._sources.has(aSource)) {
+	      return this.sourcesContent[this._sources.indexOf(aSource)];
+	    }
+
+	    var url;
+	    if (this.sourceRoot != null
+	        && (url = util.urlParse(this.sourceRoot))) {
+	      // XXX: file:// URIs and absolute paths lead to unexpected behavior for
+	      // many users. We can help them out when they expect file:// URIs to
+	      // behave like it would if they were running a local HTTP server. See
+	      // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.
+	      var fileUriAbsPath = aSource.replace(/^file:\/\//, "");
+	      if (url.scheme == "file"
+	          && this._sources.has(fileUriAbsPath)) {
+	        return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]
+	      }
+
+	      if ((!url.path || url.path == "/")
+	          && this._sources.has("/" + aSource)) {
+	        return this.sourcesContent[this._sources.indexOf("/" + aSource)];
+	      }
+	    }
+
+	    // This function is used recursively from
+	    // IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we
+	    // don't want to throw if we can't find the source - we just want to
+	    // return null, so we provide a flag to exit gracefully.
+	    if (nullOnMissing) {
+	      return null;
+	    }
+	    else {
+	      throw new Error('"' + aSource + '" is not in the SourceMap.');
+	    }
+	  };
+
+	/**
+	 * Returns the generated line and column information for the original source,
+	 * line, and column positions provided. The only argument is an object with
+	 * the following properties:
+	 *
+	 *   - source: The filename of the original source.
+	 *   - line: The line number in the original source.
+	 *   - column: The column number in the original source.
+	 *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
+	 *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
+	 *     closest element that is smaller than or greater than the one we are
+	 *     searching for, respectively, if the exact element cannot be found.
+	 *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
+	 *
+	 * and an object is returned with the following properties:
+	 *
+	 *   - line: The line number in the generated source, or null.
+	 *   - column: The column number in the generated source, or null.
+	 */
+	BasicSourceMapConsumer.prototype.generatedPositionFor =
+	  function SourceMapConsumer_generatedPositionFor(aArgs) {
+	    var source = util.getArg(aArgs, 'source');
+	    if (this.sourceRoot != null) {
+	      source = util.relative(this.sourceRoot, source);
+	    }
+	    if (!this._sources.has(source)) {
+	      return {
+	        line: null,
+	        column: null,
+	        lastColumn: null
+	      };
+	    }
+	    source = this._sources.indexOf(source);
+
+	    var needle = {
+	      source: source,
+	      originalLine: util.getArg(aArgs, 'line'),
+	      originalColumn: util.getArg(aArgs, 'column')
+	    };
+
+	    var index = this._findMapping(
+	      needle,
+	      this._originalMappings,
+	      "originalLine",
+	      "originalColumn",
+	      util.compareByOriginalPositions,
+	      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)
+	    );
+
+	    if (index >= 0) {
+	      var mapping = this._originalMappings[index];
+
+	      if (mapping.source === needle.source) {
+	        return {
+	          line: util.getArg(mapping, 'generatedLine', null),
+	          column: util.getArg(mapping, 'generatedColumn', null),
+	          lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
+	        };
+	      }
+	    }
+
+	    return {
+	      line: null,
+	      column: null,
+	      lastColumn: null
+	    };
+	  };
+
+	exports.BasicSourceMapConsumer = BasicSourceMapConsumer;
+
+	/**
+	 * An IndexedSourceMapConsumer instance represents a parsed source map which
+	 * we can query for information. It differs from BasicSourceMapConsumer in
+	 * that it takes "indexed" source maps (i.e. ones with a "sections" field) as
+	 * input.
+	 *
+	 * The only parameter is a raw source map (either as a JSON string, or already
+	 * parsed to an object). According to the spec for indexed source maps, they
+	 * have the following attributes:
+	 *
+	 *   - version: Which version of the source map spec this map is following.
+	 *   - file: Optional. The generated file this source map is associated with.
+	 *   - sections: A list of section definitions.
+	 *
+	 * Each value under the "sections" field has two fields:
+	 *   - offset: The offset into the original specified at which this section
+	 *       begins to apply, defined as an object with a "line" and "column"
+	 *       field.
+	 *   - map: A source map definition. This source map could also be indexed,
+	 *       but doesn't have to be.
+	 *
+	 * Instead of the "map" field, it's also possible to have a "url" field
+	 * specifying a URL to retrieve a source map from, but that's currently
+	 * unsupported.
+	 *
+	 * Here's an example source map, taken from the source map spec[0], but
+	 * modified to omit a section which uses the "url" field.
+	 *
+	 *  {
+	 *    version : 3,
+	 *    file: "app.js",
+	 *    sections: [{
+	 *      offset: {line:100, column:10},
+	 *      map: {
+	 *        version : 3,
+	 *        file: "section.js",
+	 *        sources: ["foo.js", "bar.js"],
+	 *        names: ["src", "maps", "are", "fun"],
+	 *        mappings: "AAAA,E;;ABCDE;"
+	 *      }
+	 *    }],
+	 *  }
+	 *
+	 * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt
+	 */
+	function IndexedSourceMapConsumer(aSourceMap) {
+	  var sourceMap = aSourceMap;
+	  if (typeof aSourceMap === 'string') {
+	    sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ''));
+	  }
+
+	  var version = util.getArg(sourceMap, 'version');
+	  var sections = util.getArg(sourceMap, 'sections');
+
+	  if (version != this._version) {
+	    throw new Error('Unsupported version: ' + version);
+	  }
+
+	  this._sources = new ArraySet();
+	  this._names = new ArraySet();
+
+	  var lastOffset = {
+	    line: -1,
+	    column: 0
+	  };
+	  this._sections = sections.map(function (s) {
+	    if (s.url) {
+	      // The url field will require support for asynchronicity.
+	      // See https://github.com/mozilla/source-map/issues/16
+	      throw new Error('Support for url field in sections not implemented.');
+	    }
+	    var offset = util.getArg(s, 'offset');
+	    var offsetLine = util.getArg(offset, 'line');
+	    var offsetColumn = util.getArg(offset, 'column');
+
+	    if (offsetLine < lastOffset.line ||
+	        (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {
+	      throw new Error('Section offsets must be ordered and non-overlapping.');
+	    }
+	    lastOffset = offset;
+
+	    return {
+	      generatedOffset: {
+	        // The offset fields are 0-based, but we use 1-based indices when
+	        // encoding/decoding from VLQ.
+	        generatedLine: offsetLine + 1,
+	        generatedColumn: offsetColumn + 1
+	      },
+	      consumer: new SourceMapConsumer(util.getArg(s, 'map'))
+	    }
+	  });
+	}
+
+	IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
+	IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;
+
+	/**
+	 * The version of the source mapping spec that we are consuming.
+	 */
+	IndexedSourceMapConsumer.prototype._version = 3;
+
+	/**
+	 * The list of original sources.
+	 */
+	Object.defineProperty(IndexedSourceMapConsumer.prototype, 'sources', {
+	  get: function () {
+	    var sources = [];
+	    for (var i = 0; i < this._sections.length; i++) {
+	      for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {
+	        sources.push(this._sections[i].consumer.sources[j]);
+	      }
+	    }
+	    return sources;
+	  }
+	});
+
+	/**
+	 * Returns the original source, line, and column information for the generated
+	 * source's line and column positions provided. The only argument is an object
+	 * with the following properties:
+	 *
+	 *   - line: The line number in the generated source.
+	 *   - column: The column number in the generated source.
+	 *
+	 * and an object is returned with the following properties:
+	 *
+	 *   - source: The original source file, or null.
+	 *   - line: The line number in the original source, or null.
+	 *   - column: The column number in the original source, or null.
+	 *   - name: The original identifier, or null.
+	 */
+	IndexedSourceMapConsumer.prototype.originalPositionFor =
+	  function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
+	    var needle = {
+	      generatedLine: util.getArg(aArgs, 'line'),
+	      generatedColumn: util.getArg(aArgs, 'column')
+	    };
+
+	    // Find the section containing the generated position we're trying to map
+	    // to an original position.
+	    var sectionIndex = binarySearch.search(needle, this._sections,
+	      function(needle, section) {
+	        var cmp = needle.generatedLine - section.generatedOffset.generatedLine;
+	        if (cmp) {
+	          return cmp;
+	        }
+
+	        return (needle.generatedColumn -
+	                section.generatedOffset.generatedColumn);
+	      });
+	    var section = this._sections[sectionIndex];
+
+	    if (!section) {
+	      return {
+	        source: null,
+	        line: null,
+	        column: null,
+	        name: null
+	      };
+	    }
+
+	    return section.consumer.originalPositionFor({
+	      line: needle.generatedLine -
+	        (section.generatedOffset.generatedLine - 1),
+	      column: needle.generatedColumn -
+	        (section.generatedOffset.generatedLine === needle.generatedLine
+	         ? section.generatedOffset.generatedColumn - 1
+	         : 0),
+	      bias: aArgs.bias
+	    });
+	  };
+
+	/**
+	 * Return true if we have the source content for every source in the source
+	 * map, false otherwise.
+	 */
+	IndexedSourceMapConsumer.prototype.hasContentsOfAllSources =
+	  function IndexedSourceMapConsumer_hasContentsOfAllSources() {
+	    return this._sections.every(function (s) {
+	      return s.consumer.hasContentsOfAllSources();
+	    });
+	  };
+
+	/**
+	 * Returns the original source content. The only argument is the url of the
+	 * original source file. Returns null if no original source content is
+	 * available.
+	 */
+	IndexedSourceMapConsumer.prototype.sourceContentFor =
+	  function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
+	    for (var i = 0; i < this._sections.length; i++) {
+	      var section = this._sections[i];
+
+	      var content = section.consumer.sourceContentFor(aSource, true);
+	      if (content) {
+	        return content;
+	      }
+	    }
+	    if (nullOnMissing) {
+	      return null;
+	    }
+	    else {
+	      throw new Error('"' + aSource + '" is not in the SourceMap.');
+	    }
+	  };
+
+	/**
+	 * Returns the generated line and column information for the original source,
+	 * line, and column positions provided. The only argument is an object with
+	 * the following properties:
+	 *
+	 *   - source: The filename of the original source.
+	 *   - line: The line number in the original source.
+	 *   - column: The column number in the original source.
+	 *
+	 * and an object is returned with the following properties:
+	 *
+	 *   - line: The line number in the generated source, or null.
+	 *   - column: The column number in the generated source, or null.
+	 */
+	IndexedSourceMapConsumer.prototype.generatedPositionFor =
+	  function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
+	    for (var i = 0; i < this._sections.length; i++) {
+	      var section = this._sections[i];
+
+	      // Only consider this section if the requested source is in the list of
+	      // sources of the consumer.
+	      if (section.consumer.sources.indexOf(util.getArg(aArgs, 'source')) === -1) {
+	        continue;
+	      }
+	      var generatedPosition = section.consumer.generatedPositionFor(aArgs);
+	      if (generatedPosition) {
+	        var ret = {
+	          line: generatedPosition.line +
+	            (section.generatedOffset.generatedLine - 1),
+	          column: generatedPosition.column +
+	            (section.generatedOffset.generatedLine === generatedPosition.line
+	             ? section.generatedOffset.generatedColumn - 1
+	             : 0)
+	        };
+	        return ret;
+	      }
+	    }
+
+	    return {
+	      line: null,
+	      column: null
+	    };
+	  };
+
+	/**
+	 * Parse the mappings in a string in to a data structure which we can easily
+	 * query (the ordered arrays in the `this.__generatedMappings` and
+	 * `this.__originalMappings` properties).
+	 */
+	IndexedSourceMapConsumer.prototype._parseMappings =
+	  function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {
+	    this.__generatedMappings = [];
+	    this.__originalMappings = [];
+	    for (var i = 0; i < this._sections.length; i++) {
+	      var section = this._sections[i];
+	      var sectionMappings = section.consumer._generatedMappings;
+	      for (var j = 0; j < sectionMappings.length; j++) {
+	        var mapping = sectionMappings[j];
+
+	        var source = section.consumer._sources.at(mapping.source);
+	        if (section.consumer.sourceRoot !== null) {
+	          source = util.join(section.consumer.sourceRoot, source);
+	        }
+	        this._sources.add(source);
+	        source = this._sources.indexOf(source);
+
+	        var name = section.consumer._names.at(mapping.name);
+	        this._names.add(name);
+	        name = this._names.indexOf(name);
+
+	        // The mappings coming from the consumer for the section have
+	        // generated positions relative to the start of the section, so we
+	        // need to offset them to be relative to the start of the concatenated
+	        // generated file.
+	        var adjustedMapping = {
+	          source: source,
+	          generatedLine: mapping.generatedLine +
+	            (section.generatedOffset.generatedLine - 1),
+	          generatedColumn: mapping.generatedColumn +
+	            (section.generatedOffset.generatedLine === mapping.generatedLine
+	            ? section.generatedOffset.generatedColumn - 1
+	            : 0),
+	          originalLine: mapping.originalLine,
+	          originalColumn: mapping.originalColumn,
+	          name: name
+	        };
+
+	        this.__generatedMappings.push(adjustedMapping);
+	        if (typeof adjustedMapping.originalLine === 'number') {
+	          this.__originalMappings.push(adjustedMapping);
+	        }
+	      }
+	    }
+
+	    quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);
+	    quickSort(this.__originalMappings, util.compareByOriginalPositions);
+	  };
+
+	exports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;
+
+
+/***/ },
+/* 8 */
+/***/ function(module, exports) {
+
+	/* -*- Mode: js; js-indent-level: 2; -*- */
+	/*
+	 * Copyright 2011 Mozilla Foundation and contributors
+	 * Licensed under the New BSD license. See LICENSE or:
+	 * http://opensource.org/licenses/BSD-3-Clause
+	 */
+
+	exports.GREATEST_LOWER_BOUND = 1;
+	exports.LEAST_UPPER_BOUND = 2;
+
+	/**
+	 * Recursive implementation of binary search.
+	 *
+	 * @param aLow Indices here and lower do not contain the needle.
+	 * @param aHigh Indices here and higher do not contain the needle.
+	 * @param aNeedle The element being searched for.
+	 * @param aHaystack The non-empty array being searched.
+	 * @param aCompare Function which takes two elements and returns -1, 0, or 1.
+	 * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
+	 *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
+	 *     closest element that is smaller than or greater than the one we are
+	 *     searching for, respectively, if the exact element cannot be found.
+	 */
+	function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
+	  // This function terminates when one of the following is true:
+	  //
+	  //   1. We find the exact element we are looking for.
+	  //
+	  //   2. We did not find the exact element, but we can return the index of
+	  //      the next-closest element.
+	  //
+	  //   3. We did not find the exact element, and there is no next-closest
+	  //      element than the one we are searching for, so we return -1.
+	  var mid = Math.floor((aHigh - aLow) / 2) + aLow;
+	  var cmp = aCompare(aNeedle, aHaystack[mid], true);
+	  if (cmp === 0) {
+	    // Found the element we are looking for.
+	    return mid;
+	  }
+	  else if (cmp > 0) {
+	    // Our needle is greater than aHaystack[mid].
+	    if (aHigh - mid > 1) {
+	      // The element is in the upper half.
+	      return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
+	    }
+
+	    // The exact needle element was not found in this haystack. Determine if
+	    // we are in termination case (3) or (2) and return the appropriate thing.
+	    if (aBias == exports.LEAST_UPPER_BOUND) {
+	      return aHigh < aHaystack.length ? aHigh : -1;
+	    } else {
+	      return mid;
+	    }
+	  }
+	  else {
+	    // Our needle is less than aHaystack[mid].
+	    if (mid - aLow > 1) {
+	      // The element is in the lower half.
+	      return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
+	    }
+
+	    // we are in termination case (3) or (2) and return the appropriate thing.
+	    if (aBias == exports.LEAST_UPPER_BOUND) {
+	      return mid;
+	    } else {
+	      return aLow < 0 ? -1 : aLow;
+	    }
+	  }
+	}
+
+	/**
+	 * This is an implementation of binary search which will always try and return
+	 * the index of the closest element if there is no exact hit. This is because
+	 * mappings between original and generated line/col pairs are single points,
+	 * and there is an implicit region between each of them, so a miss just means
+	 * that you aren't on the very start of a region.
+	 *
+	 * @param aNeedle The element you are looking for.
+	 * @param aHaystack The array that is being searched.
+	 * @param aCompare A function which takes the needle and an element in the
+	 *     array and returns -1, 0, or 1 depending on whether the needle is less
+	 *     than, equal to, or greater than the element, respectively.
+	 * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
+	 *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
+	 *     closest element that is smaller than or greater than the one we are
+	 *     searching for, respectively, if the exact element cannot be found.
+	 *     Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.
+	 */
+	exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
+	  if (aHaystack.length === 0) {
+	    return -1;
+	  }
+
+	  var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack,
+	                              aCompare, aBias || exports.GREATEST_LOWER_BOUND);
+	  if (index < 0) {
+	    return -1;
+	  }
+
+	  // We have found either the exact element, or the next-closest element than
+	  // the one we are searching for. However, there may be more than one such
+	  // element. Make sure we always return the smallest of these.
+	  while (index - 1 >= 0) {
+	    if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {
+	      break;
+	    }
+	    --index;
+	  }
+
+	  return index;
+	};
+
+
+/***/ },
+/* 9 */
+/***/ function(module, exports) {
+
+	/* -*- Mode: js; js-indent-level: 2; -*- */
+	/*
+	 * Copyright 2011 Mozilla Foundation and contributors
+	 * Licensed under the New BSD license. See LICENSE or:
+	 * http://opensource.org/licenses/BSD-3-Clause
+	 */
+
+	// It turns out that some (most?) JavaScript engines don't self-host
+	// `Array.prototype.sort`. This makes sense because C++ will likely remain
+	// faster than JS when doing raw CPU-intensive sorting. However, when using a
+	// custom comparator function, calling back and forth between the VM's C++ and
+	// JIT'd JS is rather slow *and* loses JIT type information, resulting in
+	// worse generated code for the comparator function than would be optimal. In
+	// fact, when sorting with a comparator, these costs outweigh the benefits of
+	// sorting in C++. By using our own JS-implemented Quick Sort (below), we get
+	// a ~3500ms mean speed-up in `bench/bench.html`.
+
+	/**
+	 * Swap the elements indexed by `x` and `y` in the array `ary`.
+	 *
+	 * @param {Array} ary
+	 *        The array.
+	 * @param {Number} x
+	 *        The index of the first item.
+	 * @param {Number} y
+	 *        The index of the second item.
+	 */
+	function swap(ary, x, y) {
+	  var temp = ary[x];
+	  ary[x] = ary[y];
+	  ary[y] = temp;
+	}
+
+	/**
+	 * Returns a random integer within the range `low .. high` inclusive.
+	 *
+	 * @param {Number} low
+	 *        The lower bound on the range.
+	 * @param {Number} high
+	 *        The upper bound on the range.
+	 */
+	function randomIntInRange(low, high) {
+	  return Math.round(low + (Math.random() * (high - low)));
+	}
+
+	/**
+	 * The Quick Sort algorithm.
+	 *
+	 * @param {Array} ary
+	 *        An array to sort.
+	 * @param {function} comparator
+	 *        Function to use to compare two items.
+	 * @param {Number} p
+	 *        Start index of the array
+	 * @param {Number} r
+	 *        End index of the array
+	 */
+	function doQuickSort(ary, comparator, p, r) {
+	  // If our lower bound is less than our upper bound, we (1) partition the
+	  // array into two pieces and (2) recurse on each half. If it is not, this is
+	  // the empty array and our base case.
+
+	  if (p < r) {
+	    // (1) Partitioning.
+	    //
+	    // The partitioning chooses a pivot between `p` and `r` and moves all
+	    // elements that are less than or equal to the pivot to the before it, and
+	    // all the elements that are greater than it after it. The effect is that
+	    // once partition is done, the pivot is in the exact place it will be when
+	    // the array is put in sorted order, and it will not need to be moved
+	    // again. This runs in O(n) time.
+
+	    // Always choose a random pivot so that an input array which is reverse
+	    // sorted does not cause O(n^2) running time.
+	    var pivotIndex = randomIntInRange(p, r);
+	    var i = p - 1;
+
+	    swap(ary, pivotIndex, r);
+	    var pivot = ary[r];
+
+	    // Immediately after `j` is incremented in this loop, the following hold
+	    // true:
+	    //
+	    //   * Every element in `ary[p .. i]` is less than or equal to the pivot.
+	    //
+	    //   * Every element in `ary[i+1 .. j-1]` is greater than the pivot.
+	    for (var j = p; j < r; j++) {
+	      if (comparator(ary[j], pivot) <= 0) {
+	        i += 1;
+	        swap(ary, i, j);
+	      }
+	    }
+
+	    swap(ary, i + 1, j);
+	    var q = i + 1;
+
+	    // (2) Recurse on each half.
+
+	    doQuickSort(ary, comparator, p, q - 1);
+	    doQuickSort(ary, comparator, q + 1, r);
+	  }
+	}
+
+	/**
+	 * Sort the given array in-place with the given comparator function.
+	 *
+	 * @param {Array} ary
+	 *        An array to sort.
+	 * @param {function} comparator
+	 *        Function to use to compare two items.
+	 */
+	exports.quickSort = function (ary, comparator) {
+	  doQuickSort(ary, comparator, 0, ary.length - 1);
+	};
+
+
+/***/ },
+/* 10 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* -*- Mode: js; js-indent-level: 2; -*- */
+	/*
+	 * Copyright 2011 Mozilla Foundation and contributors
+	 * Licensed under the New BSD license. See LICENSE or:
+	 * http://opensource.org/licenses/BSD-3-Clause
+	 */
+
+	var SourceMapGenerator = __webpack_require__(1).SourceMapGenerator;
+	var util = __webpack_require__(4);
+
+	// Matches a Windows-style `\r\n` newline or a `\n` newline used by all other
+	// operating systems these days (capturing the result).
+	var REGEX_NEWLINE = /(\r?\n)/;
+
+	// Newline character code for charCodeAt() comparisons
+	var NEWLINE_CODE = 10;
+
+	// Private symbol for identifying `SourceNode`s when multiple versions of
+	// the source-map library are loaded. This MUST NOT CHANGE across
+	// versions!
+	var isSourceNode = "$$$isSourceNode$$$";
+
+	/**
+	 * SourceNodes provide a way to abstract over interpolating/concatenating
+	 * snippets of generated JavaScript source code while maintaining the line and
+	 * column information associated with the original source code.
+	 *
+	 * @param aLine The original line number.
+	 * @param aColumn The original column number.
+	 * @param aSource The original source's filename.
+	 * @param aChunks Optional. An array of strings which are snippets of
+	 *        generated JS, or other SourceNodes.
+	 * @param aName The original identifier.
+	 */
+	function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
+	  this.children = [];
+	  this.sourceContents = {};
+	  this.line = aLine == null ? null : aLine;
+	  this.column = aColumn == null ? null : aColumn;
+	  this.source = aSource == null ? null : aSource;
+	  this.name = aName == null ? null : aName;
+	  this[isSourceNode] = true;
+	  if (aChunks != null) this.add(aChunks);
+	}
+
+	/**
+	 * Creates a SourceNode from generated code and a SourceMapConsumer.
+	 *
+	 * @param aGeneratedCode The generated code
+	 * @param aSourceMapConsumer The SourceMap for the generated code
+	 * @param aRelativePath Optional. The path that relative sources in the
+	 *        SourceMapConsumer should be relative to.
+	 */
+	SourceNode.fromStringWithSourceMap =
+	  function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
+	    // The SourceNode we want to fill with the generated code
+	    // and the SourceMap
+	    var node = new SourceNode();
+
+	    // All even indices of this array are one line of the generated code,
+	    // while all odd indices are the newlines between two adjacent lines
+	    // (since `REGEX_NEWLINE` captures its match).
+	    // Processed fragments are removed from this array, by calling `shiftNextLine`.
+	    var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
+	    var shiftNextLine = function() {
+	      var lineContents = remainingLines.shift();
+	      // The last line of a file might not have a newline.
+	      var newLine = remainingLines.shift() || "";
+	      return lineContents + newLine;
+	    };
+
+	    // We need to remember the position of "remainingLines"
+	    var lastGeneratedLine = 1, lastGeneratedColumn = 0;
+
+	    // The generate SourceNodes we need a code range.
+	    // To extract it current and last mapping is used.
+	    // Here we store the last mapping.
+	    var lastMapping = null;
+
+	    aSourceMapConsumer.eachMapping(function (mapping) {
+	      if (lastMapping !== null) {
+	        // We add the code from "lastMapping" to "mapping":
+	        // First check if there is a new line in between.
+	        if (lastGeneratedLine < mapping.generatedLine) {
+	          // Associate first line with "lastMapping"
+	          addMappingWithCode(lastMapping, shiftNextLine());
+	          lastGeneratedLine++;
+	          lastGeneratedColumn = 0;
+	          // The remaining code is added without mapping
+	        } else {
+	          // There is no new line in between.
+	          // Associate the code between "lastGeneratedColumn" and
+	          // "mapping.generatedColumn" with "lastMapping"
+	          var nextLine = remainingLines[0];
+	          var code = nextLine.substr(0, mapping.generatedColumn -
+	                                        lastGeneratedColumn);
+	          remainingLines[0] = nextLine.substr(mapping.generatedColumn -
+	                                              lastGeneratedColumn);
+	          lastGeneratedColumn = mapping.generatedColumn;
+	          addMappingWithCode(lastMapping, code);
+	          // No more remaining code, continue
+	          lastMapping = mapping;
+	          return;
+	        }
+	      }
+	      // We add the generated code until the first mapping
+	      // to the SourceNode without any mapping.
+	      // Each line is added as separate string.
+	      while (lastGeneratedLine < mapping.generatedLine) {
+	        node.add(shiftNextLine());
+	        lastGeneratedLine++;
+	      }
+	      if (lastGeneratedColumn < mapping.generatedColumn) {
+	        var nextLine = remainingLines[0];
+	        node.add(nextLine.substr(0, mapping.generatedColumn));
+	        remainingLines[0] = nextLine.substr(mapping.generatedColumn);
+	        lastGeneratedColumn = mapping.generatedColumn;
+	      }
+	      lastMapping = mapping;
+	    }, this);
+	    // We have processed all mappings.
+	    if (remainingLines.length > 0) {
+	      if (lastMapping) {
+	        // Associate the remaining code in the current line with "lastMapping"
+	        addMappingWithCode(lastMapping, shiftNextLine());
+	      }
+	      // and add the remaining lines without any mapping
+	      node.add(remainingLines.join(""));
+	    }
+
+	    // Copy sourcesContent into SourceNode
+	    aSourceMapConsumer.sources.forEach(function (sourceFile) {
+	      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+	      if (content != null) {
+	        if (aRelativePath != null) {
+	          sourceFile = util.join(aRelativePath, sourceFile);
+	        }
+	        node.setSourceContent(sourceFile, content);
+	      }
+	    });
+
+	    return node;
+
+	    function addMappingWithCode(mapping, code) {
+	      if (mapping === null || mapping.source === undefined) {
+