953 files changed, 95589 insertions, 0 deletions

diff --git a/node_modules/@babel/code-frame/README.md b/node_modules/@babel/code-frame/README.md
new file mode 100644
index 00000000..818b78a0
--- /dev/null
+++ b/node_modules/@babel/code-frame/README.md
@@ -0,0 +1,142 @@
+# @babel/code-frame
+
+> Generate errors that contain a code frame that point to source locations.
+
+## Install
+
+```sh
+npm install --save-dev @babel/code-frame
+```
+
+## Usage
+
+```js
+import { codeFrameColumns } from '@babel/code-frame';
+
+const rawLines = `class Foo {
+  constructor()
+}`;
+const location = { start: { line: 2, column: 16 } };
+
+const result = codeFrameColumns(rawLines, location, { /* options */ });
+
+console.log(result);
+```
+
+```
+  1 | class Foo {
+> 2 |   constructor()
+    |                ^
+  3 | }
+```
+
+If the column number is not known, you may omit it.
+
+You can also pass an `end` hash in `location`.
+
+```js
+import { codeFrameColumns } from '@babel/code-frame';
+
+const rawLines = `class Foo {
+  constructor() {
+    console.log("hello");
+  }
+}`;
+const location = { start: { line: 2, column: 17 }, end: { line: 4, column: 3 } };
+
+const result = codeFrameColumns(rawLines, location, { /* options */ });
+
+console.log(result);
+```
+
+```
+  1 | class Foo {
+> 2 |   constructor() {
+    |                 ^
+> 3 |     console.log("hello");
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^
+> 4 |   }
+    | ^^^
+  5 | };
+```
+
+## Options
+
+### `highlightCode`
+
+`boolean`, defaults to `false`.
+
+Toggles syntax highlighting the code as JavaScript for terminals.
+
+
+### `linesAbove`
+
+`number`, defaults to `2`.
+
+Adjust the number of lines to show above the error.
+
+### `linesBelow`
+
+`number`, defaults to `3`.
+
+Adjust the number of lines to show below the error.
+
+### `forceColor`
+
+`boolean`, defaults to `false`.
+
+Enable this to forcibly syntax highlight the code as JavaScript (for non-terminals); overrides `highlightCode`.
+
+### `message`
+
+`string`, otherwise nothing
+
+Pass in a string to be displayed inline (if possible) next to the highlighted
+location in the code. If it can't be positioned inline, it will be placed above
+the code frame.
+
+```
+1 | class Foo {
+> 2 |   constructor()
+  |                ^ Missing {
+3 | };
+```
+
+## Upgrading from prior versions
+
+Prior to version 7, the only API exposed by this module was for a single line and optional column pointer. The old API will now log a deprecation warning.
+
+The new API takes a `location` object, similar to what is available in an AST.
+
+This is an example of the deprecated (but still available) API:
+
+```js
+import codeFrame from '@babel/code-frame';
+
+const rawLines = `class Foo {
+  constructor()
+}`;
+const lineNumber = 2;
+const colNumber = 16;
+
+const result = codeFrame(rawLines, lineNumber, colNumber, { /* options */ });
+
+console.log(result);
+```
+
+To get the same highlighting using the new API:
+
+```js
+import { codeFrameColumns } from '@babel/code-frame';
+
+const rawLines = `class Foo {
+  constructor() {
+    console.log("hello");
+  }
+}`;
+const location = { start: { line: 2, column: 16 } };
+
+const result = codeFrameColumns(rawLines, location, { /* options */ });
+
+console.log(result);
+```
diff --git a/node_modules/@babel/code-frame/lib/index.js b/node_modules/@babel/code-frame/lib/index.js
new file mode 100644
index 00000000..18b2ae89
--- /dev/null
+++ b/node_modules/@babel/code-frame/lib/index.js
@@ -0,0 +1,177 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.codeFrameColumns = codeFrameColumns;
+exports.default = _default;
+
+function _highlight() {
+  const data = _interopRequireWildcard(require("@babel/highlight"));
+
+  _highlight = function _highlight() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+let deprecationWarningShown = false;
+
+function getDefs(chalk) {
+  return {
+    gutter: chalk.grey,
+    marker: chalk.red.bold,
+    message: chalk.red.bold
+  };
+}
+
+const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
+
+function getMarkerLines(loc, source, opts) {
+  const startLoc = Object.assign({
+    column: 0,
+    line: -1
+  }, loc.start);
+  const endLoc = Object.assign({}, startLoc, loc.end);
+
+  const _ref = opts || {},
+        _ref$linesAbove = _ref.linesAbove,
+        linesAbove = _ref$linesAbove === void 0 ? 2 : _ref$linesAbove,
+        _ref$linesBelow = _ref.linesBelow,
+        linesBelow = _ref$linesBelow === void 0 ? 3 : _ref$linesBelow;
+
+  const startLine = startLoc.line;
+  const startColumn = startLoc.column;
+  const endLine = endLoc.line;
+  const endColumn = endLoc.column;
+  let start = Math.max(startLine - (linesAbove + 1), 0);
+  let end = Math.min(source.length, endLine + linesBelow);
+
+  if (startLine === -1) {
+    start = 0;
+  }
+
+  if (endLine === -1) {
+    end = source.length;
+  }
+
+  const lineDiff = endLine - startLine;
+  const markerLines = {};
+
+  if (lineDiff) {
+    for (let i = 0; i <= lineDiff; i++) {
+      const lineNumber = i + startLine;
+
+      if (!startColumn) {
+        markerLines[lineNumber] = true;
+      } else if (i === 0) {
+        const sourceLength = source[lineNumber - 1].length;
+        markerLines[lineNumber] = [startColumn, sourceLength - startColumn];
+      } else if (i === lineDiff) {
+        markerLines[lineNumber] = [0, endColumn];
+      } else {
+        const sourceLength = source[lineNumber - i].length;
+        markerLines[lineNumber] = [0, sourceLength];
+      }
+    }
+  } else {
+    if (startColumn === endColumn) {
+      if (startColumn) {
+        markerLines[startLine] = [startColumn, 0];
+      } else {
+        markerLines[startLine] = true;
+      }
+    } else {
+      markerLines[startLine] = [startColumn, endColumn - startColumn];
+    }
+  }
+
+  return {
+    start,
+    end,
+    markerLines
+  };
+}
+
+function codeFrameColumns(rawLines, loc, opts = {}) {
+  const highlighted = (opts.highlightCode || opts.forceColor) && (0, _highlight().shouldHighlight)(opts);
+  const chalk = (0, _highlight().getChalk)(opts);
+  const defs = getDefs(chalk);
+
+  const maybeHighlight = (chalkFn, string) => {
+    return highlighted ? chalkFn(string) : string;
+  };
+
+  if (highlighted) rawLines = (0, _highlight().default)(rawLines, opts);
+  const lines = rawLines.split(NEWLINE);
+
+  const _getMarkerLines = getMarkerLines(loc, lines, opts),
+        start = _getMarkerLines.start,
+        end = _getMarkerLines.end,
+        markerLines = _getMarkerLines.markerLines;
+
+  const hasColumns = loc.start && typeof loc.start.column === "number";
+  const numberMaxWidth = String(end).length;
+  let frame = lines.slice(start, end).map((line, index) => {
+    const number = start + 1 + index;
+    const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
+    const gutter = ` ${paddedNumber} | `;
+    const hasMarker = markerLines[number];
+    const lastMarkerLine = !markerLines[number + 1];
+
+    if (hasMarker) {
+      let markerLine = "";
+
+      if (Array.isArray(hasMarker)) {
+        const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " ");
+        const numberOfMarkers = hasMarker[1] || 1;
+        markerLine = ["\n ", maybeHighlight(defs.gutter, gutter.replace(/\d/g, " ")), markerSpacing, maybeHighlight(defs.marker, "^").repeat(numberOfMarkers)].join("");
+
+        if (lastMarkerLine && opts.message) {
+          markerLine += " " + maybeHighlight(defs.message, opts.message);
+        }
+      }
+
+      return [maybeHighlight(defs.marker, ">"), maybeHighlight(defs.gutter, gutter), line, markerLine].join("");
+    } else {
+      return ` ${maybeHighlight(defs.gutter, gutter)}${line}`;
+    }
+  }).join("\n");
+
+  if (opts.message && !hasColumns) {
+    frame = `${" ".repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`;
+  }
+
+  if (highlighted) {
+    return chalk.reset(frame);
+  } else {
+    return frame;
+  }
+}
+
+function _default(rawLines, lineNumber, colNumber, opts = {}) {
+  if (!deprecationWarningShown) {
+    deprecationWarningShown = true;
+    const message = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.";
+
+    if (process.emitWarning) {
+      process.emitWarning(message, "DeprecationWarning");
+    } else {
+      const deprecationError = new Error(message);
+      deprecationError.name = "DeprecationWarning";
+      console.warn(new Error(message));
+    }
+  }
+
+  colNumber = Math.max(colNumber, 0);
+  const location = {
+    start: {
+      column: colNumber,
+      line: lineNumber
+    }
+  };
+  return codeFrameColumns(rawLines, location, opts);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/code-frame/package.json b/node_modules/@babel/code-frame/package.json
new file mode 100644
index 00000000..9dd743a1
--- /dev/null
+++ b/node_modules/@babel/code-frame/package.json
@@ -0,0 +1,17 @@
+{
+  "name": "@babel/code-frame",
+  "version": "7.0.0-beta.47",
+  "description": "Generate errors that contain a code frame that point to source locations.",
+  "author": "Sebastian McKenzie <sebmck@gmail.com>",
+  "homepage": "https://babeljs.io/",
+  "license": "MIT",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-code-frame",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/highlight": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "chalk": "^2.0.0",
+    "strip-ansi": "^4.0.0"
+  }
+}
diff --git a/node_modules/@babel/core/README.md b/node_modules/@babel/core/README.md
new file mode 100644
index 00000000..ec13d84e
--- /dev/null
+++ b/node_modules/@babel/core/README.md
@@ -0,0 +1,250 @@
+# @babel/core
+
+> Babel compiler core.
+
+
+```javascript
+var babel = require("@babel/core");
+import { transform } from "@babel/core";
+import * as babel from "@babel/core";
+```
+
+All transformations will use your local configuration files (`.babelrc` or in `package.json`). See [options](#options) to disable it.
+
+
+## babel.transform(code: string, [options?](#options): Object, callback: Function)
+
+Transforms the passed in `code`. Calling a callback with an object with the generated code,
+source map, and AST.
+
+```js
+babel.transform(code, options, function(err, result) {
+  result; // => { code, map, ast }
+});
+```
+
+**Example**
+
+```js
+babel.transform("code();", options, function(err, result) {
+  result.code;
+  result.map;
+  result.ast;
+});
+```
+
+### Compat Note:
+
+In Babel 6, this method was synchronous and `transformSync` did not exist. For backward-compatibility,
+this function will behave synchronously if no callback is given. If you're starting with Babel 7
+and need synchronous behavior, please use `transformSync` since this backward-compat may be dropped in
+future major versions of Babel.
+
+
+## babel.transformSync(code: string, [options?](#options): Object)
+
+Transforms the passed in `code`. Returning an object with the generated code,
+source map, and AST.
+
+```js
+babel.transformSync(code, options) // => { code, map, ast }
+```
+
+**Example**
+
+```js
+var result = babel.transformSync("code();", options);
+result.code;
+result.map;
+result.ast;
+```
+
+
+## babel.transformFile(filename: string, [options?](#options): Object, callback: Function)
+
+Asynchronously transforms the entire contents of a file.
+
+```js
+babel.transformFile(filename, options, callback)
+```
+
+**Example**
+
+```js
+babel.transformFile("filename.js", options, function (err, result) {
+  result; // => { code, map, ast }
+});
+```
+
+
+## babel.transformFileSync(filename: string, [options?](#options): Object)
+
+Synchronous version of `babel.transformFile`. Returns the transformed contents of
+the `filename`.
+
+```js
+babel.transformFileSync(filename, options) // => { code, map, ast }
+```
+
+**Example**
+
+```js
+babel.transformFileSync("filename.js", options).code;
+```
+
+
+## babel.transformFromAst(ast: Object, code?: string, [options?](#options): Object, callback: Function): FileNode | null
+
+Given an [AST](https://astexplorer.net/), transform it.
+
+```js
+const sourceCode = "if (true) return;";
+const parsedAst = babylon.parse(sourceCode, { allowReturnOutsideFunction: true });
+babel.transformFromAst(parsedAst, sourceCode, options, function(err, result) {
+  const { code, map, ast } = result;
+});
+```
+
+### Compat Note:
+
+In Babel 6, this method was synchronous and `transformFromAstSync` did not exist. For backward-compatibility,
+this function will behave synchronously if no callback is given. If you're starting with Babel 7
+and need synchronous behavior, please use `transformFromAstSync` since this backward-compat may be dropped in
+future major versions of Babel.
+
+
+## babel.transformFromAstSync(ast: Object, code?: string, [options?](#options): Object)
+
+Given an [AST](https://astexplorer.net/), transform it.
+
+```js
+const sourceCode = "if (true) return;";
+const parsedAst = babylon.parse(sourceCode, { allowReturnOutsideFunction: true });
+const { code, map, ast } = babel.transformFromAstSync(parsedAst, sourceCode, options);
+```
+
+## babel.parse(code: string, [options?](#options): Object)
+
+Given some code, parse it using Babel's standard behavior. Referenced presets and
+plugins will be loaded such that optional syntax plugins are automatically
+enabled.
+
+
+## Advanced APIs
+
+Many systems that wrap Babel like to automatically inject plugins and presets,
+or override options. To accomplish this goal, Babel exposes several functions
+that aid in loading the configuration part-way without transforming.
+
+### babel.loadOptions([options?](#options): Object)
+
+Resolve Babel's options fully, resulting in an options object where:
+
+* `opts.plugins` is a full list of `Plugin` instances.
+* `opts.presets` is empty and all presets are flattened into `opts`.
+* It can be safely passed back to Babel. Fields like `babelrc` have been set to 
+  false so that later calls to Babel will not make a second attempt to load
+  config files.
+
+`Plugin` instances aren't meant to be manipulated directly, but often
+callers will serialize this `opts` to JSON to use it as a cache key representing
+the options Babel has received. Caching on this isn't 100% guaranteed to
+invalidate properly, but it is the best we have at the moment.
+
+
+### babel.loadPartialConfig([options?](#options): Object): PartialConfig
+
+To allow systems to easily manipulate and validate a user's config, this function
+resolves the plugins and presets and proceeds no further. The expectation is
+that callers will take the config's `.options`, manipulate it as then see fit
+and pass it back to Babel again.
+
+* `babelrc: string | void` - The path of the `.babelrc` file, if there was one.
+* `babelignore: string | void` - The path of the `.babelignore` file, if there was one.
+* `options: ValidatedOptions` - The partially resolved options, which can be manipulated and passed back to Babel again.
+  * `plugins: Array<ConfigItem>` - See below.
+  * `presets: Array<ConfigItem>` - See below.
+  * It can be safely passed back to Babel. Fields like `babelrc` have been set
+    to false so that later calls to Babel will not make a second attempt to 
+    load config files.
+* `hasFilesystemConfig(): boolean` - Check if the resolved config loaded any settings from the filesystem.
+
+[`ConfigItem`](#configitem-type) instances expose properties to introspect the values, but each
+item should be treated as immutable. If changes are desired, the item should be
+removed from the list and replaced with either a normal Babel config value, or
+with a replacement item created by `babel.createConfigItem`. See that
+function for information about `ConfigItem` fields.
+
+
+### babel.createConfigItem(value: string | {} | Function | [string | {} | Function, {} | void], { dirname?: string, type?: "preset" | "plugin" }): ConfigItem
+
+Allows build tooling to create and cache config items up front. If this function
+is called multiple times for a given plugin, Babel will call the plugin's function itself
+multiple times. If you have a clear set of expected plugins and presets to
+inject, pre-constructing the config items would be recommended.
+
+
+### `ConfigItem` type
+
+Each `ConfigItem` exposes all of the information Babel knows. The fields are:
+
+* `value: {} | Function` - The resolved value of the plugin.
+* `options: {} | void` - The options object passed to the plugin.
+* `dirname: string` - The path that the options are relative to.
+* `name: string | void` - The name that the user gave the plugin instance, e.g. `plugins: [ ['env', {}, 'my-env'] ]` 
+* `file: Object | void` - Information about the plugin's file, if Babel knows it.
+  * `request: string` - The file that the user requested, e.g. `"@babel/env"`
+  * `resolved: string` - The full path of the resolved file, e.g. `"/tmp/node_modules/@babel/preset-env/lib/index.js"`
+
+
+## Options
+
+<blockquote class="babel-callout babel-callout-info">
+  <h4>Babel CLI</h4>
+  <p>
+    You can pass these options from the Babel CLI like so:
+  </p>
+  <p>
+    <code>babel --option-name<span class="o">=</span>value</code>
+  </p>
+</blockquote>
+
+Following is a table of the options you can use:
+
+| Option                   | Default              | Description                     |
+| ------------------------ | -------------------- | ------------------------------- |
+| `ast`                    | `false`              | Include the AST in the returned object |
+| `auxiliaryCommentAfter`  | `null`               | Attach a comment after all non-user injected code |
+| `auxiliaryCommentBefore` | `null`               | Attach a comment before all non-user injected code |
+| `root`                   | `"."`                | Specify the "root" folder that defines the location to search for "babel.config.js", and the default folder to allow `.babelrc` files inside of.|
+| `configFile`             | `undefined`          | The config file to load Babel's config from. Defaults to searching for "babel.config.js" inside the "root" folder. `false` will disable searching for config files.|
+| `babelrc`                | `true`               | Specify whether or not to use .babelrc and .babelignore files. Not available when using the CLI, [use `--no-babelrc` instead](https://babeljs.io/docs/usage/cli/#babel-ignoring-babelrc) |
+| `babelrcRoots`           | `(root)`             | Specify which packages should be search for .babelrc files when they are being compiled. `true` to _always_ search, or a path string or an array of paths to packages to search inside of. Defaults to only searching the "root" package. |
+| `envName`                | env vars             | Defaults to environment variable `BABEL_ENV` if set, or else `NODE_ENV` if set, or else it defaults to `"development"` |
+| `code`                   | `true`               | Enable code generation |
+| `comments`               | `true`               | Output comments in generated output |
+| `compact`                | `"auto"`             | Do not include superfluous whitespace characters and line terminators. When set to `"auto"` compact is set to `true` on input sizes of >500KB |
+| `env`                    | `{}`                 | This is an object of keys that represent different environments. For example, you may have: `{ env: { production: { /* specific options */ } } }` which will use those options when the `envName` is `production` |
+| `extends`                | `null`               | A path to a `.babelrc` file to extend |
+| `filename`               | `"unknown"`          | Filename for use in errors etc |
+| `filenameRelative`       | `(filename)`         | Filename relative to `sourceRoot` |
+| `generatorOpts`          | `{}`                 | An object containing the options to be passed down to the babel code generator, @babel/generator |
+| `getModuleId`            | `null`               | Specify a custom callback to generate a module id with. Called as `getModuleId(moduleName)`. If falsy value is returned then the generated module id is used |
+| `highlightCode`          | `true`               | ANSI highlight syntax error code frames |
+| `ignore`                 | `null`               | Opposite to the `only` option. `ignore` is disregarded if `only` is specified |
+| `inputSourceMap`         | `null`               | A source map object that the output source map will be based on |
+| `minified`               | `false`              | Should the output be minified (not printing last semicolons in blocks, printing literal string values instead of escaped ones, stripping `()` from `new` when safe) |
+| `moduleId`               | `null`               | Specify a custom name for module ids |
+| `moduleIds`              | `false`              | If truthy, insert an explicit id for modules. By default, all modules are anonymous. (Not available for `common` modules) |
+| `moduleRoot`             | `(sourceRoot)`       | Optional prefix for the AMD module formatter that will be prepend to the filename on module definitions |
+| `only`                   | `null`               | A [glob](https://github.com/isaacs/minimatch), regex, or mixed array of both, matching paths to **only** compile. Can also be an array of arrays containing paths to explicitly match. When attempting to compile a non-matching file it's returned verbatim |
+| `parserOpts`             | `{}`                 | An object containing the options to be passed down to the babel parser, babylon |
+| `plugins`                | `[]`                 | List of [plugins](https://babeljs.io/docs/plugins/) to load and use |
+| `presets`                | `[]`                 | List of [presets](https://babeljs.io/docs/plugins/#presets) (a set of plugins) to load and use |
+| `retainLines`            | `false`              | Retain line numbers. This will lead to wacky code but is handy for scenarios where you can't use source maps. (**NOTE:** This will not retain the columns) |
+| `shouldPrintComment`     | `null`               | An optional callback that controls whether a comment should be output or not. Called as `shouldPrintComment(commentContents)`. **NOTE:** This overrides the `comment` option when used |
+| `sourceFileName`         | `(filenameRelative)` | Set `sources[0]` on returned source map |
+| `sourceMaps`             | `false`              | If truthy, adds a `map` property to returned output. If set to `"inline"`, a comment with a sourceMappingURL directive is added to the bottom of the returned code. If set to `"both"` then a `map` property is returned as well as a source map comment appended. **This does not emit sourcemap files by itself!** To have sourcemaps emitted using the CLI, you must pass it the `--source-maps` option |
+| `sourceRoot`             | `(moduleRoot)`       | The root from which all sources are relative |
+| `sourceType`             | `"module"`           | Indicate the mode the code should be parsed in. Can be one of "script", "module", or "unambiguous". `"unambiguous"` will make Babel attempt to _guess_, based on the presence of ES6 `import` or `export` statements. Files with ES6 `import`s and `export`s are considered `"module"` and are otherwise `"script"`. |
+| `wrapPluginVisitorMethod`| `null`               | An optional callback that can be used to wrap visitor methods. **NOTE:** This is useful for things like introspection, and not really needed for implementing anything. Called as `wrapPluginVisitorMethod(pluginAlias, visitorType, callback)`.
diff --git a/node_modules/@babel/core/lib/config/caching.js b/node_modules/@babel/core/lib/config/caching.js
new file mode 100644
index 00000000..d092b2d0
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/caching.js
@@ -0,0 +1,200 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeStrongCache = makeStrongCache;
+exports.makeWeakCache = makeWeakCache;
+
+function makeStrongCache(handler) {
+  return makeCachedFunction(new Map(), handler);
+}
+
+function makeWeakCache(handler) {
+  return makeCachedFunction(new WeakMap(), handler);
+}
+
+function makeCachedFunction(callCache, handler) {
+  return function cachedFunction(arg, data) {
+    let cachedValue = callCache.get(arg);
+
+    if (cachedValue) {
+      for (var _iterator = cachedValue, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+        var _ref2;
+
+        if (_isArray) {
+          if (_i >= _iterator.length) break;
+          _ref2 = _iterator[_i++];
+        } else {
+          _i = _iterator.next();
+          if (_i.done) break;
+          _ref2 = _i.value;
+        }
+
+        const _ref = _ref2;
+        const value = _ref.value,
+              valid = _ref.valid;
+        if (valid(data)) return value;
+      }
+    }
+
+    const cache = new CacheConfigurator(data);
+    const value = handler(arg, cache);
+    if (!cache.configured()) cache.forever();
+    cache.deactivate();
+
+    switch (cache.mode()) {
+      case "forever":
+        cachedValue = [{
+          value,
+          valid: () => true
+        }];
+        callCache.set(arg, cachedValue);
+        break;
+
+      case "invalidate":
+        cachedValue = [{
+          value,
+          valid: cache.validator()
+        }];
+        callCache.set(arg, cachedValue);
+        break;
+
+      case "valid":
+        if (cachedValue) {
+          cachedValue.push({
+            value,
+            valid: cache.validator()
+          });
+        } else {
+          cachedValue = [{
+            value,
+            valid: cache.validator()
+          }];
+          callCache.set(arg, cachedValue);
+        }
+
+    }
+
+    return value;
+  };
+}
+
+class CacheConfigurator {
+  constructor(data) {
+    this._active = true;
+    this._never = false;
+    this._forever = false;
+    this._invalidate = false;
+    this._configured = false;
+    this._pairs = [];
+    this._data = data;
+  }
+
+  simple() {
+    return makeSimpleConfigurator(this);
+  }
+
+  mode() {
+    if (this._never) return "never";
+    if (this._forever) return "forever";
+    if (this._invalidate) return "invalidate";
+    return "valid";
+  }
+
+  forever() {
+    if (!this._active) {
+      throw new Error("Cannot change caching after evaluation has completed.");
+    }
+
+    if (this._never) {
+      throw new Error("Caching has already been configured with .never()");
+    }
+
+    this._forever = true;
+    this._configured = true;
+  }
+
+  never() {
+    if (!this._active) {
+      throw new Error("Cannot change caching after evaluation has completed.");
+    }
+
+    if (this._forever) {
+      throw new Error("Caching has already been configured with .forever()");
+    }
+
+    this._never = true;
+    this._configured = true;
+  }
+
+  using(handler) {
+    if (!this._active) {
+      throw new Error("Cannot change caching after evaluation has completed.");
+    }
+
+    if (this._never || this._forever) {
+      throw new Error("Caching has already been configured with .never or .forever()");
+    }
+
+    this._configured = true;
+    const key = handler(this._data);
+
+    this._pairs.push([key, handler]);
+
+    return key;
+  }
+
+  invalidate(handler) {
+    if (!this._active) {
+      throw new Error("Cannot change caching after evaluation has completed.");
+    }
+
+    if (this._never || this._forever) {
+      throw new Error("Caching has already been configured with .never or .forever()");
+    }
+
+    this._invalidate = true;
+    this._configured = true;
+    const key = handler(this._data);
+
+    this._pairs.push([key, handler]);
+
+    return key;
+  }
+
+  validator() {
+    const pairs = this._pairs;
+    return data => pairs.every(([key, fn]) => key === fn(data));
+  }
+
+  deactivate() {
+    this._active = false;
+  }
+
+  configured() {
+    return this._configured;
+  }
+
+}
+
+function makeSimpleConfigurator(cache) {
+  function cacheFn(val) {
+    if (typeof val === "boolean") {
+      if (val) cache.forever();else cache.never();
+      return;
+    }
+
+    return cache.using(val);
+  }
+
+  cacheFn.forever = () => cache.forever();
+
+  cacheFn.never = () => cache.never();
+
+  cacheFn.using = cb => cache.using(() => cb());
+
+  cacheFn.invalidate = cb => cache.invalidate(() => cb());
+
+  return cacheFn;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/config-chain.js b/node_modules/@babel/core/lib/config/config-chain.js
new file mode 100644
index 00000000..22bca2bd
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/config-chain.js
@@ -0,0 +1,487 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildRootChain = buildRootChain;
+exports.buildPresetChain = void 0;
+
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+
+  _path = function _path() {
+    return data;
+  };
+
+  return data;
+}
+
+function _micromatch() {
+  const data = _interopRequireDefault(require("micromatch"));
+
+  _micromatch = function _micromatch() {
+    return data;
+  };
+
+  return data;
+}
+
+function _debug() {
+  const data = _interopRequireDefault(require("debug"));
+
+  _debug = function _debug() {
+    return data;
+  };
+
+  return data;
+}
+
+var _options = require("./validation/options");
+
+var _files = require("./files");
+
+var _caching = require("./caching");
+
+var _configDescriptors = require("./config-descriptors");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const debug = (0, _debug().default)("babel:config:config-chain");
+const buildPresetChain = makeChainWalker({
+  init: arg => arg,
+  root: preset => loadPresetDescriptors(preset),
+  env: (preset, envName) => loadPresetEnvDescriptors(preset)(envName),
+  overrides: (preset, index) => loadPresetOverridesDescriptors(preset)(index),
+  overridesEnv: (preset, index, envName) => loadPresetOverridesEnvDescriptors(preset)(index)(envName)
+});
+exports.buildPresetChain = buildPresetChain;
+const loadPresetDescriptors = (0, _caching.makeWeakCache)(preset => buildRootDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors));
+const loadPresetEnvDescriptors = (0, _caching.makeWeakCache)(preset => (0, _caching.makeStrongCache)(envName => buildEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, envName)));
+const loadPresetOverridesDescriptors = (0, _caching.makeWeakCache)(preset => (0, _caching.makeStrongCache)(index => buildOverrideDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index)));
+const loadPresetOverridesEnvDescriptors = (0, _caching.makeWeakCache)(preset => (0, _caching.makeStrongCache)(index => (0, _caching.makeStrongCache)(envName => buildOverrideEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index, envName))));
+
+function buildRootChain(opts, context) {
+  const programmaticChain = loadProgrammaticChain({
+    options: opts,
+    dirname: context.cwd
+  }, context);
+  if (!programmaticChain) return null;
+  const _opts$root = opts.root,
+        rootDir = _opts$root === void 0 ? "." : _opts$root,
+        _opts$configFile = opts.configFile,
+        configFileName = _opts$configFile === void 0 ? true : _opts$configFile;
+  let babelrc = opts.babelrc,
+      babelrcRoots = opts.babelrcRoots;
+
+  const absoluteRoot = _path().default.resolve(context.cwd, rootDir);
+
+  let configFile;
+
+  if (typeof configFileName === "string") {
+    configFile = (0, _files.loadConfig)(configFileName, context.cwd, context.envName);
+  } else if (configFileName === true) {
+    configFile = (0, _files.findRootConfig)(absoluteRoot, context.envName);
+  }
+
+  const configFileChain = emptyChain();
+
+  if (configFile) {
+    const validatedFile = validateConfigFile(configFile);
+    const result = loadFileChain(validatedFile, context);
+    if (!result) return null;
+
+    if (babelrc === undefined) {
+      babelrc = validatedFile.options.babelrc;
+    }
+
+    if (babelrcRoots === undefined) {
+      babelrcRoots = validatedFile.options.babelrcRoots;
+    }
+
+    mergeChain(configFileChain, result);
+  }
+
+  const pkgData = typeof context.filename === "string" ? (0, _files.findPackageData)(context.filename) : null;
+  let ignoreFile, babelrcFile;
+  const fileChain = emptyChain();
+
+  if ((babelrc === true || babelrc === undefined) && pkgData && babelrcLoadEnabled(context, pkgData, babelrcRoots, absoluteRoot)) {
+    var _findRelativeConfig = (0, _files.findRelativeConfig)(pkgData, context.envName);
+
+    ignoreFile = _findRelativeConfig.ignore;
+    babelrcFile = _findRelativeConfig.config;
+
+    if (ignoreFile && shouldIgnore(context, ignoreFile.ignore, null, ignoreFile.dirname)) {
+      return null;
+    }
+
+    if (babelrcFile) {
+      const result = loadFileChain(validateBabelrcFile(babelrcFile), context);
+      if (!result) return null;
+      mergeChain(fileChain, result);
+    }
+  }
+
+  const chain = mergeChain(mergeChain(mergeChain(emptyChain(), configFileChain), fileChain), programmaticChain);
+  return {
+    plugins: dedupDescriptors(chain.plugins),
+    presets: dedupDescriptors(chain.presets),
+    options: chain.options.map(o => normalizeOptions(o)),
+    ignore: ignoreFile || undefined,
+    babelrc: babelrcFile || undefined,
+    config: configFile || undefined
+  };
+}
+
+function babelrcLoadEnabled(context, pkgData, babelrcRoots, absoluteRoot) {
+  if (typeof babelrcRoots === "boolean") return babelrcRoots;
+
+  if (babelrcRoots === undefined) {
+    return pkgData.directories.indexOf(absoluteRoot) !== -1;
+  }
+
+  let babelrcPatterns = babelrcRoots;
+  if (!Array.isArray(babelrcPatterns)) babelrcPatterns = [babelrcPatterns];
+  babelrcPatterns = babelrcPatterns.map(pat => _path().default.resolve(context.cwd, pat));
+
+  if (babelrcPatterns.length === 1 && babelrcPatterns[0] === absoluteRoot) {
+    return pkgData.directories.indexOf(absoluteRoot) !== -1;
+  }
+
+  return (0, _micromatch().default)(pkgData.directories, babelrcPatterns).length > 0;
+}
+
+const validateConfigFile = (0, _caching.makeWeakCache)(file => ({
+  filepath: file.filepath,
+  dirname: file.dirname,
+  options: (0, _options.validate)("configfile", file.options)
+}));
+const validateBabelrcFile = (0, _caching.makeWeakCache)(file => ({
+  filepath: file.filepath,
+  dirname: file.dirname,
+  options: (0, _options.validate)("babelrcfile", file.options)
+}));
+const validateExtendFile = (0, _caching.makeWeakCache)(file => ({
+  filepath: file.filepath,
+  dirname: file.dirname,
+  options: (0, _options.validate)("extendsfile", file.options)
+}));
+const loadProgrammaticChain = makeChainWalker({
+  root: input => buildRootDescriptors(input, "base", _configDescriptors.createCachedDescriptors),
+  env: (input, envName) => buildEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, envName),
+  overrides: (input, index) => buildOverrideDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index),
+  overridesEnv: (input, index, envName) => buildOverrideEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index, envName)
+});
+const loadFileChain = makeChainWalker({
+  root: file => loadFileDescriptors(file),
+  env: (file, envName) => loadFileEnvDescriptors(file)(envName),
+  overrides: (file, index) => loadFileOverridesDescriptors(file)(index),
+  overridesEnv: (file, index, envName) => loadFileOverridesEnvDescriptors(file)(index)(envName)
+});
+const loadFileDescriptors = (0, _caching.makeWeakCache)(file => buildRootDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors));
+const loadFileEnvDescriptors = (0, _caching.makeWeakCache)(file => (0, _caching.makeStrongCache)(envName => buildEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, envName)));
+const loadFileOverridesDescriptors = (0, _caching.makeWeakCache)(file => (0, _caching.makeStrongCache)(index => buildOverrideDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index)));
+const loadFileOverridesEnvDescriptors = (0, _caching.makeWeakCache)(file => (0, _caching.makeStrongCache)(index => (0, _caching.makeStrongCache)(envName => buildOverrideEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index, envName))));
+
+function buildRootDescriptors({
+  dirname,
+  options
+}, alias, descriptors) {
+  return descriptors(dirname, options, alias);
+}
+
+function buildEnvDescriptors({
+  dirname,
+  options
+}, alias, descriptors, envName) {
+  const opts = options.env && options.env[envName];
+  return opts ? descriptors(dirname, opts, `${alias}.env["${envName}"]`) : null;
+}
+
+function buildOverrideDescriptors({
+  dirname,
+  options
+}, alias, descriptors, index) {
+  const opts = options.overrides && options.overrides[index];
+  if (!opts) throw new Error("Assertion failure - missing override");
+  return descriptors(dirname, opts, `${alias}.overrides[${index}]`);
+}
+
+function buildOverrideEnvDescriptors({
+  dirname,
+  options
+}, alias, descriptors, index, envName) {
+  const override = options.overrides && options.overrides[index];
+  if (!override) throw new Error("Assertion failure - missing override");
+  const opts = override.env && override.env[envName];
+  return opts ? descriptors(dirname, opts, `${alias}.overrides[${index}].env["${envName}"]`) : null;
+}
+
+function makeChainWalker({
+  root,
+  env,
+  overrides,
+  overridesEnv
+}) {
+  return (input, context, files = new Set()) => {
+    const dirname = input.dirname;
+    const flattenedConfigs = [];
+    const rootOpts = root(input);
+
+    if (configIsApplicable(rootOpts, dirname, context)) {
+      flattenedConfigs.push(rootOpts);
+      const envOpts = env(input, context.envName);
+
+      if (envOpts && configIsApplicable(envOpts, dirname, context)) {
+        flattenedConfigs.push(envOpts);
+      }
+
+      (rootOpts.options.overrides || []).forEach((_, index) => {
+        const overrideOps = overrides(input, index);
+
+        if (configIsApplicable(overrideOps, dirname, context)) {
+          flattenedConfigs.push(overrideOps);
+          const overrideEnvOpts = overridesEnv(input, index, context.envName);
+
+          if (overrideEnvOpts && configIsApplicable(overrideEnvOpts, dirname, context)) {
+            flattenedConfigs.push(overrideEnvOpts);
+          }
+        }
+      });
+    }
+
+    if (flattenedConfigs.some(({
+      options: {
+        ignore,
+        only
+      }
+    }) => shouldIgnore(context, ignore, only, dirname))) {
+      return null;
+    }
+
+    const chain = emptyChain();
+
+    for (var _i = 0; _i < flattenedConfigs.length; _i++) {
+      const op = flattenedConfigs[_i];
+
+      if (!mergeExtendsChain(chain, op.options, dirname, context, files)) {
+        return null;
+      }
+
+      mergeChainOpts(chain, op);
+    }
+
+    return chain;
+  };
+}
+
+function mergeExtendsChain(chain, opts, dirname, context, files) {
+  if (opts.extends === undefined) return true;
+  const file = (0, _files.loadConfig)(opts.extends, dirname, context.envName);
+
+  if (files.has(file)) {
+    throw new Error(`Configuration cycle detected loading ${file.filepath}.\n` + `File already loaded following the config chain:\n` + Array.from(files, file => ` - ${file.filepath}`).join("\n"));
+  }
+
+  files.add(file);
+  const fileChain = loadFileChain(validateExtendFile(file), context, files);
+  files.delete(file);
+  if (!fileChain) return false;
+  mergeChain(chain, fileChain);
+  return true;
+}
+
+function mergeChain(target, source) {
+  target.options.push(...source.options);
+  target.plugins.push(...source.plugins);
+  target.presets.push(...source.presets);
+  return target;
+}
+
+function mergeChainOpts(target, {
+  options,
+  plugins,
+  presets
+}) {
+  target.options.push(options);
+  target.plugins.push(...plugins());
+  target.presets.push(...presets());
+  return target;
+}
+
+function emptyChain() {
+  return {
+    options: [],
+    presets: [],
+    plugins: []
+  };
+}
+
+function normalizeOptions(opts) {
+  const options = Object.assign({}, opts);
+  delete options.extends;
+  delete options.env;
+  delete options.plugins;
+  delete options.presets;
+  delete options.passPerPreset;
+  delete options.ignore;
+  delete options.only;
+
+  if (options.sourceMap) {
+    options.sourceMaps = options.sourceMap;
+    delete options.sourceMap;
+  }
+
+  return options;
+}
+
+function dedupDescriptors(items) {
+  const map = new Map();
+  const descriptors = [];
+
+  for (var _iterator = items, _isArray = Array.isArray(_iterator), _i2 = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref;
+
+    if (_isArray) {
+      if (_i2 >= _iterator.length) break;
+      _ref = _iterator[_i2++];
+    } else {
+      _i2 = _iterator.next();
+      if (_i2.done) break;
+      _ref = _i2.value;
+    }
+
+    const item = _ref;
+
+    if (typeof item.value === "function") {
+      const fnKey = item.value;
+      let nameMap = map.get(fnKey);
+
+      if (!nameMap) {
+        nameMap = new Map();
+        map.set(fnKey, nameMap);
+      }
+
+      let desc = nameMap.get(item.name);
+
+      if (!desc) {
+        desc = {
+          value: null
+        };
+        descriptors.push(desc);
+        if (!item.ownPass) nameMap.set(item.name, desc);
+      }
+
+      if (item.options === false) {
+        desc.value = null;
+      } else {
+        desc.value = item;
+      }
+    } else {
+      descriptors.push({
+        value: item
+      });
+    }
+  }
+
+  return descriptors.reduce((acc, desc) => {
+    if (desc.value) acc.push(desc.value);
+    return acc;
+  }, []);
+}
+
+function configIsApplicable({
+  options
+}, dirname, context) {
+  return (options.test === undefined || configFieldIsApplicable(context, options.test, dirname)) && (options.include === undefined || configFieldIsApplicable(context, options.include, dirname)) && (options.exclude === undefined || !configFieldIsApplicable(context, options.exclude, dirname));
+}
+
+function configFieldIsApplicable(context, test, dirname) {
+  if (context.filename === null) {
+    throw new Error(`Configuration contains explicit test/include/exclude checks, but no filename was passed to Babel`);
+  }
+
+  const ctx = context;
+  const patterns = Array.isArray(test) ? test : [test];
+  return matchesPatterns(ctx, patterns, dirname, false);
+}
+
+function shouldIgnore(context, ignore, only, dirname) {
+  if (ignore) {
+    if (context.filename === null) {
+      throw new Error(`Configuration contains ignore checks, but no filename was passed to Babel`);
+    }
+
+    const ctx = context;
+
+    if (matchesPatterns(ctx, ignore, dirname)) {
+      debug("Ignored %o because it matched one of %O from %o", context.filename, ignore, dirname);
+      return true;
+    }
+  }
+
+  if (only) {
+    if (context.filename === null) {
+      throw new Error(`Configuration contains ignore checks, but no filename was passed to Babel`);
+    }
+
+    const ctx = context;
+
+    if (!matchesPatterns(ctx, only, dirname)) {
+      debug("Ignored %o because it failed to match one of %O from %o", context.filename, only, dirname);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function matchesPatterns(context, patterns, dirname, allowNegation = true) {
+  const res = [];
+  const strings = [];
+  const fns = [];
+  patterns.forEach(pattern => {
+    if (typeof pattern === "string") strings.push(pattern);else if (typeof pattern === "function") fns.push(pattern);else res.push(pattern);
+  });
+  const filename = context.filename;
+  if (res.some(re => re.test(context.filename))) return true;
+  if (fns.some(fn => fn(filename))) return true;
+
+  if (strings.length > 0) {
+    const possibleDirs = getPossibleDirs(context);
+    const absolutePatterns = strings.map(pattern => {
+      const negate = pattern[0] === "!";
+
+      if (negate && !allowNegation) {
+        throw new Error(`Negation of file paths is not supported.`);
+      }
+
+      if (negate) pattern = pattern.slice(1);
+      return (negate ? "!" : "") + _path().default.resolve(dirname, pattern);
+    });
+
+    if ((0, _micromatch().default)(possibleDirs, absolutePatterns, {
+      nocase: true,
+      nonegate: !allowNegation
+    }).length > 0) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+const getPossibleDirs = (0, _caching.makeWeakCache)(context => {
+  let current = context.filename;
+  if (current === null) return [];
+  const possibleDirs = [current];
+
+  while (true) {
+    const previous = current;
+    current = _path().default.dirname(current);
+    if (previous === current) break;
+    possibleDirs.push(current);
+  }
+
+  return possibleDirs;
+});
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/config-descriptors.js b/node_modules/@babel/core/lib/config/config-descriptors.js
new file mode 100644
index 00000000..c4373f8b
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/config-descriptors.js
@@ -0,0 +1,206 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCachedDescriptors = createCachedDescriptors;
+exports.createUncachedDescriptors = createUncachedDescriptors;
+exports.createDescriptor = createDescriptor;
+
+var _files = require("./files");
+
+var _item = require("./item");
+
+var _caching = require("./caching");
+
+function createCachedDescriptors(dirname, options, alias) {
+  const plugins = options.plugins,
+        presets = options.presets,
+        passPerPreset = options.passPerPreset;
+  return {
+    options,
+    plugins: plugins ? () => createCachedPluginDescriptors(plugins, dirname)(alias) : () => [],
+    presets: presets ? () => createCachedPresetDescriptors(presets, dirname)(alias)(!!passPerPreset) : () => []
+  };
+}
+
+function createUncachedDescriptors(dirname, options, alias) {
+  let plugins;
+  let presets;
+  return {
+    options,
+    plugins: function (_plugins) {
+      function plugins() {
+        return _plugins.apply(this, arguments);
+      }
+
+      plugins.toString = function () {
+        return _plugins.toString();
+      };
+
+      return plugins;
+    }(() => {
+      if (!plugins) {
+        plugins = createPluginDescriptors(options.plugins || [], dirname, alias);
+      }
+
+      return plugins;
+    }),
+    presets: function (_presets) {
+      function presets() {
+        return _presets.apply(this, arguments);
+      }
+
+      presets.toString = function () {
+        return _presets.toString();
+      };
+
+      return presets;
+    }(() => {
+      if (!presets) {
+        presets = createPresetDescriptors(options.presets || [], dirname, alias, !!options.passPerPreset);
+      }
+
+      return presets;
+    })
+  };
+}
+
+const createCachedPresetDescriptors = (0, _caching.makeWeakCache)((items, cache) => {
+  const dirname = cache.using(dir => dir);
+  return (0, _caching.makeStrongCache)(alias => (0, _caching.makeStrongCache)(passPerPreset => createPresetDescriptors(items, dirname, alias, passPerPreset)));
+});
+const createCachedPluginDescriptors = (0, _caching.makeWeakCache)((items, cache) => {
+  const dirname = cache.using(dir => dir);
+  return (0, _caching.makeStrongCache)(alias => createPluginDescriptors(items, dirname, alias));
+});
+
+function createPresetDescriptors(items, dirname, alias, passPerPreset) {
+  return createDescriptors("preset", items, dirname, alias, passPerPreset);
+}
+
+function createPluginDescriptors(items, dirname, alias) {
+  return createDescriptors("plugin", items, dirname, alias);
+}
+
+function createDescriptors(type, items, dirname, alias, ownPass) {
+  const descriptors = items.map((item, index) => createDescriptor(item, dirname, {
+    type,
+    alias: `${alias}$${index}`,
+    ownPass: !!ownPass
+  }));
+  assertNoDuplicates(descriptors);
+  return descriptors;
+}
+
+function createDescriptor(pair, dirname, {
+  type,
+  alias,
+  ownPass
+}) {
+  const desc = (0, _item.getItemDescriptor)(pair);
+
+  if (desc) {
+    return desc;
+  }
+
+  let name;
+  let options;
+  let value = pair;
+
+  if (Array.isArray(value)) {
+    if (value.length === 3) {
+      var _value = value;
+      value = _value[0];
+      options = _value[1];
+      name = _value[2];
+    } else {
+      var _value2 = value;
+      value = _value2[0];
+      options = _value2[1];
+    }
+  }
+
+  let file = undefined;
+  let filepath = null;
+
+  if (typeof value === "string") {
+    if (typeof type !== "string") {
+      throw new Error("To resolve a string-based item, the type of item must be given");
+    }
+
+    const resolver = type === "plugin" ? _files.loadPlugin : _files.loadPreset;
+    const request = value;
+
+    var _resolver = resolver(value, dirname);
+
+    filepath = _resolver.filepath;
+    value = _resolver.value;
+    file = {
+      request,
+      resolved: filepath
+    };
+  }
+
+  if (!value) {
+    throw new Error(`Unexpected falsy value: ${String(value)}`);
+  }
+
+  if (typeof value === "object" && value.__esModule) {
+    if (value.default) {
+      value = value.default;
+    } else {
+      throw new Error("Must export a default export when using ES6 modules.");
+    }
+  }
+
+  if (typeof value !== "object" && typeof value !== "function") {
+    throw new Error(`Unsupported format: ${typeof value}. Expected an object or a function.`);
+  }
+
+  if (filepath !== null && typeof value === "object" && value) {
+    throw new Error(`Plugin/Preset files are not allowed to export objects, only functions. In ${filepath}`);
+  }
+
+  return {
+    name,
+    alias: filepath || alias,
+    value,
+    options,
+    dirname,
+    ownPass,
+    file
+  };
+}
+
+function assertNoDuplicates(items) {
+  const map = new Map();
+
+  for (var _iterator = items, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref;
+
+    if (_isArray) {
+      if (_i >= _iterator.length) break;
+      _ref = _iterator[_i++];
+    } else {
+      _i = _iterator.next();
+      if (_i.done) break;
+      _ref = _i.value;
+    }
+
+    const item = _ref;
+    if (typeof item.value !== "function") continue;
+    let nameMap = map.get(item.value);
+
+    if (!nameMap) {
+      nameMap = new Set();
+      map.set(item.value, nameMap);
+    }
+
+    if (nameMap.has(item.name)) {
+      throw new Error([`Duplicate plugin/preset detected.`, `If you'd like to use two separate instances of a plugin,`, `they neen separate names, e.g.`, ``, `  plugins: [`, `    ['some-plugin', {}],`, `    ['some-plugin', {}, 'some unique name'],`, `  ]`].join("\n"));
+    }
+
+    nameMap.add(item.name);
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/files/configuration.js b/node_modules/@babel/core/lib/config/files/configuration.js
new file mode 100644
index 00000000..e0667159
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/files/configuration.js
@@ -0,0 +1,306 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findRelativeConfig = findRelativeConfig;
+exports.findRootConfig = findRootConfig;
+exports.loadConfig = loadConfig;
+
+function _debug() {
+  const data = _interopRequireDefault(require("debug"));
+
+  _debug = function _debug() {
+    return data;
+  };
+
+  return data;
+}
+
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+
+  _path = function _path() {
+    return data;
+  };
+
+  return data;
+}
+
+function _fs() {
+  const data = _interopRequireDefault(require("fs"));
+
+  _fs = function _fs() {
+    return data;
+  };
+
+  return data;
+}
+
+function _json() {
+  const data = _interopRequireDefault(require("json5"));
+
+  _json = function _json() {
+    return data;
+  };
+
+  return data;
+}
+
+function _resolve() {
+  const data = _interopRequireDefault(require("resolve"));
+
+  _resolve = function _resolve() {
+    return data;
+  };
+
+  return data;
+}
+
+var _caching = require("../caching");
+
+var _configApi = _interopRequireDefault(require("../helpers/config-api"));
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const debug = (0, _debug().default)("babel:config:loading:files:configuration");
+const BABEL_CONFIG_JS_FILENAME = "babel.config.js";
+const BABELRC_FILENAME = ".babelrc";
+const BABELRC_JS_FILENAME = ".babelrc.js";
+const BABELIGNORE_FILENAME = ".babelignore";
+
+function findRelativeConfig(packageData, envName) {
+  let config = null;
+  let ignore = null;
+
+  const dirname = _path().default.dirname(packageData.filepath);
+
+  for (var _iterator = packageData.directories, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref;
+
+    if (_isArray) {
+      if (_i >= _iterator.length) break;
+      _ref = _iterator[_i++];
+    } else {
+      _i = _iterator.next();
+      if (_i.done) break;
+      _ref = _i.value;
+    }
+
+    const loc = _ref;
+
+    if (!config) {
+      config = [BABELRC_FILENAME, BABELRC_JS_FILENAME].reduce((previousConfig, name) => {
+        const filepath = _path().default.join(loc, name);
+
+        const config = readConfig(filepath, envName);
+
+        if (config && previousConfig) {
+          throw new Error(`Multiple configuration files found. Please remove one:\n` + ` - ${_path().default.basename(previousConfig.filepath)}\n` + ` - ${name}\n` + `from ${loc}`);
+        }
+
+        return config || previousConfig;
+      }, null);
+      const pkgConfig = packageData.pkg && packageData.pkg.dirname === loc ? packageToBabelConfig(packageData.pkg) : null;
+
+      if (pkgConfig) {
+        if (config) {
+          throw new Error(`Multiple configuration files found. Please remove one:\n` + ` - ${_path().default.basename(pkgConfig.filepath)}#babel\n` + ` - ${_path().default.basename(config.filepath)}\n` + `from ${loc}`);
+        }
+
+        config = pkgConfig;
+      }
+
+      if (config) {
+        debug("Found configuration %o from %o.", config.filepath, dirname);
+      }
+    }
+
+    if (!ignore) {
+      const ignoreLoc = _path().default.join(loc, BABELIGNORE_FILENAME);
+
+      ignore = readIgnoreConfig(ignoreLoc);
+
+      if (ignore) {
+        debug("Found ignore %o from %o.", ignore.filepath, dirname);
+      }
+    }
+  }
+
+  return {
+    config,
+    ignore
+  };
+}
+
+function findRootConfig(dirname, envName) {
+  const filepath = _path().default.resolve(dirname, BABEL_CONFIG_JS_FILENAME);
+
+  const conf = readConfig(filepath, envName);
+
+  if (conf) {
+    debug("Found root config %o in $o.", BABEL_CONFIG_JS_FILENAME, dirname);
+  }
+
+  return conf;
+}
+
+function loadConfig(name, dirname, envName) {
+  const filepath = _resolve().default.sync(name, {
+    basedir: dirname
+  });
+
+  const conf = readConfig(filepath, envName);
+
+  if (!conf) {
+    throw new Error(`Config file ${filepath} contains no configuration data`);
+  }
+
+  debug("Loaded config %o from $o.", name, dirname);
+  return conf;
+}
+
+function readConfig(filepath, envName) {
+  return _path().default.extname(filepath) === ".js" ? readConfigJS(filepath, {
+    envName
+  }) : readConfigJSON5(filepath);
+}
+
+const LOADING_CONFIGS = new Set();
+const readConfigJS = (0, _caching.makeStrongCache)((filepath, cache) => {
+  if (!_fs().default.existsSync(filepath)) {
+    cache.forever();
+    return null;
+  }
+
+  if (LOADING_CONFIGS.has(filepath)) {
+    cache.never();
+    debug("Auto-ignoring usage of config %o.", filepath);
+    return {
+      filepath,
+      dirname: _path().default.dirname(filepath),
+      options: {}
+    };
+  }
+
+  let options;
+
+  try {
+    LOADING_CONFIGS.add(filepath);
+
+    const configModule = require(filepath);
+
+    options = configModule && configModule.__esModule ? configModule.default || undefined : configModule;
+  } catch (err) {
+    err.message = `${filepath}: Error while loading config - ${err.message}`;
+    throw err;
+  } finally {
+    LOADING_CONFIGS.delete(filepath);
+  }
+
+  if (typeof options === "function") {
+    options = options((0, _configApi.default)(cache));
+    if (!cache.configured()) throwConfigError();
+  }
+
+  if (!options || typeof options !== "object" || Array.isArray(options)) {
+    throw new Error(`${filepath}: Configuration should be an exported JavaScript object.`);
+  }
+
+  if (typeof options.then === "function") {
+    throw new Error(`You appear to be using an async configuration, ` + `which your current version of Babel does not support. ` + `We may add support for this in the future, ` + `but if you're on the most recent version of @babel/core and still ` + `seeing this error, then you'll need to synchronously return your config.`);
+  }
+
+  return {
+    filepath,
+    dirname: _path().default.dirname(filepath),
+    options
+  };
+});
+const packageToBabelConfig = (0, _caching.makeWeakCache)(file => {
+  if (typeof file.options.babel === "undefined") return null;
+  const babel = file.options.babel;
+
+  if (typeof babel !== "object" || Array.isArray(babel) || babel === null) {
+    throw new Error(`${file.filepath}: .babel property must be an object`);
+  }
+
+  return {
+    filepath: file.filepath,
+    dirname: file.dirname,
+    options: babel
+  };
+});
+const readConfigJSON5 = (0, _utils.makeStaticFileCache)((filepath, content) => {
+  let options;
+
+  try {
+    options = _json().default.parse(content);
+  } catch (err) {
+    err.message = `${filepath}: Error while parsing config - ${err.message}`;
+    throw err;
+  }
+
+  if (!options) throw new Error(`${filepath}: No config detected`);
+
+  if (typeof options !== "object") {
+    throw new Error(`${filepath}: Config returned typeof ${typeof options}`);
+  }
+
+  if (Array.isArray(options)) {
+    throw new Error(`${filepath}: Expected config object but found array`);
+  }
+
+  return {
+    filepath,
+    dirname: _path().default.dirname(filepath),
+    options
+  };
+});
+const readIgnoreConfig = (0, _utils.makeStaticFileCache)((filepath, content) => {
+  const ignore = content.split("\n").map(line => line.replace(/#(.*?)$/, "").trim()).filter(line => !!line);
+  return {
+    filepath,
+    dirname: _path().default.dirname(filepath),
+    ignore
+  };
+});
+
+function throwConfigError() {
+  throw new Error(`\
+Caching was left unconfigured. Babel's plugins, presets, and .babelrc.js files can be configured
+for various types of caching, using the first param of their handler functions:
+
+module.exports = function(api) {
+  // The API exposes the following:
+
+  // Cache the returned value forever and don't call this function again.
+  api.cache(true);
+
+  // Don't cache at all. Not recommended because it will be very slow.
+  api.cache(false);
+
+  // Cached based on the value of some function. If this function returns a value different from
+  // a previously-encountered value, the plugins will re-evaluate.
+  var env = api.cache(() => process.env.NODE_ENV);
+
+  // If testing for a specific env, we recommend specifics to avoid instantiating a plugin for
+  // any possible NODE_ENV value that might come up during plugin execution.
+  var isProd = api.cache(() => process.env.NODE_ENV === "production");
+
+  // .cache(fn) will perform a linear search though instances to find the matching plugin based
+  // based on previous instantiated plugins. If you want to recreate the plugin and discard the
+  // previous instance whenever something changes, you may use:
+  var isProd = api.cache.invalidate(() => process.env.NODE_ENV === "production");
+
+  // Note, we also expose the following more-verbose versions of the above examples:
+  api.cache.forever(); // api.cache(true)
+  api.cache.never();   // api.cache(false)
+  api.cache.using(fn); // api.cache(fn)
+
+  // Return the value that will be cached.
+  return { };
+};`);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/files/index-browser.js b/node_modules/@babel/core/lib/config/files/index-browser.js
new file mode 100644
index 00000000..4f0174ee
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/files/index-browser.js
@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findPackageData = findPackageData;
+exports.findRelativeConfig = findRelativeConfig;
+exports.findRootConfig = findRootConfig;
+exports.loadConfig = loadConfig;
+exports.resolvePlugin = resolvePlugin;
+exports.resolvePreset = resolvePreset;
+exports.loadPlugin = loadPlugin;
+exports.loadPreset = loadPreset;
+
+function findPackageData(filepath) {
+  return {
+    filepath,
+    directories: [],
+    pkg: null,
+    isPackage: false
+  };
+}
+
+function findRelativeConfig(pkgData, envName) {
+  return {
+    pkg: null,
+    config: null,
+    ignore: null
+  };
+}
+
+function findRootConfig(dirname, envName) {
+  return null;
+}
+
+function loadConfig(name, dirname, envName) {
+  throw new Error(`Cannot load ${name} relative to ${dirname} in a browser`);
+}
+
+function resolvePlugin(name, dirname) {
+  return null;
+}
+
+function resolvePreset(name, dirname) {
+  return null;
+}
+
+function loadPlugin(name, dirname) {
+  throw new Error(`Cannot load plugin ${name} relative to ${dirname} in a browser`);
+}
+
+function loadPreset(name, dirname) {
+  throw new Error(`Cannot load preset ${name} relative to ${dirname} in a browser`);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/files/index.js b/node_modules/@babel/core/lib/config/files/index.js
new file mode 100644
index 00000000..25c3008b
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/files/index.js
@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "findPackageData", {
+  enumerable: true,
+  get: function get() {
+    return _package.findPackageData;
+  }
+});
+Object.defineProperty(exports, "findRelativeConfig", {
+  enumerable: true,
+  get: function get() {
+    return _configuration.findRelativeConfig;
+  }
+});
+Object.defineProperty(exports, "findRootConfig", {
+  enumerable: true,
+  get: function get() {
+    return _configuration.findRootConfig;
+  }
+});
+Object.defineProperty(exports, "loadConfig", {
+  enumerable: true,
+  get: function get() {
+    return _configuration.loadConfig;
+  }
+});
+Object.defineProperty(exports, "resolvePlugin", {
+  enumerable: true,
+  get: function get() {
+    return _plugins.resolvePlugin;
+  }
+});
+Object.defineProperty(exports, "resolvePreset", {
+  enumerable: true,
+  get: function get() {
+    return _plugins.resolvePreset;
+  }
+});
+Object.defineProperty(exports, "loadPlugin", {
+  enumerable: true,
+  get: function get() {
+    return _plugins.loadPlugin;
+  }
+});
+Object.defineProperty(exports, "loadPreset", {
+  enumerable: true,
+  get: function get() {
+    return _plugins.loadPreset;
+  }
+});
+
+var _package = require("./package");
+
+var _configuration = require("./configuration");
+
+var _plugins = require("./plugins");
+
+({});
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/files/package.js b/node_modules/@babel/core/lib/config/files/package.js
new file mode 100644
index 00000000..4557b8ab
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/files/package.js
@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findPackageData = findPackageData;
+
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+
+  _path = function _path() {
+    return data;
+  };
+
+  return data;
+}
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const PACKAGE_FILENAME = "package.json";
+
+function findPackageData(filepath) {
+  let pkg = null;
+  const directories = [];
+  let isPackage = true;
+
+  let dirname = _path().default.dirname(filepath);
+
+  while (!pkg && _path().default.basename(dirname) !== "node_modules") {
+    directories.push(dirname);
+    pkg = readConfigPackage(_path().default.join(dirname, PACKAGE_FILENAME));
+
+    const nextLoc = _path().default.dirname(dirname);
+
+    if (dirname === nextLoc) {
+      isPackage = false;
+      break;
+    }
+
+    dirname = nextLoc;
+  }
+
+  return {
+    filepath,
+    directories,
+    pkg,
+    isPackage
+  };
+}
+
+const readConfigPackage = (0, _utils.makeStaticFileCache)((filepath, content) => {
+  let options;
+
+  try {
+    options = JSON.parse(content);
+  } catch (err) {
+    err.message = `${filepath}: Error while parsing JSON - ${err.message}`;
+    throw err;
+  }
+
+  if (typeof options !== "object") {
+    throw new Error(`${filepath}: Config returned typeof ${typeof options}`);
+  }
+
+  if (Array.isArray(options)) {
+    throw new Error(`${filepath}: Expected config object but found array`);
+  }
+
+  return {
+    filepath,
+    dirname: _path().default.dirname(filepath),
+    options
+  };
+});
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/files/plugins.js b/node_modules/@babel/core/lib/config/files/plugins.js
new file mode 100644
index 00000000..e771dbe6
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/files/plugins.js
@@ -0,0 +1,168 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolvePlugin = resolvePlugin;
+exports.resolvePreset = resolvePreset;
+exports.loadPlugin = loadPlugin;
+exports.loadPreset = loadPreset;
+
+function _debug() {
+  const data = _interopRequireDefault(require("debug"));
+
+  _debug = function _debug() {
+    return data;
+  };
+
+  return data;
+}
+
+function _resolve() {
+  const data = _interopRequireDefault(require("resolve"));
+
+  _resolve = function _resolve() {
+    return data;
+  };
+
+  return data;
+}
+
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+
+  _path = function _path() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const debug = (0, _debug().default)("babel:config:loading:files:plugins");
+const EXACT_RE = /^module:/;
+const BABEL_PLUGIN_PREFIX_RE = /^(?!@|module:|[^/]+\/|babel-plugin-)/;
+const BABEL_PRESET_PREFIX_RE = /^(?!@|module:|[^/]+\/|babel-preset-)/;
+const BABEL_PLUGIN_ORG_RE = /^(@babel\/)(?!plugin-|[^/]+\/)/;
+const BABEL_PRESET_ORG_RE = /^(@babel\/)(?!preset-|[^/]+\/)/;
+const OTHER_PLUGIN_ORG_RE = /^(@(?!babel\/)[^/]+\/)(?!babel-plugin-|[^/]+\/)/;
+const OTHER_PRESET_ORG_RE = /^(@(?!babel\/)[^/]+\/)(?!babel-preset-|[^/]+\/)/;
+
+function resolvePlugin(name, dirname) {
+  return resolveStandardizedName("plugin", name, dirname);
+}
+
+function resolvePreset(name, dirname) {
+  return resolveStandardizedName("preset", name, dirname);
+}
+
+function loadPlugin(name, dirname) {
+  const filepath = resolvePlugin(name, dirname);
+
+  if (!filepath) {
+    throw new Error(`Plugin ${name} not found relative to ${dirname}`);
+  }
+
+  const value = requireModule("plugin", filepath);
+  debug("Loaded plugin %o from %o.", name, dirname);
+  return {
+    filepath,
+    value
+  };
+}
+
+function loadPreset(name, dirname) {
+  const filepath = resolvePreset(name, dirname);
+
+  if (!filepath) {
+    throw new Error(`Preset ${name} not found relative to ${dirname}`);
+  }
+
+  const value = requireModule("preset", filepath);
+  debug("Loaded preset %o from %o.", name, dirname);
+  return {
+    filepath,
+    value
+  };
+}
+
+function standardizeName(type, name) {
+  if (_path().default.isAbsolute(name)) return name;
+  const isPreset = type === "preset";
+  return name.replace(isPreset ? BABEL_PRESET_PREFIX_RE : BABEL_PLUGIN_PREFIX_RE, `babel-${type}-`).replace(isPreset ? BABEL_PRESET_ORG_RE : BABEL_PLUGIN_ORG_RE, `$1${type}-`).replace(isPreset ? OTHER_PRESET_ORG_RE : OTHER_PLUGIN_ORG_RE, `$1babel-${type}-`).replace(EXACT_RE, "");
+}
+
+function resolveStandardizedName(type, name, dirname = process.cwd()) {
+  const standardizedName = standardizeName(type, name);
+
+  try {
+    return _resolve().default.sync(standardizedName, {
+      basedir: dirname
+    });
+  } catch (e) {
+    if (e.code !== "MODULE_NOT_FOUND") throw e;
+
+    if (standardizedName !== name) {
+      let resolvedOriginal = false;
+
+      try {
+        _resolve().default.sync(name, {
+          basedir: dirname
+        });
+
+        resolvedOriginal = true;
+      } catch (e2) {}
+
+      if (resolvedOriginal) {
+        e.message += `\n- If you want to resolve "${name}", use "module:${name}"`;
+      }
+    }
+
+    let resolvedBabel = false;
+
+    try {
+      _resolve().default.sync(standardizeName(type, "@babel/" + name), {
+        basedir: dirname
+      });
+
+      resolvedBabel = true;
+    } catch (e2) {}
+
+    if (resolvedBabel) {
+      e.message += `\n- Did you mean "@babel/${name}"?`;
+    }
+
+    let resolvedOppositeType = false;
+    const oppositeType = type === "preset" ? "plugin" : "preset";
+
+    try {
+      _resolve().default.sync(standardizeName(oppositeType, name), {
+        basedir: dirname
+      });
+
+      resolvedOppositeType = true;
+    } catch (e2) {}
+
+    if (resolvedOppositeType) {
+      e.message += `\n- Did you accidentally pass a ${type} as a ${oppositeType}?`;
+    }
+
+    throw e;
+  }
+}
+
+const LOADING_MODULES = new Set();
+
+function requireModule(type, name) {
+  if (LOADING_MODULES.has(name)) {
+    throw new Error(`Reentrant ${type} detected trying to load "${name}". This module is not ignored ` + "and is trying to load itself while compiling itself, leading to a dependency cycle. " + 'We recommend adding it to your "ignore" list in your babelrc, or to a .babelignore.');
+  }
+
+  try {
+    LOADING_MODULES.add(name);
+    return require(name);
+  } finally {
+    LOADING_MODULES.delete(name);
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/files/types.js b/node_modules/@babel/core/lib/config/files/types.js
new file mode 100644
index 00000000..9a390c31
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/files/types.js
@@ -0,0 +1 @@
+"use strict";
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/files/utils.js b/node_modules/@babel/core/lib/config/files/utils.js
new file mode 100644
index 00000000..9314e2dc
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/files/utils.js
@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeStaticFileCache = makeStaticFileCache;
+
+function _fs() {
+  const data = _interopRequireDefault(require("fs"));
+
+  _fs = function _fs() {
+    return data;
+  };
+
+  return data;
+}
+
+var _caching = require("../caching");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function makeStaticFileCache(fn) {
+  return (0, _caching.makeStrongCache)((filepath, cache) => {
+    if (cache.invalidate(() => fileMtime(filepath)) === null) {
+      cache.forever();
+      return null;
+    }
+
+    return fn(filepath, _fs().default.readFileSync(filepath, "utf8"));
+  });
+}
+
+function fileMtime(filepath) {
+  try {
+    return +_fs().default.statSync(filepath).mtime;
+  } catch (e) {
+    if (e.code !== "ENOENT" && e.code !== "ENOTDIR") throw e;
+  }
+
+  return null;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/full.js b/node_modules/@babel/core/lib/config/full.js
new file mode 100644
index 00000000..e2875cdf
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/full.js
@@ -0,0 +1,268 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = loadFullConfig;
+
+var _util = require("./util");
+
+var context = _interopRequireWildcard(require("../index"));
+
+var _plugin = _interopRequireDefault(require("./plugin"));
+
+var _item = require("./item");
+
+var _configChain = require("./config-chain");
+
+function _traverse() {
+  const data = _interopRequireDefault(require("@babel/traverse"));
+
+  _traverse = function _traverse() {
+    return data;
+  };
+
+  return data;
+}
+
+var _caching = require("./caching");
+
+var _options = require("./validation/options");
+
+var _plugins = require("./validation/plugins");
+
+var _configApi = _interopRequireDefault(require("./helpers/config-api"));
+
+var _partial = _interopRequireDefault(require("./partial"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function loadFullConfig(inputOpts) {
+  const result = (0, _partial.default)(inputOpts);
+
+  if (!result) {
+    return null;
+  }
+
+  const options = result.options,
+        context = result.context;
+  const optionDefaults = {};
+  const passes = [[]];
+
+  try {
+    const plugins = options.plugins,
+          presets = options.presets;
+
+    if (!plugins || !presets) {
+      throw new Error("Assertion failure - plugins and presets exist");
+    }
+
+    const ignored = function recurseDescriptors(config, pass) {
+      const plugins = config.plugins.map(descriptor => {
+        return loadPluginDescriptor(descriptor, context);
+      });
+      const presets = config.presets.map(descriptor => {
+        return {
+          preset: loadPresetDescriptor(descriptor, context),
+          pass: descriptor.ownPass ? [] : pass
+        };
+      });
+
+      if (presets.length > 0) {
+        passes.splice(1, 0, ...presets.map(o => o.pass).filter(p => p !== pass));
+
+        for (var _iterator = presets, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+          var _ref2;
+
+          if (_isArray) {
+            if (_i >= _iterator.length) break;
+            _ref2 = _iterator[_i++];
+          } else {
+            _i = _iterator.next();
+            if (_i.done) break;
+            _ref2 = _i.value;
+          }
+
+          const _ref = _ref2;
+          const preset = _ref.preset,
+                pass = _ref.pass;
+          if (!preset) return true;
+          const ignored = recurseDescriptors({
+            plugins: preset.plugins,
+            presets: preset.presets
+          }, pass);
+          if (ignored) return true;
+          preset.options.forEach(opts => {
+            (0, _util.mergeOptions)(optionDefaults, opts);
+          });
+        }
+      }
+
+      if (plugins.length > 0) {
+        pass.unshift(...plugins);
+      }
+    }({
+      plugins: plugins.map(item => {
+        const desc = (0, _item.getItemDescriptor)(item);
+
+        if (!desc) {
+          throw new Error("Assertion failure - must be config item");
+        }
+
+        return desc;
+      }),
+      presets: presets.map(item => {
+        const desc = (0, _item.getItemDescriptor)(item);
+
+        if (!desc) {
+          throw new Error("Assertion failure - must be config item");
+        }
+
+        return desc;
+      })
+    }, passes[0]);
+
+    if (ignored) return null;
+  } catch (e) {
+    if (!/^\[BABEL\]/.test(e.message)) {
+      e.message = `[BABEL] ${context.filename || "unknown"}: ${e.message}`;
+    }
+
+    throw e;
+  }
+
+  const opts = optionDefaults;
+  (0, _util.mergeOptions)(opts, options);
+  opts.plugins = passes[0];
+  opts.presets = passes.slice(1).filter(plugins => plugins.length > 0).map(plugins => ({
+    plugins
+  }));
+  opts.passPerPreset = opts.presets.length > 0;
+  return {
+    options: opts,
+    passes: passes
+  };
+}
+
+const loadDescriptor = (0, _caching.makeWeakCache)(({
+  value,
+  options,
+  dirname,
+  alias
+}, cache) => {
+  if (options === false) throw new Error("Assertion failure");
+  options = options || {};
+  let item = value;
+
+  if (typeof value === "function") {
+    const api = Object.assign({}, context, (0, _configApi.default)(cache));
+
+    try {
+      item = value(api, options, dirname);
+    } catch (e) {
+      if (alias) {
+        e.message += ` (While processing: ${JSON.stringify(alias)})`;
+      }
+
+      throw e;
+    }
+  }
+
+  if (!item || typeof item !== "object") {
+    throw new Error("Plugin/Preset did not return an object.");
+  }
+
+  if (typeof item.then === "function") {
+    throw new Error(`You appear to be using an async plugin, ` + `which your current version of Babel does not support.` + `If you're using a published plugin, ` + `you may need to upgrade your @babel/core version.`);
+  }
+
+  return {
+    value: item,
+    options,
+    dirname,
+    alias
+  };
+});
+
+function loadPluginDescriptor(descriptor, context) {
+  if (descriptor.value instanceof _plugin.default) {
+    if (descriptor.options) {
+      throw new Error("Passed options to an existing Plugin instance will not work.");
+    }
+
+    return descriptor.value;
+  }
+
+  return instantiatePlugin(loadDescriptor(descriptor, context), context);
+}
+
+const instantiatePlugin = (0, _caching.makeWeakCache)(({
+  value,
+  options,
+  dirname,
+  alias
+}, cache) => {
+  const pluginObj = (0, _plugins.validatePluginObject)(value);
+  const plugin = Object.assign({}, pluginObj);
+
+  if (plugin.visitor) {
+    plugin.visitor = _traverse().default.explode(Object.assign({}, plugin.visitor));
+  }
+
+  if (plugin.inherits) {
+    const inheritsDescriptor = {
+      name: undefined,
+      alias: `${alias}$inherits`,
+      value: plugin.inherits,
+      options,
+      dirname
+    };
+    const inherits = cache.invalidate(data => loadPluginDescriptor(inheritsDescriptor, data));
+    plugin.pre = chain(inherits.pre, plugin.pre);
+    plugin.post = chain(inherits.post, plugin.post);
+    plugin.manipulateOptions = chain(inherits.manipulateOptions, plugin.manipulateOptions);
+    plugin.visitor = _traverse().default.visitors.merge([inherits.visitor || {}, plugin.visitor || {}]);
+  }
+
+  return new _plugin.default(plugin, options, alias);
+});
+
+const loadPresetDescriptor = (descriptor, context) => {
+  return (0, _configChain.buildPresetChain)(instantiatePreset(loadDescriptor(descriptor, context)), context);
+};
+
+const instantiatePreset = (0, _caching.makeWeakCache)(({
+  value,
+  dirname,
+  alias
+}) => {
+  return {
+    options: (0, _options.validate)("preset", value),
+    alias,
+    dirname
+  };
+});
+
+function chain(a, b) {
+  const fns = [a, b].filter(Boolean);
+  if (fns.length <= 1) return fns[0];
+  return function (...args) {
+    for (var _iterator2 = fns, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+      var _ref3;
+
+      if (_isArray2) {
+        if (_i2 >= _iterator2.length) break;
+        _ref3 = _iterator2[_i2++];
+      } else {
+        _i2 = _iterator2.next();
+        if (_i2.done) break;
+        _ref3 = _i2.value;
+      }
+
+      const fn = _ref3;
+      fn.apply(this, args);
+    }
+  };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/helpers/config-api.js b/node_modules/@babel/core/lib/config/helpers/config-api.js
new file mode 100644
index 00000000..78080a80
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/helpers/config-api.js
@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = makeAPI;
+
+function _semver() {
+  const data = _interopRequireDefault(require("semver"));
+
+  _semver = function _semver() {
+    return data;
+  };
+
+  return data;
+}
+
+var _ = require("../../");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function makeAPI(cache) {
+  const env = value => cache.using(data => {
+    if (typeof value === "undefined") return data.envName;
+    if (typeof value === "function") return value(data.envName);
+    if (!Array.isArray(value)) value = [value];
+    return value.some(entry => {
+      if (typeof entry !== "string") {
+        throw new Error("Unexpected non-string value");
+      }
+
+      return entry === data.envName;
+    });
+  });
+
+  return {
+    version: _.version,
+    cache: cache.simple(),
+    env,
+    async: () => false,
+    assertVersion
+  };
+}
+
+function assertVersion(range) {
+  if (typeof range === "number") {
+    if (!Number.isInteger(range)) {
+      throw new Error("Expected string or integer value.");
+    }
+
+    range = `^${range}.0.0-0`;
+  }
+
+  if (typeof range !== "string") {
+    throw new Error("Expected string or integer value.");
+  }
+
+  if (_semver().default.satisfies(_.version, range)) return;
+  const limit = Error.stackTraceLimit;
+
+  if (typeof limit === "number" && limit < 25) {
+    Error.stackTraceLimit = 25;
+  }
+
+  const err = new Error(`Requires Babel "${range}", but was loaded with "${_.version}". ` + `If you are sure you have a compatible version of @babel/core, ` + `it is likely that something in your build process is loading the ` + `wrong version. Inspect the stack trace of this error to look for ` + `the first entry that doesn't mention "@babel/core" or "babel-core" ` + `to see what is calling Babel.`);
+
+  if (typeof limit === "number") {
+    Error.stackTraceLimit = limit;
+  }
+
+  throw Object.assign(err, {
+    code: "BABEL_VERSION_UNSUPPORTED",
+    version: _.version,
+    range
+  });
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/helpers/environment.js b/node_modules/@babel/core/lib/config/helpers/environment.js
new file mode 100644
index 00000000..e4bfdbc7
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/helpers/environment.js
@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getEnv = getEnv;
+
+function getEnv(defaultValue = "development") {
+  return process.env.BABEL_ENV || process.env.NODE_ENV || defaultValue;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/index.js b/node_modules/@babel/core/lib/config/index.js
new file mode 100644
index 00000000..829a7952
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/index.js
@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadOptions = loadOptions;
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function get() {
+    return _full.default;
+  }
+});
+Object.defineProperty(exports, "loadPartialConfig", {
+  enumerable: true,
+  get: function get() {
+    return _partial.loadPartialConfig;
+  }
+});
+exports.OptionManager = void 0;
+
+var _full = _interopRequireDefault(require("./full"));
+
+var _partial = require("./partial");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function loadOptions(opts) {
+  const config = (0, _full.default)(opts);
+  return config ? config.options : null;
+}
+
+class OptionManager {
+  init(opts) {
+    return loadOptions(opts);
+  }
+
+}
+
+exports.OptionManager = OptionManager;
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/item.js b/node_modules/@babel/core/lib/config/item.js
new file mode 100644
index 00000000..3f2d5e69
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/item.js
@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createItemFromDescriptor = createItemFromDescriptor;
+exports.createConfigItem = createConfigItem;
+exports.getItemDescriptor = getItemDescriptor;
+
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+
+  _path = function _path() {
+    return data;
+  };
+
+  return data;
+}
+
+var _configDescriptors = require("./config-descriptors");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function createItemFromDescriptor(desc) {
+  return new ConfigItem(desc);
+}
+
+function createConfigItem(value, {
+  dirname = ".",
+  type
+} = {}) {
+  const descriptor = (0, _configDescriptors.createDescriptor)(value, _path().default.resolve(dirname), {
+    type,
+    alias: "programmatic item"
+  });
+  return createItemFromDescriptor(descriptor);
+}
+
+function getItemDescriptor(item) {
+  if (item instanceof ConfigItem) {
+    return item._descriptor;
+  }
+
+  return undefined;
+}
+
+class ConfigItem {
+  constructor(descriptor) {
+    this._descriptor = descriptor;
+    Object.defineProperty(this, "_descriptor", {
+      enumerable: false
+    });
+
+    if (this._descriptor.options === false) {
+      throw new Error("Assertion failure - unexpected false options");
+    }
+
+    this.value = this._descriptor.value;
+    this.options = this._descriptor.options;
+    this.dirname = this._descriptor.dirname;
+    this.name = this._descriptor.name;
+    this.file = this._descriptor.file ? {
+      request: this._descriptor.file.request,
+      resolved: this._descriptor.file.resolved
+    } : undefined;
+    Object.freeze(this);
+  }
+
+}
+
+Object.freeze(ConfigItem.prototype);
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/partial.js b/node_modules/@babel/core/lib/config/partial.js
new file mode 100644
index 00000000..8b8937ed
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/partial.js
@@ -0,0 +1,103 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = loadPrivatePartialConfig;
+exports.loadPartialConfig = loadPartialConfig;
+
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+
+  _path = function _path() {
+    return data;
+  };
+
+  return data;
+}
+
+var _plugin = _interopRequireDefault(require("./plugin"));
+
+var _util = require("./util");
+
+var _item = require("./item");
+
+var _configChain = require("./config-chain");
+
+var _environment = require("./helpers/environment");
+
+var _options = require("./validation/options");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function loadPrivatePartialConfig(inputOpts) {
+  if (inputOpts != null && (typeof inputOpts !== "object" || Array.isArray(inputOpts))) {
+    throw new Error("Babel options must be an object, null, or undefined");
+  }
+
+  const args = inputOpts ? (0, _options.validate)("arguments", inputOpts) : {};
+  const _args$envName = args.envName,
+        envName = _args$envName === void 0 ? (0, _environment.getEnv)() : _args$envName,
+        _args$cwd = args.cwd,
+        cwd = _args$cwd === void 0 ? "." : _args$cwd;
+
+  const absoluteCwd = _path().default.resolve(cwd);
+
+  const context = {
+    filename: args.filename ? _path().default.resolve(cwd, args.filename) : null,
+    cwd: absoluteCwd,
+    envName
+  };
+  const configChain = (0, _configChain.buildRootChain)(args, context);
+  if (!configChain) return null;
+  const options = {};
+  configChain.options.forEach(opts => {
+    (0, _util.mergeOptions)(options, opts);
+  });
+  options.babelrc = false;
+  options.configFile = false;
+  options.envName = envName;
+  options.cwd = absoluteCwd;
+  options.passPerPreset = false;
+  options.plugins = configChain.plugins.map(descriptor => (0, _item.createItemFromDescriptor)(descriptor));
+  options.presets = configChain.presets.map(descriptor => (0, _item.createItemFromDescriptor)(descriptor));
+  return {
+    options,
+    context,
+    ignore: configChain.ignore,
+    babelrc: configChain.babelrc,
+    config: configChain.config
+  };
+}
+
+function loadPartialConfig(inputOpts) {
+  const result = loadPrivatePartialConfig(inputOpts);
+  if (!result) return null;
+  const options = result.options,
+        babelrc = result.babelrc,
+        ignore = result.ignore,
+        config = result.config;
+  (options.plugins || []).forEach(item => {
+    if (item.value instanceof _plugin.default) {
+      throw new Error("Passing cached plugin instances is not supported in " + "babel.loadPartialConfig()");
+    }
+  });
+  return new PartialConfig(options, babelrc ? babelrc.filepath : undefined, ignore ? ignore.filepath : undefined, config ? config.filepath : undefined);
+}
+
+class PartialConfig {
+  constructor(options, babelrc, ignore, config) {
+    this.options = options;
+    this.babelignore = ignore;
+    this.babelrc = babelrc;
+    this.config = config;
+    Object.freeze(this);
+  }
+
+  hasFilesystemConfig() {
+    return this.babelrc !== undefined || this.config !== undefined;
+  }
+
+}
+
+Object.freeze(PartialConfig.prototype);
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/plugin.js b/node_modules/@babel/core/lib/config/plugin.js
new file mode 100644
index 00000000..3c780708
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/plugin.js
@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+class Plugin {
+  constructor(plugin, options, key) {
+    this.key = plugin.name || key;
+    this.manipulateOptions = plugin.manipulateOptions;
+    this.post = plugin.post;
+    this.pre = plugin.pre;
+    this.visitor = plugin.visitor || {};
+    this.parserOverride = plugin.parserOverride;
+    this.generatorOverride = plugin.generatorOverride;
+    this.options = options;
+  }
+
+}
+
+exports.default = Plugin;
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/util.js b/node_modules/@babel/core/lib/config/util.js
new file mode 100644
index 00000000..96de62c1
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/util.js
@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeOptions = mergeOptions;
+
+function mergeOptions(target, source) {
+  var _arr = Object.keys(source);
+
+  for (var _i = 0; _i < _arr.length; _i++) {
+    const k = _arr[_i];
+
+    if (k === "parserOpts" && source.parserOpts) {
+      const parserOpts = source.parserOpts;
+      const targetObj = target.parserOpts = target.parserOpts || {};
+      mergeDefaultFields(targetObj, parserOpts);
+    } else if (k === "generatorOpts" && source.generatorOpts) {
+      const generatorOpts = source.generatorOpts;
+      const targetObj = target.generatorOpts = target.generatorOpts || {};
+      mergeDefaultFields(targetObj, generatorOpts);
+    } else {
+      const val = source[k];
+      if (val !== undefined) target[k] = val;
+    }
+  }
+}
+
+function mergeDefaultFields(target, source) {
+  var _arr2 = Object.keys(source);
+
+  for (var _i2 = 0; _i2 < _arr2.length; _i2++) {
+    const k = _arr2[_i2];
+    const val = source[k];
+    if (val !== undefined) target[k] = val;
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/validation/option-assertions.js b/node_modules/@babel/core/lib/config/validation/option-assertions.js
new file mode 100644
index 00000000..4aa57c37
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/validation/option-assertions.js
@@ -0,0 +1,205 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assertSourceMaps = assertSourceMaps;
+exports.assertCompact = assertCompact;
+exports.assertSourceType = assertSourceType;
+exports.assertInputSourceMap = assertInputSourceMap;
+exports.assertString = assertString;
+exports.assertFunction = assertFunction;
+exports.assertBoolean = assertBoolean;
+exports.assertObject = assertObject;
+exports.assertArray = assertArray;
+exports.assertIgnoreList = assertIgnoreList;
+exports.assertConfigApplicableTest = assertConfigApplicableTest;
+exports.assertConfigFileSearch = assertConfigFileSearch;
+exports.assertBabelrcSearch = assertBabelrcSearch;
+exports.assertPluginList = assertPluginList;
+
+function assertSourceMaps(key, value) {
+  if (value !== undefined && typeof value !== "boolean" && value !== "inline" && value !== "both") {
+    throw new Error(`.${key} must be a boolean, "inline", "both", or undefined`);
+  }
+
+  return value;
+}
+
+function assertCompact(key, value) {
+  if (value !== undefined && typeof value !== "boolean" && value !== "auto") {
+    throw new Error(`.${key} must be a boolean, "auto", or undefined`);
+  }
+
+  return value;
+}
+
+function assertSourceType(key, value) {
+  if (value !== undefined && value !== "module" && value !== "script" && value !== "unambiguous") {
+    throw new Error(`.${key} must be "module", "script", "unambiguous", or undefined`);
+  }
+
+  return value;
+}
+
+function assertInputSourceMap(key, value) {
+  if (value !== undefined && typeof value !== "boolean" && (typeof value !== "object" || !value)) {
+    throw new Error(".inputSourceMap must be a boolean, object, or undefined");
+  }
+
+  return value;
+}
+
+function assertString(key, value) {
+  if (value !== undefined && typeof value !== "string") {
+    throw new Error(`.${key} must be a string, or undefined`);
+  }
+
+  return value;
+}
+
+function assertFunction(key, value) {
+  if (value !== undefined && typeof value !== "function") {
+    throw new Error(`.${key} must be a function, or undefined`);
+  }
+
+  return value;
+}
+
+function assertBoolean(key, value) {
+  if (value !== undefined && typeof value !== "boolean") {
+    throw new Error(`.${key} must be a boolean, or undefined`);
+  }
+
+  return value;
+}
+
+function assertObject(key, value) {
+  if (value !== undefined && (typeof value !== "object" || Array.isArray(value) || !value)) {
+    throw new Error(`.${key} must be an object, or undefined`);
+  }
+
+  return value;
+}
+
+function assertArray(key, value) {
+  if (value != null && !Array.isArray(value)) {
+    throw new Error(`.${key} must be an array, or undefined`);
+  }
+
+  return value;
+}
+
+function assertIgnoreList(key, value) {
+  const arr = assertArray(key, value);
+
+  if (arr) {
+    arr.forEach((item, i) => assertIgnoreItem(key, i, item));
+  }
+
+  return arr;
+}
+
+function assertIgnoreItem(key, index, value) {
+  if (typeof value !== "string" && typeof value !== "function" && !(value instanceof RegExp)) {
+    throw new Error(`.${key}[${index}] must be an array of string/Funtion/RegExp values, or undefined`);
+  }
+
+  return value;
+}
+
+function assertConfigApplicableTest(key, value) {
+  if (value === undefined) return value;
+
+  if (Array.isArray(value)) {
+    value.forEach((item, i) => {
+      if (!checkValidTest(item)) {
+        throw new Error(`.${key}[${i}] must be a string/Function/RegExp.`);
+      }
+    });
+  } else if (!checkValidTest(value)) {
+    throw new Error(`.${key} must be a string/Function/RegExp, or an array of those`);
+  }
+
+  return value;
+}
+
+function checkValidTest(value) {
+  return typeof value === "string" || typeof value === "function" || value instanceof RegExp;
+}
+
+function assertConfigFileSearch(key, value) {
+  if (value !== undefined && typeof value !== "boolean" && typeof value !== "string") {
+    throw new Error(`.${key} must be a undefined, a boolean, a string, ` + `got ${JSON.stringify(value)}`);
+  }
+
+  return value;
+}
+
+function assertBabelrcSearch(key, value) {
+  if (value === undefined || typeof value === "boolean") return value;
+
+  if (Array.isArray(value)) {
+    value.forEach((item, i) => {
+      if (typeof item !== "string") {
+        throw new Error(`.${key}[${i}] must be a string.`);
+      }
+    });
+  } else if (typeof value !== "string") {
+    throw new Error(`.${key} must be a undefined, a boolean, a string, ` + `or an array of strings, got ${JSON.stringify(value)}`);
+  }
+
+  return value;
+}
+
+function assertPluginList(key, value) {
+  const arr = assertArray(key, value);
+
+  if (arr) {
+    arr.forEach((item, i) => assertPluginItem(key, i, item));
+  }
+
+  return arr;
+}
+
+function assertPluginItem(key, index, value) {
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      throw new Error(`.${key}[${index}] must include an object`);
+    }
+
+    if (value.length > 3) {
+      throw new Error(`.${key}[${index}] may only be a two-tuple or three-tuple`);
+    }
+
+    assertPluginTarget(key, index, true, value[0]);
+
+    if (value.length > 1) {
+      const opts = value[1];
+
+      if (opts !== undefined && opts !== false && (typeof opts !== "object" || Array.isArray(opts))) {
+        throw new Error(`.${key}[${index}][1] must be an object, false, or undefined`);
+      }
+    }
+
+    if (value.length === 3) {
+      const name = value[2];
+
+      if (name !== undefined && typeof name !== "string") {
+        throw new Error(`.${key}[${index}][2] must be a string, or undefined`);
+      }
+    }
+  } else {
+    assertPluginTarget(key, index, false, value);
+  }
+
+  return value;
+}
+
+function assertPluginTarget(key, index, inArray, value) {
+  if ((typeof value !== "object" || !value) && typeof value !== "string" && typeof value !== "function") {
+    throw new Error(`.${key}[${index}]${inArray ? `[0]` : ""} must be a string, object, function`);
+  }
+
+  return value;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/validation/options.js b/node_modules/@babel/core/lib/config/validation/options.js
new file mode 100644
index 00000000..b427b693
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/validation/options.js
@@ -0,0 +1,169 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validate = validate;
+
+var _plugin = _interopRequireDefault(require("../plugin"));
+
+var _removed = _interopRequireDefault(require("./removed"));
+
+var _optionAssertions = require("./option-assertions");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const ROOT_VALIDATORS = {
+  cwd: _optionAssertions.assertString,
+  root: _optionAssertions.assertString,
+  configFile: _optionAssertions.assertConfigFileSearch,
+  filename: _optionAssertions.assertString,
+  filenameRelative: _optionAssertions.assertString,
+  code: _optionAssertions.assertBoolean,
+  ast: _optionAssertions.assertBoolean,
+  envName: _optionAssertions.assertString
+};
+const BABELRC_VALIDATORS = {
+  babelrc: _optionAssertions.assertBoolean,
+  babelrcRoots: _optionAssertions.assertBabelrcSearch
+};
+const NONPRESET_VALIDATORS = {
+  extends: _optionAssertions.assertString,
+  env: assertEnvSet,
+  ignore: _optionAssertions.assertIgnoreList,
+  only: _optionAssertions.assertIgnoreList,
+  overrides: assertOverridesList,
+  test: _optionAssertions.assertConfigApplicableTest,
+  include: _optionAssertions.assertConfigApplicableTest,
+  exclude: _optionAssertions.assertConfigApplicableTest
+};
+const COMMON_VALIDATORS = {
+  inputSourceMap: _optionAssertions.assertInputSourceMap,
+  presets: _optionAssertions.assertPluginList,
+  plugins: _optionAssertions.assertPluginList,
+  passPerPreset: _optionAssertions.assertBoolean,
+  retainLines: _optionAssertions.assertBoolean,
+  comments: _optionAssertions.assertBoolean,
+  shouldPrintComment: _optionAssertions.assertFunction,
+  compact: _optionAssertions.assertCompact,
+  minified: _optionAssertions.assertBoolean,
+  auxiliaryCommentBefore: _optionAssertions.assertString,
+  auxiliaryCommentAfter: _optionAssertions.assertString,
+  sourceType: _optionAssertions.assertSourceType,
+  wrapPluginVisitorMethod: _optionAssertions.assertFunction,
+  highlightCode: _optionAssertions.assertBoolean,
+  sourceMaps: _optionAssertions.assertSourceMaps,
+  sourceMap: _optionAssertions.assertSourceMaps,
+  sourceFileName: _optionAssertions.assertString,
+  sourceRoot: _optionAssertions.assertString,
+  getModuleId: _optionAssertions.assertFunction,
+  moduleRoot: _optionAssertions.assertString,
+  moduleIds: _optionAssertions.assertBoolean,
+  moduleId: _optionAssertions.assertString,
+  parserOpts: _optionAssertions.assertObject,
+  generatorOpts: _optionAssertions.assertObject
+};
+
+function validate(type, opts) {
+  assertNoDuplicateSourcemap(opts);
+  Object.keys(opts).forEach(key => {
+    if (type === "preset" && NONPRESET_VALIDATORS[key]) {
+      throw new Error(`.${key} is not allowed in preset options`);
+    }
+
+    if (type !== "arguments" && ROOT_VALIDATORS[key]) {
+      throw new Error(`.${key} is only allowed in root programmatic options`);
+    }
+
+    if (type !== "arguments" && type !== "configfile" && BABELRC_VALIDATORS[key]) {
+      if (type === "babelrcfile" || type === "extendsfile") {
+        throw new Error(`.${key} is not allowed in .babelrc or "extend"ed files, only in root programmatic options, ` + `or babel.config.js/config file options`);
+      }
+
+      throw new Error(`.${key} is only allowed in root programmatic options, or babel.config.js/config file options`);
+    }
+
+    if (type === "env" && key === "env") {
+      throw new Error(`.${key} is not allowed inside another env block`);
+    }
+
+    if (type === "env" && key === "overrides") {
+      throw new Error(`.${key} is not allowed inside an env block`);
+    }
+
+    if (type === "override" && key === "overrides") {
+      throw new Error(`.${key} is not allowed inside an overrides block`);
+    }
+
+    const validator = COMMON_VALIDATORS[key] || NONPRESET_VALIDATORS[key] || BABELRC_VALIDATORS[key] || ROOT_VALIDATORS[key];
+    if (validator) validator(key, opts[key]);else throw buildUnknownError(key);
+  });
+  return opts;
+}
+
+function buildUnknownError(key) {
+  if (_removed.default[key]) {
+    const _removed$key = _removed.default[key],
+          message = _removed$key.message,
+          _removed$key$version = _removed$key.version,
+          version = _removed$key$version === void 0 ? 5 : _removed$key$version;
+    throw new ReferenceError(`Using removed Babel ${version} option: .${key} - ${message}`);
+  } else {
+    const unknownOptErr = `Unknown option: .${key}. Check out http://babeljs.io/docs/usage/options/ for more information about options.`;
+    throw new ReferenceError(unknownOptErr);
+  }
+}
+
+function has(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+function assertNoDuplicateSourcemap(opts) {
+  if (has(opts, "sourceMap") && has(opts, "sourceMaps")) {
+    throw new Error(".sourceMap is an alias for .sourceMaps, cannot use both");
+  }
+}
+
+function assertEnvSet(key, value) {
+  const obj = (0, _optionAssertions.assertObject)(key, value);
+
+  if (obj) {
+    var _arr = Object.keys(obj);
+
+    for (var _i = 0; _i < _arr.length; _i++) {
+      const key = _arr[_i];
+      const env = (0, _optionAssertions.assertObject)(key, obj[key]);
+      if (env) validate("env", env);
+    }
+  }
+
+  return obj;
+}
+
+function assertOverridesList(key, value) {
+  const arr = (0, _optionAssertions.assertArray)(key, value);
+
+  if (arr) {
+    for (var _iterator = arr.entries(), _isArray = Array.isArray(_iterator), _i2 = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i2 >= _iterator.length) break;
+        _ref = _iterator[_i2++];
+      } else {
+        _i2 = _iterator.next();
+        if (_i2.done) break;
+        _ref = _i2.value;
+      }
+
+      const _ref2 = _ref,
+            index = _ref2[0],
+            item = _ref2[1];
+      const env = (0, _optionAssertions.assertObject)(`${index}`, item);
+      if (!env) throw new Error(`.${key}[${index}] must be an object`);
+      validate("override", env);
+    }
+  }
+
+  return arr;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/validation/plugins.js b/node_modules/@babel/core/lib/config/validation/plugins.js
new file mode 100644
index 00000000..73b498cd
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/validation/plugins.js
@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validatePluginObject = validatePluginObject;
+
+var _optionAssertions = require("./option-assertions");
+
+const VALIDATORS = {
+  name: _optionAssertions.assertString,
+  manipulateOptions: _optionAssertions.assertFunction,
+  pre: _optionAssertions.assertFunction,
+  post: _optionAssertions.assertFunction,
+  inherits: _optionAssertions.assertFunction,
+  visitor: assertVisitorMap,
+  parserOverride: _optionAssertions.assertFunction,
+  generatorOverride: _optionAssertions.assertFunction
+};
+
+function assertVisitorMap(key, value) {
+  const obj = (0, _optionAssertions.assertObject)(key, value);
+
+  if (obj) {
+    Object.keys(obj).forEach(prop => assertVisitorHandler(prop, obj[prop]));
+
+    if (obj.enter || obj.exit) {
+      throw new Error(`.${key} cannot contain catch-all "enter" or "exit" handlers. Please target individual nodes.`);
+    }
+  }
+
+  return obj;
+}
+
+function assertVisitorHandler(key, value) {
+  if (value && typeof value === "object") {
+    Object.keys(value).forEach(handler => {
+      if (handler !== "enter" && handler !== "exit") {
+        throw new Error(`.visitor["${key}"] may only have .enter and/or .exit handlers.`);
+      }
+    });
+  } else if (typeof value !== "function") {
+    throw new Error(`.visitor["${key}"] must be a function`);
+  }
+
+  return value;
+}
+
+function validatePluginObject(obj) {
+  Object.keys(obj).forEach(key => {
+    const validator = VALIDATORS[key];
+    if (validator) validator(key, obj[key]);else throw new Error(`.${key} is not a valid Plugin property`);
+  });
+  return obj;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/validation/removed.js b/node_modules/@babel/core/lib/config/validation/removed.js
new file mode 100644
index 00000000..f0fcd7de
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/validation/removed.js
@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = {
+  auxiliaryComment: {
+    message: "Use `auxiliaryCommentBefore` or `auxiliaryCommentAfter`"
+  },
+  blacklist: {
+    message: "Put the specific transforms you want in the `plugins` option"
+  },
+  breakConfig: {
+    message: "This is not a necessary option in Babel 6"
+  },
+  experimental: {
+    message: "Put the specific transforms you want in the `plugins` option"
+  },
+  externalHelpers: {
+    message: "Use the `external-helpers` plugin instead. " + "Check out http://babeljs.io/docs/plugins/external-helpers/"
+  },
+  extra: {
+    message: ""
+  },
+  jsxPragma: {
+    message: "use the `pragma` option in the `react-jsx` plugin. " + "Check out http://babeljs.io/docs/plugins/transform-react-jsx/"
+  },
+  loose: {
+    message: "Specify the `loose` option for the relevant plugin you are using " + "or use a preset that sets the option."
+  },
+  metadataUsedHelpers: {
+    message: "Not required anymore as this is enabled by default"
+  },
+  modules: {
+    message: "Use the corresponding module transform plugin in the `plugins` option. " + "Check out http://babeljs.io/docs/plugins/#modules"
+  },
+  nonStandard: {
+    message: "Use the `react-jsx` and `flow-strip-types` plugins to support JSX and Flow. " + "Also check out the react preset http://babeljs.io/docs/plugins/preset-react/"
+  },
+  optional: {
+    message: "Put the specific transforms you want in the `plugins` option"
+  },
+  sourceMapName: {
+    message: "The `sourceMapName` option has been removed because it makes more sense for the " + "tooling that calls Babel to assign `map.file` themselves."
+  },
+  stage: {
+    message: "Check out the corresponding stage-x presets http://babeljs.io/docs/plugins/#presets"
+  },
+  whitelist: {
+    message: "Put the specific transforms you want in the `plugins` option"
+  },
+  resolveModuleSource: {
+    version: 6,
+    message: "Use `babel-plugin-module-resolver@3`'s 'resolvePath' options"
+  },
+  metadata: {
+    version: 6,
+    message: "Generated plugin metadata is always included in the output result"
+  },
+  sourceMapTarget: {
+    version: 6,
+    message: "The `sourceMapTarget` option has been removed because it makes more sense for the tooling " + "that calls Babel to assign `map.file` themselves."
+  }
+};
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/index.js b/node_modules/@babel/core/lib/index.js
new file mode 100644
index 00000000..aa2e6afc
--- /dev/null
+++ b/node_modules/@babel/core/lib/index.js
@@ -0,0 +1,197 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Plugin = Plugin;
+Object.defineProperty(exports, "File", {
+  enumerable: true,
+  get: function get() {
+    return _file.default;
+  }
+});
+Object.defineProperty(exports, "buildExternalHelpers", {
+  enumerable: true,
+  get: function get() {
+    return _buildExternalHelpers.default;
+  }
+});
+Object.defineProperty(exports, "resolvePlugin", {
+  enumerable: true,
+  get: function get() {
+    return _files.resolvePlugin;
+  }
+});
+Object.defineProperty(exports, "resolvePreset", {
+  enumerable: true,
+  get: function get() {
+    return _files.resolvePreset;
+  }
+});
+Object.defineProperty(exports, "version", {
+  enumerable: true,
+  get: function get() {
+    return _package.version;
+  }
+});
+Object.defineProperty(exports, "getEnv", {
+  enumerable: true,
+  get: function get() {
+    return _environment.getEnv;
+  }
+});
+Object.defineProperty(exports, "traverse", {
+  enumerable: true,
+  get: function get() {
+    return _traverse().default;
+  }
+});
+Object.defineProperty(exports, "template", {
+  enumerable: true,
+  get: function get() {
+    return _template().default;
+  }
+});
+Object.defineProperty(exports, "loadPartialConfig", {
+  enumerable: true,
+  get: function get() {
+    return _config.loadPartialConfig;
+  }
+});
+Object.defineProperty(exports, "loadOptions", {
+  enumerable: true,
+  get: function get() {
+    return _config.loadOptions;
+  }
+});
+Object.defineProperty(exports, "OptionManager", {
+  enumerable: true,
+  get: function get() {
+    return _config.OptionManager;
+  }
+});
+Object.defineProperty(exports, "createConfigItem", {
+  enumerable: true,
+  get: function get() {
+    return _item.createConfigItem;
+  }
+});
+Object.defineProperty(exports, "transform", {
+  enumerable: true,
+  get: function get() {
+    return _transform.default;
+  }
+});
+Object.defineProperty(exports, "transformSync", {
+  enumerable: true,
+  get: function get() {
+    return _transformSync.default;
+  }
+});
+Object.defineProperty(exports, "transformFile", {
+  enumerable: true,
+  get: function get() {
+    return _transformFile.default;
+  }
+});
+Object.defineProperty(exports, "transformFileSync", {
+  enumerable: true,
+  get: function get() {
+    return _transformFileSync.default;
+  }
+});
+Object.defineProperty(exports, "transformFromAst", {
+  enumerable: true,
+  get: function get() {
+    return _transformAst.default;
+  }
+});
+Object.defineProperty(exports, "transformFromAstSync", {
+  enumerable: true,
+  get: function get() {
+    return _transformAstSync.default;
+  }
+});
+Object.defineProperty(exports, "parse", {
+  enumerable: true,
+  get: function get() {
+    return _parse.default;
+  }
+});
+exports.types = exports.DEFAULT_EXTENSIONS = void 0;
+
+var _file = _interopRequireDefault(require("./transformation/file/file"));
+
+var _buildExternalHelpers = _interopRequireDefault(require("./tools/build-external-helpers"));
+
+var _files = require("./config/files");
+
+var _package = require("../package.json");
+
+var _environment = require("./config/helpers/environment");
+
+function _types() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  _types = function _types() {
+    return data;
+  };
+
+  return data;
+}
+
+Object.defineProperty(exports, "types", {
+  enumerable: true,
+  get: function get() {
+    return _types();
+  }
+});
+
+function _traverse() {
+  const data = _interopRequireDefault(require("@babel/traverse"));
+
+  _traverse = function _traverse() {
+    return data;
+  };
+
+  return data;
+}
+
+function _template() {
+  const data = _interopRequireDefault(require("@babel/template"));
+
+  _template = function _template() {
+    return data;
+  };
+
+  return data;
+}
+
+var _config = require("./config");
+
+var _item = require("./config/item");
+
+var _transform = _interopRequireDefault(require("./transform"));
+
+var _transformSync = _interopRequireDefault(require("./transform-sync"));
+
+var _transformFile = _interopRequireDefault(require("./transform-file"));
+
+var _transformFileSync = _interopRequireDefault(require("./transform-file-sync"));
+
+var _transformAst = _interopRequireDefault(require("./transform-ast"));
+
+var _transformAstSync = _interopRequireDefault(require("./transform-ast-sync"));
+
+var _parse = _interopRequireDefault(require("./parse"));
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function Plugin(alias) {
+  throw new Error(`The (${alias}) Babel 5 plugin is being run with an unsupported Babel version.`);
+}
+
+const DEFAULT_EXTENSIONS = Object.freeze([".js", ".jsx", ".es6", ".es", ".mjs"]);
+exports.DEFAULT_EXTENSIONS = DEFAULT_EXTENSIONS;
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/parse.js b/node_modules/@babel/core/lib/parse.js
new file mode 100644
index 00000000..2251e268
--- /dev/null
+++ b/node_modules/@babel/core/lib/parse.js
@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = parse;
+
+var _config = _interopRequireDefault(require("./config"));
+
+var _normalizeFile = _interopRequireDefault(require("./transformation/normalize-file"));
+
+var _normalizeOpts = _interopRequireDefault(require("./transformation/normalize-opts"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function parse(code, opts) {
+  const config = (0, _config.default)(opts);
+
+  if (config === null) {
+    return null;
+  }
+
+  const file = (0, _normalizeFile.default)(config.passes, (0, _normalizeOpts.default)(config), code);
+  return file.ast;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/tools/build-external-helpers.js b/node_modules/@babel/core/lib/tools/build-external-helpers.js
new file mode 100644
index 00000000..02af09e7
--- /dev/null
+++ b/node_modules/@babel/core/lib/tools/build-external-helpers.js
@@ -0,0 +1,144 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+function helpers() {
+  const data = _interopRequireWildcard(require("@babel/helpers"));
+
+  helpers = function helpers() {
+    return data;
+  };
+
+  return data;
+}
+
+function _generator() {
+  const data = _interopRequireDefault(require("@babel/generator"));
+
+  _generator = function _generator() {
+    return data;
+  };
+
+  return data;
+}
+
+function _template() {
+  const data = _interopRequireDefault(require("@babel/template"));
+
+  _template = function _template() {
+    return data;
+  };
+
+  return data;
+}
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+const buildUmdWrapper = replacements => _template().default`
+    (function (root, factory) {
+      if (typeof define === "function" && define.amd) {
+        define(AMD_ARGUMENTS, factory);
+      } else if (typeof exports === "object") {
+        factory(COMMON_ARGUMENTS);
+      } else {
+        factory(BROWSER_ARGUMENTS);
+      }
+    })(UMD_ROOT, function (FACTORY_PARAMETERS) {
+      FACTORY_BODY
+    });
+  `(replacements);
+
+function buildGlobal(whitelist) {
+  const namespace = t().identifier("babelHelpers");
+  const body = [];
+  const container = t().functionExpression(null, [t().identifier("global")], t().blockStatement(body));
+  const tree = t().program([t().expressionStatement(t().callExpression(container, [t().conditionalExpression(t().binaryExpression("===", t().unaryExpression("typeof", t().identifier("global")), t().stringLiteral("undefined")), t().identifier("self"), t().identifier("global"))]))]);
+  body.push(t().variableDeclaration("var", [t().variableDeclarator(namespace, t().assignmentExpression("=", t().memberExpression(t().identifier("global"), namespace), t().objectExpression([])))]));
+  buildHelpers(body, namespace, whitelist);
+  return tree;
+}
+
+function buildModule(whitelist) {
+  const body = [];
+  const refs = buildHelpers(body, null, whitelist);
+  body.unshift(t().exportNamedDeclaration(null, Object.keys(refs).map(name => {
+    return t().exportSpecifier(t().cloneNode(refs[name]), t().identifier(name));
+  })));
+  return t().program(body, [], "module");
+}
+
+function buildUmd(whitelist) {
+  const namespace = t().identifier("babelHelpers");
+  const body = [];
+  body.push(t().variableDeclaration("var", [t().variableDeclarator(namespace, t().identifier("global"))]));
+  buildHelpers(body, namespace, whitelist);
+  return t().program([buildUmdWrapper({
+    FACTORY_PARAMETERS: t().identifier("global"),
+    BROWSER_ARGUMENTS: t().assignmentExpression("=", t().memberExpression(t().identifier("root"), namespace), t().objectExpression([])),
+    COMMON_ARGUMENTS: t().identifier("exports"),
+    AMD_ARGUMENTS: t().arrayExpression([t().stringLiteral("exports")]),
+    FACTORY_BODY: body,
+    UMD_ROOT: t().identifier("this")
+  })]);
+}
+
+function buildVar(whitelist) {
+  const namespace = t().identifier("babelHelpers");
+  const body = [];
+  body.push(t().variableDeclaration("var", [t().variableDeclarator(namespace, t().objectExpression([]))]));
+  const tree = t().program(body);
+  buildHelpers(body, namespace, whitelist);
+  body.push(t().expressionStatement(namespace));
+  return tree;
+}
+
+function buildHelpers(body, namespace, whitelist) {
+  const getHelperReference = name => {
+    return namespace ? t().memberExpression(namespace, t().identifier(name)) : t().identifier(`_${name}`);
+  };
+
+  const refs = {};
+  helpers().list.forEach(function (name) {
+    if (whitelist && whitelist.indexOf(name) < 0) return;
+    const ref = refs[name] = getHelperReference(name);
+
+    const _helpers$get = helpers().get(name, getHelperReference, ref),
+          nodes = _helpers$get.nodes;
+
+    body.push(...nodes);
+  });
+  return refs;
+}
+
+function _default(whitelist, outputType = "global") {
+  let tree;
+  const build = {
+    global: buildGlobal,
+    module: buildModule,
+    umd: buildUmd,
+    var: buildVar
+  }[outputType];
+
+  if (build) {
+    tree = build(whitelist);
+  } else {
+    throw new Error(`Unsupported output type ${outputType}`);
+  }
+
+  return (0, _generator().default)(tree).code;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/transform-ast-sync.js b/node_modules/@babel/core/lib/transform-ast-sync.js
new file mode 100644
index 00000000..a4946dd6
--- /dev/null
+++ b/node_modules/@babel/core/lib/transform-ast-sync.js
@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = transformFromAstSync;
+
+var _config = _interopRequireDefault(require("./config"));
+
+var _transformation = require("./transformation");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function transformFromAstSync(ast, code, opts) {
+  const config = (0, _config.default)(opts);
+  if (config === null) return null;
+  if (!ast) throw new Error("No AST given");
+  return (0, _transformation.runSync)(config, code, ast);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/transform-ast.js b/node_modules/@babel/core/lib/transform-ast.js
new file mode 100644
index 00000000..13f18a40
--- /dev/null
+++ b/node_modules/@babel/core/lib/transform-ast.js
@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _config = _interopRequireDefault(require("./config"));
+
+var _transformation = require("./transformation");
+
+var _transformAstSync = _interopRequireDefault(require("./transform-ast-sync"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var transformFromAst = function transformFromAst(ast, code, opts, callback) {
+  if (typeof opts === "function") {
+    opts = undefined;
+    callback = opts;
+  }
+
+  if (callback === undefined) return (0, _transformAstSync.default)(ast, code, opts);
+  const cb = callback;
+  process.nextTick(() => {
+    let cfg;
+
+    try {
+      cfg = (0, _config.default)(opts);
+      if (cfg === null) return cb(null, null);
+    } catch (err) {
+      return cb(err);
+    }
+
+    if (!ast) return cb(new Error("No AST given"));
+    (0, _transformation.runAsync)(cfg, code, ast, cb);
+  });
+};
+
+exports.default = transformFromAst;
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/transform-file-browser.js b/node_modules/@babel/core/lib/transform-file-browser.js
new file mode 100644
index 00000000..735e5829
--- /dev/null
+++ b/node_modules/@babel/core/lib/transform-file-browser.js
@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = transformFile;
+
+function transformFile(filename, opts = {}, callback) {
+  if (typeof opts === "function") {
+    callback = opts;
+  }
+
+  callback(new Error("Transforming files is not supported in browsers"), null);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/transform-file-sync-browser.js b/node_modules/@babel/core/lib/transform-file-sync-browser.js
new file mode 100644
index 00000000..3f5740dd
--- /dev/null
+++ b/node_modules/@babel/core/lib/transform-file-sync-browser.js
@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = transformFileSync;
+
+function transformFileSync() {
+  throw new Error("Transforming files is not supported in browsers");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/transform-file-sync.js b/node_modules/@babel/core/lib/transform-file-sync.js
new file mode 100644
index 00000000..53086e55
--- /dev/null
+++ b/node_modules/@babel/core/lib/transform-file-sync.js
@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = transformFileSync;
+
+function _fs() {
+  const data = _interopRequireDefault(require("fs"));
+
+  _fs = function _fs() {
+    return data;
+  };
+
+  return data;
+}
+
+var _config = _interopRequireDefault(require("./config"));
+
+var _transformation = require("./transformation");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function transformFileSync(filename, opts) {
+  let options;
+
+  if (opts == null) {
+    options = {
+      filename
+    };
+  } else if (opts && typeof opts === "object") {
+    options = Object.assign({}, opts, {
+      filename
+    });
+  }
+
+  const config = (0, _config.default)(options);
+  if (config === null) return null;
+  return (0, _transformation.runSync)(config, _fs().default.readFileSync(filename, "utf8"));
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/transform-file.js b/node_modules/@babel/core/lib/transform-file.js
new file mode 100644
index 00000000..a5d4e5e9
--- /dev/null
+++ b/node_modules/@babel/core/lib/transform-file.js
@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _fs() {
+  const data = _interopRequireDefault(require("fs"));
+
+  _fs = function _fs() {
+    return data;
+  };
+
+  return data;
+}
+
+var _config = _interopRequireDefault(require("./config"));
+
+var _transformation = require("./transformation");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var transformFile = function transformFile(filename, opts, callback) {
+  let options;
+
+  if (typeof opts === "function") {
+    callback = opts;
+    opts = undefined;
+  }
+
+  if (opts == null) {
+    options = {
+      filename
+    };
+  } else if (opts && typeof opts === "object") {
+    options = Object.assign({}, opts, {
+      filename
+    });
+  }
+
+  process.nextTick(() => {
+    let cfg;
+
+    try {
+      cfg = (0, _config.default)(options);
+      if (cfg === null) return callback(null, null);
+    } catch (err) {
+      return callback(err);
+    }
+
+    const config = cfg;
+
+    _fs().default.readFile(filename, "utf8", function (err, code) {
+      if (err) return callback(err, null);
+      (0, _transformation.runAsync)(config, code, null, callback);
+    });
+  });
+};
+
+exports.default = transformFile;
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/transform-sync.js b/node_modules/@babel/core/lib/transform-sync.js
new file mode 100644
index 00000000..f3a36581
--- /dev/null
+++ b/node_modules/@babel/core/lib/transform-sync.js
@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = transformSync;
+
+var _config = _interopRequireDefault(require("./config"));
+
+var _transformation = require("./transformation");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function transformSync(code, opts) {
+  const config = (0, _config.default)(opts);
+  if (config === null) return null;
+  return (0, _transformation.runSync)(config, code);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/transform.js b/node_modules/@babel/core/lib/transform.js
new file mode 100644
index 00000000..7891c38b
--- /dev/null
+++ b/node_modules/@babel/core/lib/transform.js
@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _config = _interopRequireDefault(require("./config"));
+
+var _transformation = require("./transformation");
+
+var _transformSync = _interopRequireDefault(require("./transform-sync"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var transform = function transform(code, opts, callback) {
+  if (typeof opts === "function") {
+    opts = undefined;
+    callback = opts;
+  }
+
+  if (callback === undefined) return (0, _transformSync.default)(code, opts);
+  const cb = callback;
+  process.nextTick(() => {
+    let cfg;
+
+    try {
+      cfg = (0, _config.default)(opts);
+      if (cfg === null) return cb(null, null);
+    } catch (err) {
+      return cb(err);
+    }
+
+    (0, _transformation.runAsync)(cfg, code, null, cb);
+  });
+};
+
+exports.default = transform;
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/transformation/block-hoist-plugin.js b/node_modules/@babel/core/lib/transformation/block-hoist-plugin.js
new file mode 100644
index 00000000..4e6056af
--- /dev/null
+++ b/node_modules/@babel/core/lib/transformation/block-hoist-plugin.js
@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = loadBlockHoistPlugin;
+
+function _sortBy() {
+  const data = _interopRequireDefault(require("lodash/sortBy"));
+
+  _sortBy = function _sortBy() {
+    return data;
+  };
+
+  return data;
+}
+
+var _config = _interopRequireDefault(require("../config"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+let LOADED_PLUGIN;
+
+function loadBlockHoistPlugin() {
+  if (!LOADED_PLUGIN) {
+    const config = (0, _config.default)({
+      babelrc: false,
+      configFile: false,
+      plugins: [blockHoistPlugin]
+    });
+    LOADED_PLUGIN = config ? config.passes[0][0] : undefined;
+    if (!LOADED_PLUGIN) throw new Error("Assertion failure");
+  }
+
+  return LOADED_PLUGIN;
+}
+
+const blockHoistPlugin = {
+  name: "internal.blockHoist",
+  visitor: {
+    Block: {
+      exit({
+        node
+      }) {
+        let hasChange = false;
+
+        for (let i = 0; i < node.body.length; i++) {
+          const bodyNode = node.body[i];
+
+          if (bodyNode && bodyNode._blockHoist != null) {
+            hasChange = true;
+            break;
+          }
+        }
+
+        if (!hasChange) return;
+        node.body = (0, _sortBy().default)(node.body, function (bodyNode) {
+          let priority = bodyNode && bodyNode._blockHoist;
+          if (priority == null) priority = 1;
+          if (priority === true) priority = 2;
+          return -1 * priority;
+        });
+      }
+
+    }
+  }
+};
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/transformation/file/file.js b/node_modules/@babel/core/lib/transformation/file/file.js
new file mode 100644
index 00000000..c326b9f9
--- /dev/null
+++ b/node_modules/@babel/core/lib/transformation/file/file.js
@@ -0,0 +1,238 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function helpers() {
+  const data = _interopRequireWildcard(require("@babel/helpers"));
+
+  helpers = function helpers() {
+    return data;
+  };
+
+  return data;
+}
+
+function _traverse() {
+  const data = _interopRequireWildcard(require("@babel/traverse"));
+
+  _traverse = function _traverse() {
+    return data;
+  };
+
+  return data;
+}
+
+function _codeFrame() {
+  const data = require("@babel/code-frame");
+
+  _codeFrame = function _codeFrame() {
+    return data;
+  };
+
+  return data;
+}
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+const errorVisitor = {
+  enter(path, state) {
+    const loc = path.node.loc;
+
+    if (loc) {
+      state.loc = loc;
+      path.stop();
+    }
+  }
+
+};
+
+class File {
+  constructor(options, {
+    code,
+    ast,
+    shebang,
+    inputMap
+  }) {
+    this._map = new Map();
+    this.declarations = {};
+    this.path = null;
+    this.ast = {};
+    this.metadata = {};
+    this.hub = new (_traverse().Hub)(this);
+    this.code = "";
+    this.shebang = "";
+    this.inputMap = null;
+    this.opts = options;
+    this.code = code;
+    this.ast = ast;
+    this.shebang = shebang;
+    this.inputMap = inputMap;
+    this.path = _traverse().NodePath.get({
+      hub: this.hub,
+      parentPath: null,
+      parent: this.ast,
+      container: this.ast,
+      key: "program"
+    }).setContext();
+    this.scope = this.path.scope;
+  }
+
+  set(key, val) {
+    this._map.set(key, val);
+  }
+
+  get(key) {
+    return this._map.get(key);
+  }
+
+  has(key) {
+    return this._map.has(key);
+  }
+
+  getModuleName() {
+    const _this$opts = this.opts,
+          filename = _this$opts.filename,
+          _this$opts$filenameRe = _this$opts.filenameRelative,
+          filenameRelative = _this$opts$filenameRe === void 0 ? filename : _this$opts$filenameRe,
+          moduleId = _this$opts.moduleId,
+          _this$opts$moduleIds = _this$opts.moduleIds,
+          moduleIds = _this$opts$moduleIds === void 0 ? !!moduleId : _this$opts$moduleIds,
+          getModuleId = _this$opts.getModuleId,
+          sourceRootTmp = _this$opts.sourceRoot,
+          _this$opts$moduleRoot = _this$opts.moduleRoot,
+          moduleRoot = _this$opts$moduleRoot === void 0 ? sourceRootTmp : _this$opts$moduleRoot,
+          _this$opts$sourceRoot = _this$opts.sourceRoot,
+          sourceRoot = _this$opts$sourceRoot === void 0 ? moduleRoot : _this$opts$sourceRoot;
+    if (!moduleIds) return null;
+
+    if (moduleId != null && !getModuleId) {
+      return moduleId;
+    }
+
+    let moduleName = moduleRoot != null ? moduleRoot + "/" : "";
+
+    if (filenameRelative) {
+      const sourceRootReplacer = sourceRoot != null ? new RegExp("^" + sourceRoot + "/?") : "";
+      moduleName += filenameRelative.replace(sourceRootReplacer, "").replace(/\.(\w*?)$/, "");
+    }
+
+    moduleName = moduleName.replace(/\\/g, "/");
+
+    if (getModuleId) {
+      return getModuleId(moduleName) || moduleName;
+    } else {
+      return moduleName;
+    }
+  }
+
+  resolveModuleSource(source) {
+    return source;
+  }
+
+  addImport() {
+    throw new Error("This API has been removed. If you're looking for this " + "functionality in Babel 7, you should import the " + "'@babel/helper-module-imports' module and use the functions exposed " + " from that module, such as 'addNamed' or 'addDefault'.");
+  }
+
+  addHelper(name) {
+    const declar = this.declarations[name];
+    if (declar) return t().cloneNode(declar);
+    const generator = this.get("helperGenerator");
+    const runtime = this.get("helpersNamespace");
+
+    if (generator) {
+      const res = generator(name);
+      if (res) return res;
+    } else if (runtime) {
+      return t().memberExpression(t().cloneNode(runtime), t().identifier(name));
+    }
+
+    const uid = this.declarations[name] = this.scope.generateUidIdentifier(name);
+    const dependencies = {};
+
+    for (var _iterator = helpers().getDependencies(name), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i >= _iterator.length) break;
+        _ref = _iterator[_i++];
+      } else {
+        _i = _iterator.next();
+        if (_i.done) break;
+        _ref = _i.value;
+      }
+
+      const dep = _ref;
+      dependencies[dep] = this.addHelper(dep);
+    }
+
+    const _helpers$get = helpers().get(name, dep => dependencies[dep], uid, Object.keys(this.scope.getAllBindings())),
+          nodes = _helpers$get.nodes,
+          globals = _helpers$get.globals;
+
+    globals.forEach(name => {
+      if (this.path.scope.hasBinding(name, true)) {
+        this.path.scope.rename(name);
+      }
+    });
+    nodes.forEach(node => {
+      node._compact = true;
+    });
+    this.path.unshiftContainer("body", nodes);
+    this.path.get("body").forEach(path => {
+      if (nodes.indexOf(path.node) === -1) return;
+      if (path.isVariableDeclaration()) this.scope.registerDeclaration(path);
+    });
+    return uid;
+  }
+
+  addTemplateObject() {
+    throw new Error("This function has been moved into the template literal transform itself.");
+  }
+
+  buildCodeFrameError(node, msg, Error = SyntaxError) {
+    let loc = node && (node.loc || node._loc);
+    msg = `${this.opts.filename}: ${msg}`;
+
+    if (!loc && node) {
+      const state = {
+        loc: null
+      };
+      (0, _traverse().default)(node, errorVisitor, this.scope, state);
+      loc = state.loc;
+      let txt = "This is an error on an internal node. Probably an internal error.";
+      if (loc) txt += " Location has been estimated.";
+      msg += ` (${txt})`;
+    }
+
+    if (loc) {
+      const _this$opts$highlightC = this.opts.highlightCode,
+            highlightCode = _this$opts$highlightC === void 0 ? true : _this$opts$highlightC;
+      msg += "\n" + (0, _codeFrame().codeFrameColumns)(this.code, {
+        start: {
+          line: loc.start.line,
+          column: loc.start.column + 1
+        }
+      }, {
+        highlightCode
+      });
+    }
+
+    return new Error(msg);
+  }
+
+}
+
+exports.default = File;
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/transformation/file/generate.js b/node_modules/@babel/core/lib/transformation/file/generate.js
new file mode 100644
index 00000000..98f2a54f
--- /dev/null
+++ b/node_modules/@babel/core/lib/transformation/file/generate.js
@@ -0,0 +1,114 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = generateCode;
+
+function _convertSourceMap() {
+  const data = _interopRequireDefault(require("convert-source-map"));
+
+  _convertSourceMap = function _convertSourceMap() {
+    return data;
+  };
+
+  return data;
+}
+
+function _generator() {
+  const data = _interopRequireDefault(require("@babel/generator"));
+
+  _generator = function _generator() {
+    return data;
+  };
+
+  return data;
+}
+
+var _mergeMap = _interopRequireDefault(require("./merge-map"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function generateCode(pluginPasses, file) {
+  const opts = file.opts,
+        ast = file.ast,
+        shebang = file.shebang,
+        code = file.code,
+        inputMap = file.inputMap;
+  const results = [];
+
+  for (var _iterator = pluginPasses, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref;
+
+    if (_isArray) {
+      if (_i >= _iterator.length) break;
+      _ref = _iterator[_i++];
+    } else {
+      _i = _iterator.next();
+      if (_i.done) break;
+      _ref = _i.value;
+    }
+
+    const plugins = _ref;
+
+    for (var _iterator2 = plugins, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+      var _ref2;
+
+      if (_isArray2) {
+        if (_i2 >= _iterator2.length) break;
+        _ref2 = _iterator2[_i2++];
+      } else {
+        _i2 = _iterator2.next();
+        if (_i2.done) break;
+        _ref2 = _i2.value;
+      }
+
+      const plugin = _ref2;
+      const generatorOverride = plugin.generatorOverride;
+
+      if (generatorOverride) {
+        const result = generatorOverride(ast, opts.generatorOpts, code, _generator().default);
+        if (result !== undefined) results.push(result);
+      }
+    }
+  }
+
+  let result;
+
+  if (results.length === 0) {
+    result = (0, _generator().default)(ast, opts.generatorOpts, code);
+  } else if (results.length === 1) {
+    result = results[0];
+
+    if (typeof result.then === "function") {
+      throw new Error(`You appear to be using an async parser plugin, ` + `which your current version of Babel does not support. ` + `If you're using a published plugin, ` + `you may need to upgrade your @babel/core version.`);
+    }
+  } else {
+    throw new Error("More than one plugin attempted to override codegen.");
+  }
+
+  let _result = result,
+      outputCode = _result.code,
+      outputMap = _result.map;
+
+  if (shebang) {
+    outputCode = `${shebang}\n${outputCode}`;
+  }
+
+  if (outputMap && inputMap) {
+    outputMap = (0, _mergeMap.default)(inputMap.toObject(), outputMap);
+  }
+
+  if (opts.sourceMaps === "inline" || opts.sourceMaps === "both") {
+    outputCode += "\n" + _convertSourceMap().default.fromObject(outputMap).toComment();
+  }
+
+  if (opts.sourceMaps === "inline") {
+    outputMap = null;
+  }
+
+  return {
+    outputCode,
+    outputMap
+  };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/transformation/file/merge-map.js b/node_modules/@babel/core/lib/transformation/file/merge-map.js
new file mode 100644
index 00000000..6f0edd17
--- /dev/null
+++ b/node_modules/@babel/core/lib/transformation/file/merge-map.js
@@ -0,0 +1,332 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = mergeSourceMap;
+
+function _sourceMap() {
+  const data = _interopRequireDefault(require("source-map"));
+
+  _sourceMap = function _sourceMap() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function mergeSourceMap(inputMap, map) {
+  const input = buildMappingData(inputMap);
+  const output = buildMappingData(map);
+  const mergedGenerator = new (_sourceMap().default.SourceMapGenerator)();
+
+  for (var _iterator = input.sources, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref2;
+
+    if (_isArray) {
+      if (_i >= _iterator.length) break;
+      _ref2 = _iterator[_i++];
+    } else {
+      _i = _iterator.next();
+      if (_i.done) break;
+      _ref2 = _i.value;
+    }
+
+    const _ref = _ref2;
+    const source = _ref.source;
+
+    if (typeof source.content === "string") {
+      mergedGenerator.setSourceContent(source.path, source.content);
+    }
+  }
+
+  if (output.sources.length === 1) {
+    const defaultSource = output.sources[0];
+    const insertedMappings = new Map();
+    eachInputGeneratedRange(input, (generated, original, source) => {
+      eachOverlappingGeneratedOutputRange(defaultSource, generated, item => {
+        const key = makeMappingKey(item);
+        if (insertedMappings.has(key)) return;
+        insertedMappings.set(key, item);
+        mergedGenerator.addMapping({
+          source: source.path,
+          original: {
+            line: original.line,
+            column: original.columnStart
+          },
+          generated: {
+            line: item.line,
+            column: item.columnStart
+          },
+          name: original.name
+        });
+      });
+    });
+
+    for (var _iterator2 = insertedMappings.values(), _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+      var _ref3;
+
+      if (_isArray2) {
+        if (_i2 >= _iterator2.length) break;
+        _ref3 = _iterator2[_i2++];
+      } else {
+        _i2 = _iterator2.next();
+        if (_i2.done) break;
+        _ref3 = _i2.value;
+      }
+
+      const item = _ref3;
+
+      if (item.columnEnd === Infinity) {
+        continue;
+      }
+
+      const clearItem = {
+        line: item.line,
+        columnStart: item.columnEnd
+      };
+      const key = makeMappingKey(clearItem);
+
+      if (insertedMappings.has(key)) {
+        continue;
+      }
+
+      mergedGenerator.addMapping({
+        generated: {
+          line: clearItem.line,
+          column: clearItem.columnStart
+        }
+      });
+    }
+  }
+
+  const result = mergedGenerator.toJSON();
+
+  if (typeof input.sourceRoot === "string") {
+    result.sourceRoot = input.sourceRoot;
+  }
+
+  return result;
+}
+
+function makeMappingKey(item) {
+  return JSON.stringify([item.line, item.columnStart]);
+}
+
+function eachOverlappingGeneratedOutputRange(outputFile, inputGeneratedRange, callback) {
+  const overlappingOriginal = filterApplicableOriginalRanges(outputFile, inputGeneratedRange);
+
+  for (var _iterator3 = overlappingOriginal, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
+    var _ref5;
+
+    if (_isArray3) {
+      if (_i3 >= _iterator3.length) break;
+      _ref5 = _iterator3[_i3++];
+    } else {
+      _i3 = _iterator3.next();
+      if (_i3.done) break;
+      _ref5 = _i3.value;
+    }
+
+    const _ref4 = _ref5;
+    const generated = _ref4.generated;
+
+    for (var _iterator4 = generated, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
+      var _ref6;
+
+      if (_isArray4) {
+        if (_i4 >= _iterator4.length) break;
+        _ref6 = _iterator4[_i4++];
+      } else {
+        _i4 = _iterator4.next();
+        if (_i4.done) break;
+        _ref6 = _i4.value;
+      }
+
+      const item = _ref6;
+      callback(item);
+    }
+  }
+}
+
+function filterApplicableOriginalRanges({
+  mappings
+}, {
+  line,
+  columnStart,
+  columnEnd
+}) {
+  return filterSortedArray(mappings, ({
+    original: outOriginal
+  }) => {
+    if (line > outOriginal.line) return -1;
+    if (line < outOriginal.line) return 1;
+    if (columnStart >= outOriginal.columnEnd) return -1;
+    if (columnEnd <= outOriginal.columnStart) return 1;
+    return 0;
+  });
+}
+
+function eachInputGeneratedRange(map, callback) {
+  for (var _iterator5 = map.sources, _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) {
+    var _ref8;
+
+    if (_isArray5) {
+      if (_i5 >= _iterator5.length) break;
+      _ref8 = _iterator5[_i5++];
+    } else {
+      _i5 = _iterator5.next();
+      if (_i5.done) break;
+      _ref8 = _i5.value;
+    }
+
+    const _ref7 = _ref8;
+    const source = _ref7.source,
+          mappings = _ref7.mappings;
+
+    for (var _iterator6 = mappings, _isArray6 = Array.isArray(_iterator6), _i6 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) {
+      var _ref10;
+
+      if (_isArray6) {
+        if (_i6 >= _iterator6.length) break;
+        _ref10 = _iterator6[_i6++];
+      } else {
+        _i6 = _iterator6.next();
+        if (_i6.done) break;
+        _ref10 = _i6.value;
+      }
+
+      const _ref9 = _ref10;
+      const original = _ref9.original,
+            generated = _ref9.generated;
+
+      for (var _iterator7 = generated, _isArray7 = Array.isArray(_iterator7), _i7 = 0, _iterator7 = _isArray7 ? _iterator7 : _iterator7[Symbol.iterator]();;) {
+        var _ref11;
+
+        if (_isArray7) {
+          if (_i7 >= _iterator7.length) break;
+          _ref11 = _iterator7[_i7++];
+        } else {
+          _i7 = _iterator7.next();
+          if (_i7.done) break;
+          _ref11 = _i7.value;
+        }
+
+        const item = _ref11;
+        callback(item, original, source);
+      }
+    }
+  }
+}
+
+function buildMappingData(map) {
+  const consumer = new (_sourceMap().default.SourceMapConsumer)(Object.assign({}, map, {
+    sourceRoot: null
+  }));
+  const sources = new Map();
+  const mappings = new Map();
+  let last = null;
+  consumer.computeColumnSpans();
+  consumer.eachMapping(m => {
+    if (m.originalLine === null) return;
+    let source = sources.get(m.source);
+
+    if (!source) {
+      source = {
+        path: m.source,
+        content: consumer.sourceContentFor(m.source, true)
+      };
+      sources.set(m.source, source);
+    }
+
+    let sourceData = mappings.get(source);
+
+    if (!sourceData) {
+      sourceData = {
+        source,
+        mappings: []
+      };
+      mappings.set(source, sourceData);
+    }
+
+    const obj = {
+      line: m.originalLine,
+      columnStart: m.originalColumn,
+      columnEnd: Infinity,
+      name: m.name
+    };
+
+    if (last && last.source === source && last.mapping.line === m.originalLine) {
+      last.mapping.columnEnd = m.originalColumn;
+    }
+
+    last = {
+      source,
+      mapping: obj
+    };
+    sourceData.mappings.push({
+      original: obj,
+      generated: consumer.allGeneratedPositionsFor({
+        source: m.source,
+        line: m.originalLine,
+        column: m.originalColumn
+      }).map(item => ({
+        line: item.line,
+        columnStart: item.column,
+        columnEnd: item.lastColumn + 1
+      }))
+    });
+  }, null, _sourceMap().default.SourceMapConsumer.ORIGINAL_ORDER);
+  return {
+    file: map.file,
+    sourceRoot: map.sourceRoot,
+    sources: Array.from(mappings.values())
+  };
+}
+
+function findInsertionLocation(array, callback) {
+  let left = 0;
+  let right = array.length;
+
+  while (left < right) {
+    const mid = Math.floor((left + right) / 2);
+    const item = array[mid];
+    const result = callback(item);
+
+    if (result === 0) {
+      left = mid;
+      break;
+    }
+
+    if (result >= 0) {
+      right = mid;
+    } else {
+      left = mid + 1;
+    }
+  }
+
+  let i = left;
+
+  if (i < array.length) {
+    while (i > 0 && callback(array[i]) >= 0) {
+      i--;
+    }
+
+    return i + 1;
+  }
+
+  return i;
+}
+
+function filterSortedArray(array, callback) {
+  const start = findInsertionLocation(array, callback);
+  const results = [];
+
+  for (let i = start; i < array.length && callback(array[i]) === 0; i++) {
+    results.push(array[i]);
+  }
+
+  return results;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/transformation/index.js b/node_modules/@babel/core/lib/transformation/index.js
new file mode 100644
index 00000000..fc6aedba
--- /dev/null
+++ b/node_modules/@babel/core/lib/transformation/index.js
@@ -0,0 +1,137 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runAsync = runAsync;
+exports.runSync = runSync;
+
+function _traverse() {
+  const data = _interopRequireDefault(require("@babel/traverse"));
+
+  _traverse = function _traverse() {
+    return data;
+  };
+
+  return data;
+}
+
+var _pluginPass = _interopRequireDefault(require("./plugin-pass"));
+
+var _blockHoistPlugin = _interopRequireDefault(require("./block-hoist-plugin"));
+
+var _normalizeOpts = _interopRequireDefault(require("./normalize-opts"));
+
+var _normalizeFile = _interopRequireDefault(require("./normalize-file"));
+
+var _generate = _interopRequireDefault(require("./file/generate"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function runAsync(config, code, ast, callback) {
+  let result;
+
+  try {
+    result = runSync(config, code, ast);
+  } catch (err) {
+    return callback(err);
+  }
+
+  return callback(null, result);
+}
+
+function runSync(config, code, ast) {
+  const file = (0, _normalizeFile.default)(config.passes, (0, _normalizeOpts.default)(config), code, ast);
+  transformFile(file, config.passes);
+  const opts = file.opts;
+
+  const _ref = opts.code !== false ? (0, _generate.default)(config.passes, file) : {},
+        outputCode = _ref.outputCode,
+        outputMap = _ref.outputMap;
+
+  return {
+    metadata: file.metadata,
+    options: opts,
+    ast: opts.ast === true ? file.ast : null,
+    code: outputCode === undefined ? null : outputCode,
+    map: outputMap === undefined ? null : outputMap,
+    sourceType: file.ast.program.sourceType
+  };
+}
+
+function transformFile(file, pluginPasses) {
+  for (var _iterator = pluginPasses, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref2;
+
+    if (_isArray) {
+      if (_i >= _iterator.length) break;
+      _ref2 = _iterator[_i++];
+    } else {
+      _i = _iterator.next();
+      if (_i.done) break;
+      _ref2 = _i.value;
+    }
+
+    const pluginPairs = _ref2;
+    const passPairs = [];
+    const passes = [];
+    const visitors = [];
+
+    for (var _iterator2 = pluginPairs.concat([(0, _blockHoistPlugin.default)()]), _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+      var _ref3;
+
+      if (_isArray2) {
+        if (_i2 >= _iterator2.length) break;
+        _ref3 = _iterator2[_i2++];
+      } else {
+        _i2 = _iterator2.next();
+        if (_i2.done) break;
+        _ref3 = _i2.value;
+      }
+
+      const plugin = _ref3;
+      const pass = new _pluginPass.default(file, plugin.key, plugin.options);
+      passPairs.push([plugin, pass]);
+      passes.push(pass);
+      visitors.push(plugin.visitor);
+    }
+
+    for (var _i3 = 0; _i3 < passPairs.length; _i3++) {
+      const _passPairs$_i = passPairs[_i3],
+            plugin = _passPairs$_i[0],
+            pass = _passPairs$_i[1];
+      const fn = plugin.pre;
+
+      if (fn) {
+        const result = fn.call(pass, file);
+
+        if (isThenable(result)) {
+          throw new Error(`You appear to be using an plugin with an async .pre, ` + `which your current version of Babel does not support.` + `If you're using a published plugin, you may need to upgrade ` + `your @babel/core version.`);
+        }
+      }
+    }
+
+    const visitor = _traverse().default.visitors.merge(visitors, passes, file.opts.wrapPluginVisitorMethod);
+
+    (0, _traverse().default)(file.ast, visitor, file.scope);
+
+    for (var _i4 = 0; _i4 < passPairs.length; _i4++) {
+      const _passPairs$_i2 = passPairs[_i4],
+            plugin = _passPairs$_i2[0],
+            pass = _passPairs$_i2[1];
+      const fn = plugin.post;
+
+      if (fn) {
+        const result = fn.call(pass, file);
+
+        if (isThenable(result)) {
+          throw new Error(`You appear to be using an plugin with an async .post, ` + `which your current version of Babel does not support.` + `If you're using a published plugin, you may need to upgrade ` + `your @babel/core version.`);
+        }
+      }
+    }
+  }
+}
+
+function isThenable(val) {
+  return !!val && (typeof val === "object" || typeof val === "function") && typeof val.then === "function";
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/transformation/normalize-file.js b/node_modules/@babel/core/lib/transformation/normalize-file.js
new file mode 100644
index 00000000..6d21f2ef
--- /dev/null
+++ b/node_modules/@babel/core/lib/transformation/normalize-file.js
@@ -0,0 +1,176 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = normalizeFile;
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _convertSourceMap() {
+  const data = _interopRequireDefault(require("convert-source-map"));
+
+  _convertSourceMap = function _convertSourceMap() {
+    return data;
+  };
+
+  return data;
+}
+
+function _babylon() {
+  const data = require("babylon");
+
+  _babylon = function _babylon() {
+    return data;
+  };
+
+  return data;
+}
+
+function _codeFrame() {
+  const data = require("@babel/code-frame");
+
+  _codeFrame = function _codeFrame() {
+    return data;
+  };
+
+  return data;
+}
+
+var _file = _interopRequireDefault(require("./file/file"));
+
+var _missingPluginHelper = _interopRequireDefault(require("./util/missing-plugin-helper"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+const shebangRegex = /^#!.*/;
+
+function normalizeFile(pluginPasses, options, code, ast) {
+  code = `${code || ""}`;
+  let shebang = null;
+  let inputMap = null;
+
+  if (options.inputSourceMap !== false) {
+    inputMap = _convertSourceMap().default.fromSource(code);
+
+    if (inputMap) {
+      code = _convertSourceMap().default.removeComments(code);
+    } else if (typeof options.inputSourceMap === "object") {
+      inputMap = _convertSourceMap().default.fromObject(options.inputSourceMap);
+    }
+  }
+
+  const shebangMatch = shebangRegex.exec(code);
+
+  if (shebangMatch) {
+    shebang = shebangMatch[0];
+    code = code.replace(shebangRegex, "");
+  }
+
+  if (ast) {
+    if (ast.type === "Program") {
+      ast = t().file(ast, [], []);
+    } else if (ast.type !== "File") {
+      throw new Error("AST root must be a Program or File node");
+    }
+  } else {
+    ast = parser(pluginPasses, options, code);
+  }
+
+  return new _file.default(options, {
+    code,
+    ast,
+    shebang,
+    inputMap
+  });
+}
+
+function parser(pluginPasses, options, code) {
+  try {
+    const results = [];
+
+    for (var _iterator = pluginPasses, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i >= _iterator.length) break;
+        _ref = _iterator[_i++];
+      } else {
+        _i = _iterator.next();
+        if (_i.done) break;
+        _ref = _i.value;
+      }
+
+      const plugins = _ref;
+
+      for (var _iterator2 = plugins, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+        var _ref2;
+
+        if (_isArray2) {
+          if (_i2 >= _iterator2.length) break;
+          _ref2 = _iterator2[_i2++];
+        } else {
+          _i2 = _iterator2.next();
+          if (_i2.done) break;
+          _ref2 = _i2.value;
+        }
+
+        const plugin = _ref2;
+        const parserOverride = plugin.parserOverride;
+
+        if (parserOverride) {
+          const ast = parserOverride(code, options.parserOpts, _babylon().parse);
+          if (ast !== undefined) results.push(ast);
+        }
+      }
+    }
+
+    if (results.length === 0) {
+      return (0, _babylon().parse)(code, options.parserOpts);
+    } else if (results.length === 1) {
+      if (typeof results[0].then === "function") {
+        throw new Error(`You appear to be using an async codegen plugin, ` + `which your current version of Babel does not support. ` + `If you're using a published plugin, you may need to upgrade ` + `your @babel/core version.`);
+      }
+
+      return results[0];
+    }
+
+    throw new Error("More than one plugin attempted to override parsing.");
+  } catch (err) {
+    if (err.code === "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED") {
+      err.message += "\nConsider renaming the file to '.mjs', or setting sourceType:module " + "or sourceType:unambiguous in your Babel config for this file.";
+    }
+
+    const loc = err.loc,
+          missingPlugin = err.missingPlugin;
+
+    if (loc) {
+      const codeFrame = (0, _codeFrame().codeFrameColumns)(code, {
+        start: {
+          line: loc.line,
+          column: loc.column + 1
+        }
+      }, options);
+
+      if (missingPlugin) {
+        err.message = `${options.filename || "unknown"}: ` + (0, _missingPluginHelper.default)(missingPlugin[0], loc, codeFrame);
+      } else {
+        err.message = `${options.filename || "unknown"}: ${err.message}\n\n` + codeFrame;
+      }
+
+      err.code = "BABEL_PARSE_ERROR";
+    }
+
+    throw err;
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/transformation/normalize-opts.js b/node_modules/@babel/core/lib/transformation/normalize-opts.js
new file mode 100644
index 00000000..9afc83db
--- /dev/null
+++ b/node_modules/@babel/core/lib/transformation/normalize-opts.js
@@ -0,0 +1,97 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = normalizeOptions;
+
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+
+  _path = function _path() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function normalizeOptions(config) {
+  const _config$options = config.options,
+        filename = _config$options.filename,
+        cwd = _config$options.cwd,
+        _config$options$filen = _config$options.filenameRelative,
+        filenameRelative = _config$options$filen === void 0 ? typeof filename === "string" ? _path().default.relative(cwd, filename) : "unknown" : _config$options$filen,
+        _config$options$sourc = _config$options.sourceType,
+        sourceType = _config$options$sourc === void 0 ? "module" : _config$options$sourc,
+        inputSourceMap = _config$options.inputSourceMap,
+        _config$options$sourc2 = _config$options.sourceMaps,
+        sourceMaps = _config$options$sourc2 === void 0 ? !!inputSourceMap : _config$options$sourc2,
+        moduleRoot = _config$options.moduleRoot,
+        _config$options$sourc3 = _config$options.sourceRoot,
+        sourceRoot = _config$options$sourc3 === void 0 ? moduleRoot : _config$options$sourc3,
+        _config$options$sourc4 = _config$options.sourceFileName,
+        sourceFileName = _config$options$sourc4 === void 0 ? _path().default.basename(filenameRelative) : _config$options$sourc4,
+        _config$options$comme = _config$options.comments,
+        comments = _config$options$comme === void 0 ? true : _config$options$comme,
+        _config$options$compa = _config$options.compact,
+        compact = _config$options$compa === void 0 ? "auto" : _config$options$compa;
+  const opts = config.options;
+  const options = Object.assign({}, opts, {
+    parserOpts: Object.assign({
+      sourceType: _path().default.extname(filenameRelative) === ".mjs" ? "module" : sourceType,
+      sourceFileName: filename,
+      plugins: []
+    }, opts.parserOpts),
+    generatorOpts: Object.assign({
+      filename,
+      auxiliaryCommentBefore: opts.auxiliaryCommentBefore,
+      auxiliaryCommentAfter: opts.auxiliaryCommentAfter,
+      retainLines: opts.retainLines,
+      comments,
+      shouldPrintComment: opts.shouldPrintComment,
+      compact,
+      minified: opts.minified,
+      sourceMaps,
+      sourceRoot,
+      sourceFileName
+    }, opts.generatorOpts)
+  });
+
+  for (var _iterator = config.passes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref;
+
+    if (_isArray) {
+      if (_i >= _iterator.length) break;
+      _ref = _iterator[_i++];
+    } else {
+      _i = _iterator.next();
+      if (_i.done) break;
+      _ref = _i.value;
+    }
+
+    const plugins = _ref;
+
+    for (var _iterator2 = plugins, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+      var _ref2;
+
+      if (_isArray2) {
+        if (_i2 >= _iterator2.length) break;
+        _ref2 = _iterator2[_i2++];
+      } else {
+        _i2 = _iterator2.next();
+        if (_i2.done) break;
+        _ref2 = _i2.value;
+      }
+
+      const plugin = _ref2;
+
+      if (plugin.manipulateOptions) {
+        plugin.manipulateOptions(options, options.parserOpts);
+      }
+    }
+  }
+
+  return options;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/transformation/plugin-pass.js b/node_modules/@babel/core/lib/transformation/plugin-pass.js
new file mode 100644
index 00000000..fe24bfd2
--- /dev/null
+++ b/node_modules/@babel/core/lib/transformation/plugin-pass.js
@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+class PluginPass {
+  constructor(file, key, options) {
+    this._map = new Map();
+    this.key = key;
+    this.file = file;
+    this.opts = options || {};
+    this.filename = typeof file.opts.filename === "string" ? file.opts.filename : undefined;
+  }
+
+  set(key, val) {
+    this._map.set(key, val);
+  }
+
+  get(key) {
+    return this._map.get(key);
+  }
+
+  addHelper(name) {
+    return this.file.addHelper(name);
+  }
+
+  addImport() {
+    return this.file.addImport();
+  }
+
+  getModuleName() {
+    return this.file.getModuleName();
+  }
+
+  buildCodeFrameError(node, msg, Error) {
+    return this.file.buildCodeFrameError(node, msg, Error);
+  }
+
+}
+
+exports.default = PluginPass;
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/transformation/util/missing-plugin-helper.js b/node_modules/@babel/core/lib/transformation/util/missing-plugin-helper.js
new file mode 100644
index 00000000..d568709d
--- /dev/null
+++ b/node_modules/@babel/core/lib/transformation/util/missing-plugin-helper.js
@@ -0,0 +1,237 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = generateMissingPluginMessage;
+const pluginNameMap = {
+  asyncGenerators: {
+    syntax: {
+      name: "@babel/plugin-syntax-async-generators",
+      url: "https://git.io/vb4SY"
+    },
+    transform: {
+      name: "@babel/plugin-proposal-async-generator-functions",
+      url: "https://git.io/vb4yp"
+    }
+  },
+  classProperties: {
+    syntax: {
+      name: "@babel/plugin-syntax-class-properties",
+      url: "https://git.io/vb4yQ"
+    },
+    transform: {
+      name: "@babel/plugin-proposal-class-properties",
+      url: "https://git.io/vb4SL"
+    }
+  },
+  decorators: {
+    syntax: {
+      name: "@babel/plugin-syntax-decorators",
+      url: "https://git.io/vb4y9"
+    },
+    transform: {
+      name: "@babel/plugin-proposal-decorators",
+      url: "https://git.io/vb4ST"
+    }
+  },
+  doExpressions: {
+    syntax: {
+      name: "@babel/plugin-syntax-do-expressions",
+      url: "https://git.io/vb4yh"
+    },
+    transform: {
+      name: "@babel/plugin-proposal-do-expressions",
+      url: "https://git.io/vb4S3"
+    }
+  },
+  dynamicImport: {
+    syntax: {
+      name: "@babel/plugin-syntax-dynamic-import",
+      url: "https://git.io/vb4Sv"
+    }
+  },
+  exportDefaultFrom: {
+    syntax: {
+      name: "@babel/plugin-syntax-export-default-from",
+      url: "https://git.io/vb4SO"
+    },
+    transform: {
+      name: "@babel/plugin-proposal-export-default-from",
+      url: "https://git.io/vb4yH"
+    }
+  },
+  exportNamespaceFrom: {
+    syntax: {
+      name: "@babel/plugin-syntax-export-namespace-from",
+      url: "https://git.io/vb4Sf"
+    },
+    transform: {
+      name: "@babel/plugin-proposal-export-namespace-from",
+      url: "https://git.io/vb4SG"
+    }
+  },
+  flow: {
+    syntax: {
+      name: "@babel/plugin-syntax-flow",
+      url: "https://git.io/vb4yb"
+    },
+    transform: {
+      name: "@babel/plugin-transform-flow-strip-types",
+      url: "https://git.io/vb49g"
+    }
+  },
+  functionBind: {
+    syntax: {
+      name: "@babel/plugin-syntax-function-bind",
+      url: "https://git.io/vb4y7"
+    },
+    transform: {
+      name: "@babel/plugin-proposal-function-bind",
+      url: "https://git.io/vb4St"
+    }
+  },
+  functionSent: {
+    syntax: {
+      name: "@babel/plugin-syntax-function-sent",
+      url: "https://git.io/vb4yN"
+    },
+    transform: {
+      name: "@babel/plugin-proposal-function-sent",
+      url: "https://git.io/vb4SZ"
+    }
+  },
+  importMeta: {
+    syntax: {
+      name: "@babel/plugin-syntax-import-meta",
+      url: "https://git.io/vbKK6"
+    }
+  },
+  jsx: {
+    syntax: {
+      name: "@babel/plugin-syntax-jsx",
+      url: "https://git.io/vb4yA"
+    },
+    transform: {
+      name: "@babel/plugin-transform-react-jsx",
+      url: "https://git.io/vb4yd"
+    }
+  },
+  logicalAssignment: {
+    syntax: {
+      name: "@babel/plugin-syntax-logical-assignment-operators",
+      url: "https://git.io/vAlBp"
+    },
+    transform: {
+      name: "@babel/plugin-proposal-logical-assignment-operators",
+      url: "https://git.io/vAlRe"
+    }
+  },
+  nullishCoalescingOperator: {
+    syntax: {
+      name: "@babel/plugin-syntax-nullish-coalescing-operator",
+      url: "https://git.io/vb4yx"
+    },
+    transform: {
+      name: "@babel/plugin-proposal-nullish-coalescing-operator",
+      url: "https://git.io/vb4Se"
+    }
+  },
+  numericSeparator: {
+    syntax: {
+      name: "@babel/plugin-syntax-numeric-separator",
+      url: "https://git.io/vb4Sq"
+    },
+    transform: {
+      name: "@babel/plugin-proposal-numeric-separator",
+      url: "https://git.io/vb4yS"
+    }
+  },
+  objectRestSpread: {
+    syntax: {
+      name: "@babel/plugin-syntax-object-rest-spread",
+      url: "https://git.io/vb4y5"
+    },
+    transform: {
+      name: "@babel/plugin-proposal-object-rest-spread",
+      url: "https://git.io/vb4Ss"
+    }
+  },
+  optionalCatchBinding: {
+    syntax: {
+      name: "@babel/plugin-syntax-optional-catch-binding",
+      url: "https://git.io/vb4Sn"
+    },
+    transform: {
+      name: "@babel/plugin-proposal-optional-catch-binding",
+      url: "https://git.io/vb4SI"
+    }
+  },
+  optionalChaining: {
+    syntax: {
+      name: "@babel/plugin-syntax-optional-chaining",
+      url: "https://git.io/vb4Sc"
+    },
+    transform: {
+      name: "@babel/plugin-proposal-optional-chaining",
+      url: "https://git.io/vb4Sk"
+    }
+  },
+  pipelineOperator: {
+    syntax: {
+      name: "@babel/plugin-syntax-pipeline-operator",
+      url: "https://git.io/vb4yj"
+    },
+    transform: {
+      name: "@babel/plugin-proposal-pipeline-operator",
+      url: "https://git.io/vb4SU"
+    }
+  },
+  throwExpressions: {
+    syntax: {
+      name: "@babel/plugin-syntax-throw-expressions",
+      url: "https://git.io/vb4SJ"
+    },
+    transform: {
+      name: "@babel/plugin-proposal-throw-expressions",
+      url: "https://git.io/vb4yF"
+    }
+  },
+  typescript: {
+    syntax: {
+      name: "@babel/plugin-syntax-typescript",
+      url: "https://git.io/vb4SC"
+    },
+    transform: {
+      name: "@babel/plugin-transform-typescript",
+      url: "https://git.io/vb4Sm"
+    }
+  }
+};
+
+const getNameURLCombination = ({
+  name,
+  url
+}) => `${name} (${url})`;
+
+function generateMissingPluginMessage(missingPluginName, loc, codeFrame) {
+  let helpMessage = `Support for the experimental syntax '${missingPluginName}' isn't currently enabled ` + `(${loc.line}:${loc.column + 1}):\n\n` + codeFrame;
+  const pluginInfo = pluginNameMap[missingPluginName];
+
+  if (pluginInfo) {
+    const syntaxPlugin = pluginInfo.syntax,
+          transformPlugin = pluginInfo.transform;
+
+    if (syntaxPlugin) {
+      if (transformPlugin) {
+        const transformPluginInfo = getNameURLCombination(transformPlugin);
+        helpMessage += `\n\nAdd ${transformPluginInfo} to the 'plugins' section of your Babel config ` + `to enable transformation.`;
+      } else {
+        const syntaxPluginInfo = getNameURLCombination(syntaxPlugin);
+        helpMessage += `\n\nAdd ${syntaxPluginInfo} to the 'plugins' section of your Babel config ` + `to enable parsing.`;
+      }
+    }
+  }
+
+  return helpMessage;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/node_modules/.bin/babylon b/node_modules/@babel/core/node_modules/.bin/babylon
new file mode 120000
index 00000000..5acfefcc
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/.bin/babylon
@@ -0,0 +1 @@
+../../../../babylon/bin/babylon.js
\ No newline at end of file
diff --git a/node_modules/@babel/core/node_modules/.bin/json5 b/node_modules/@babel/core/node_modules/.bin/json5
new file mode 120000
index 00000000..ea747651
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/.bin/json5
@@ -0,0 +1 @@
+../../../../json5/lib/cli.js
\ No newline at end of file
diff --git a/node_modules/@babel/core/node_modules/.bin/semver b/node_modules/@babel/core/node_modules/.bin/semver
new file mode 120000
index 00000000..7a17f06e
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/.bin/semver
@@ -0,0 +1 @@
+../../../../semver/bin/semver
\ No newline at end of file
diff --git a/node_modules/@babel/core/node_modules/arr-diff/LICENSE b/node_modules/@babel/core/node_modules/arr-diff/LICENSE
new file mode 100755
index 00000000..fa30c4cb
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/arr-diff/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2015, Jon Schlinkert.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/node_modules/@babel/core/node_modules/arr-diff/README.md b/node_modules/@babel/core/node_modules/arr-diff/README.md
new file mode 100644
index 00000000..7705c6cd
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/arr-diff/README.md
@@ -0,0 +1,74 @@
+# arr-diff [![NPM version](https://img.shields.io/npm/v/arr-diff.svg)](https://www.npmjs.com/package/arr-diff) [![Build Status](https://img.shields.io/travis/jonschlinkert/base.svg)](https://travis-ci.org/jonschlinkert/base)
+
+> Returns an array with only the unique values from the first array, by excluding all values from additional arrays using strict equality for comparisons.
+
+## Install
+
+Install with [npm](https://www.npmjs.com/)
+
+```sh
+$ npm i arr-diff --save
+```
+Install with [bower](http://bower.io/)
+
+```sh
+$ bower install arr-diff --save
+```
+
+## API
+
+### [diff](index.js#L33)
+
+Return the difference between the first array and additional arrays.
+
+**Params**
+
+* `a` **{Array}**
+* `b` **{Array}**
+* `returns` **{Array}**
+
+**Example**
+
+```js
+var diff = require('arr-diff');
+
+var a = ['a', 'b', 'c', 'd'];
+var b = ['b', 'c'];
+
+console.log(diff(a, b))
+//=> ['a', 'd']
+```
+
+## Related projects
+
+* [arr-flatten](https://www.npmjs.com/package/arr-flatten): Recursively flatten an array or arrays. This is the fastest implementation of array flatten. | [homepage](https://github.com/jonschlinkert/arr-flatten)
+* [array-filter](https://www.npmjs.com/package/array-filter): Array#filter for older browsers. | [homepage](https://github.com/juliangruber/array-filter)
+* [array-intersection](https://www.npmjs.com/package/array-intersection): Return an array with the unique values present in _all_ given arrays using strict equality… [more](https://www.npmjs.com/package/array-intersection) | [homepage](https://github.com/jonschlinkert/array-intersection)
+
+## Running tests
+
+Install dev dependencies:
+
+```sh
+$ npm i -d && npm test
+```
+
+## Contributing
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](https://github.com/jonschlinkert/arr-diff/issues/new).
+
+## Author
+
+**Jon Schlinkert**
+
++ [github/jonschlinkert](https://github.com/jonschlinkert)
++ [twitter/jonschlinkert](http://twitter.com/jonschlinkert)
+
+## License
+
+Copyright © 2015 [Jon Schlinkert](https://github.com/jonschlinkert)
+Released under the MIT license.
+
+***
+
+_This file was generated by [verb](https://github.com/verbose/verb) on Sat Dec 05 2015 23:24:53 GMT-0500 (EST)._
diff --git a/node_modules/@babel/core/node_modules/arr-diff/index.js b/node_modules/@babel/core/node_modules/arr-diff/index.js
new file mode 100644
index 00000000..bc7200d8
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/arr-diff/index.js
@@ -0,0 +1,58 @@
+/*!
+ * arr-diff <https://github.com/jonschlinkert/arr-diff>
+ *
+ * Copyright (c) 2014 Jon Schlinkert, contributors.
+ * Licensed under the MIT License
+ */
+
+'use strict';
+
+var flatten = require('arr-flatten');
+var slice = [].slice;
+
+/**
+ * Return the difference between the first array and
+ * additional arrays.
+ *
+ * ```js
+ * var diff = require('{%= name %}');
+ *
+ * var a = ['a', 'b', 'c', 'd'];
+ * var b = ['b', 'c'];
+ *
+ * console.log(diff(a, b))
+ * //=> ['a', 'd']
+ * ```
+ *
+ * @param  {Array} `a`
+ * @param  {Array} `b`
+ * @return {Array}
+ * @api public
+ */
+
+function diff(arr, arrays) {
+  var argsLen = arguments.length;
+  var len = arr.length, i = -1;
+  var res = [], arrays;
+
+  if (argsLen === 1) {
+    return arr;
+  }
+
+  if (argsLen > 2) {
+    arrays = flatten(slice.call(arguments, 1));
+  }
+
+  while (++i < len) {
+    if (!~arrays.indexOf(arr[i])) {
+      res.push(arr[i]);
+    }
+  }
+  return res;
+}
+
+/**
+ * Expose `diff`
+ */
+
+module.exports = diff;
diff --git a/node_modules/@babel/core/node_modules/arr-diff/package.json b/node_modules/@babel/core/node_modules/arr-diff/package.json
new file mode 100644
index 00000000..d40c2103
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/arr-diff/package.json
@@ -0,0 +1,49 @@
+{
+  "name": "arr-diff",
+  "description": "Returns an array with only the unique values from the first array, by excluding all values from additional arrays using strict equality for comparisons.",
+  "version": "2.0.0",
+  "homepage": "https://github.com/jonschlinkert/arr-diff",
+  "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
+  "repository": "jonschlinkert/arr-diff",
+  "bugs": {
+    "url": "https://github.com/jonschlinkert/arr-diff/issues"
+  },
+  "license": "MIT",
+  "files": [
+    "index.js"
+  ],
+  "main": "index.js",
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "dependencies": {
+    "arr-flatten": "^1.0.1"
+  },
+  "devDependencies": {
+    "array-differ": "^1.0.0",
+    "array-slice": "^0.2.3",
+    "benchmarked": "^0.1.4",
+    "chalk": "^1.1.1",
+    "mocha": "*",
+    "should": "*"
+  },
+  "keywords": [
+    "arr",
+    "array",
+    "diff",
+    "differ",
+    "difference"
+  ],
+  "verb": {
+    "related": {
+      "list": [
+        "arr-flatten",
+        "array-filter",
+        "array-intersection"
+      ]
+    }
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/node_modules/array-unique/LICENSE b/node_modules/@babel/core/node_modules/array-unique/LICENSE
new file mode 100755
index 00000000..fa30c4cb
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/array-unique/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2015, Jon Schlinkert.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/node_modules/@babel/core/node_modules/array-unique/README.md b/node_modules/@babel/core/node_modules/array-unique/README.md
new file mode 100755
index 00000000..2e287743
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/array-unique/README.md
@@ -0,0 +1,51 @@
+# array-unique [![NPM version](https://badge.fury.io/js/array-unique.svg)](http://badge.fury.io/js/array-unique)  [![Build Status](https://travis-ci.org/jonschlinkert/array-unique.svg)](https://travis-ci.org/jonschlinkert/array-unique) 
+
+> Return an array free of duplicate values. Fastest ES5 implementation.
+
+## Install with [npm](npmjs.org)
+
+```bash
+npm i array-unique --save
+```
+
+## Usage
+
+```js
+var unique = require('array-unique');
+
+unique(['a', 'b', 'c', 'c']);
+//=> ['a', 'b', 'c']
+```
+
+## Related
+* [arr-diff](https://github.com/jonschlinkert/arr-diff): Returns an array with only the unique values from the first array, by excluding all values from additional arrays using strict equality for comparisons.
+* [arr-union](https://github.com/jonschlinkert/arr-union): Returns an array of unique values using strict equality for comparisons.
+* [arr-flatten](https://github.com/jonschlinkert/arr-flatten): Recursively flatten an array or arrays. This is the fastest implementation of array flatten.
+* [arr-reduce](https://github.com/jonschlinkert/arr-reduce): Fast array reduce that also loops over sparse elements.
+* [arr-map](https://github.com/jonschlinkert/arr-map): Faster, node.js focused alternative to JavaScript's native array map.
+* [arr-pluck](https://github.com/jonschlinkert/arr-pluck): Retrieves the value of a specified property from all elements in the collection.
+
+## Run tests
+Install dev dependencies.
+
+```bash
+npm i -d && npm test
+```
+
+## Contributing
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](https://github.com/jonschlinkert/array-unique/issues)
+
+## Author
+
+**Jon Schlinkert**
+ 
++ [github/jonschlinkert](https://github.com/jonschlinkert)
++ [twitter/jonschlinkert](http://twitter.com/jonschlinkert) 
+
+## License
+Copyright (c) 2015 Jon Schlinkert  
+Released under the MIT license
+
+***
+
+_This file was generated by [verb-cli](https://github.com/assemble/verb-cli) on March 24, 2015._
\ No newline at end of file
diff --git a/node_modules/@babel/core/node_modules/array-unique/index.js b/node_modules/@babel/core/node_modules/array-unique/index.js
new file mode 100755
index 00000000..7fa75af9
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/array-unique/index.js
@@ -0,0 +1,28 @@
+/*!
+ * array-unique <https://github.com/jonschlinkert/array-unique>
+ *
+ * Copyright (c) 2014-2015, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+'use strict';
+
+module.exports = function unique(arr) {
+  if (!Array.isArray(arr)) {
+    throw new TypeError('array-unique expects an array.');
+  }
+
+  var len = arr.length;
+  var i = -1;
+
+  while (i++ < len) {
+    var j = i + 1;
+
+    for (; j < arr.length; ++j) {
+      if (arr[i] === arr[j]) {
+        arr.splice(j--, 1);
+      }
+    }
+  }
+  return arr;
+};
diff --git a/node_modules/@babel/core/node_modules/array-unique/package.json b/node_modules/@babel/core/node_modules/array-unique/package.json
new file mode 100755
index 00000000..a493f69b
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/array-unique/package.json
@@ -0,0 +1,37 @@
+{
+  "name": "array-unique",
+  "description": "Return an array free of duplicate values. Fastest ES5 implementation.",
+  "version": "0.2.1",
+  "homepage": "https://github.com/jonschlinkert/array-unique",
+  "author": {
+    "name": "Jon Schlinkert",
+    "url": "https://github.com/jonschlinkert"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/jonschlinkert/array-unique.git"
+  },
+  "bugs": {
+    "url": "https://github.com/jonschlinkert/array-unique/issues"
+  },
+  "license": {
+    "type": "MIT",
+    "url": "https://github.com/jonschlinkert/array-unique/blob/master/LICENSE"
+  },
+  "files": [
+    "index.js"
+  ],
+  "main": "index.js",
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "devDependencies": {
+    "array-uniq": "^1.0.2",
+    "benchmarked": "^0.1.3",
+    "mocha": "*",
+    "should": "*"
+  }
+}
diff --git a/node_modules/@babel/core/node_modules/braces/LICENSE b/node_modules/@babel/core/node_modules/braces/LICENSE
new file mode 100644
index 00000000..39245ac1
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/braces/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2016, Jon Schlinkert.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/node_modules/@babel/core/node_modules/braces/README.md b/node_modules/@babel/core/node_modules/braces/README.md
new file mode 100644
index 00000000..52fa7569
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/braces/README.md
@@ -0,0 +1,248 @@
+# braces [![NPM version](https://img.shields.io/npm/v/braces.svg?style=flat)](https://www.npmjs.com/package/braces) [![NPM downloads](https://img.shields.io/npm/dm/braces.svg?style=flat)](https://npmjs.org/package/braces) [![Build Status](https://img.shields.io/travis/jonschlinkert/braces.svg?style=flat)](https://travis-ci.org/jonschlinkert/braces)
+
+Fastest brace expansion for node.js, with the most complete support for the Bash 4.3 braces specification.
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+$ npm install braces --save
+```
+
+## Features
+
+* Complete support for the braces part of the [Bash 4.3 Brace Expansion](www.gnu.org/software/bash/). Braces passes [all of the relevant unit tests](#bash-4-3-support) from the spec.
+* Expands comma-separated values: `a/{b,c}/d` => `['a/b/d', 'a/c/d']`
+* Expands alphabetical or numerical ranges: `{1..3}` => `['1', '2', '3']`
+* [Very fast](#benchmarks)
+* [Special characters](./patterns.md) can be used to generate interesting patterns.
+
+## Example usage
+
+```js
+var braces = require('braces');
+
+braces('a/{x,y}/c{d}e')
+//=> ['a/x/cde', 'a/y/cde']
+
+braces('a/b/c/{x,y}')
+//=> ['a/b/c/x', 'a/b/c/y']
+
+braces('a/{x,{1..5},y}/c{d}e')
+//=> ['a/x/cde', 'a/1/cde', 'a/y/cde', 'a/2/cde', 'a/3/cde', 'a/4/cde', 'a/5/cde']
+```
+
+### Use case: fixtures
+
+> Use braces to generate test fixtures!
+
+**Example**
+
+```js
+var braces = require('./');
+var path = require('path');
+var fs = require('fs');
+
+braces('blah/{a..z}.js').forEach(function(fp) {
+  if (!fs.existsSync(path.dirname(fp))) {
+    fs.mkdirSync(path.dirname(fp));
+  }
+  fs.writeFileSync(fp, '');
+});
+```
+
+See the [tests](./test/test.js) for more examples and use cases (also see the [bash spec tests](./test/bash-mm-adjusted.js));
+
+### Range expansion
+
+Uses [expand-range](https://github.com/jonschlinkert/expand-range) for range expansion.
+
+```js
+braces('a{1..3}b')
+//=> ['a1b', 'a2b', 'a3b']
+
+braces('a{5..8}b')
+//=> ['a5b', 'a6b', 'a7b', 'a8b']
+
+braces('a{00..05}b')
+//=> ['a00b', 'a01b', 'a02b', 'a03b', 'a04b', 'a05b']
+
+braces('a{01..03}b')
+//=> ['a01b', 'a02b', 'a03b']
+
+braces('a{000..005}b')
+//=> ['a000b', 'a001b', 'a002b', 'a003b', 'a004b', 'a005b']
+
+braces('a{a..e}b')
+//=> ['aab', 'abb', 'acb', 'adb', 'aeb']
+
+braces('a{A..E}b')
+//=> ['aAb', 'aBb', 'aCb', 'aDb', 'aEb']
+```
+
+Pass a function as the last argument to customize range expansions:
+
+```js
+var range = braces('x{a..e}y', function (str, i) {
+  return String.fromCharCode(str) + i;
+});
+
+console.log(range);
+//=> ['xa0y', 'xb1y', 'xc2y', 'xd3y', 'xe4y']
+```
+
+See [expand-range](https://github.com/jonschlinkert/expand-range) for benchmarks, tests and the full list of range expansion features.
+
+## Options
+
+### options.makeRe
+
+Type: `Boolean`
+
+Deafault: `false`
+
+Return a regex-optimal string. If you're using braces to generate regex, this will result in dramatically faster performance.
+
+**Examples**
+
+With the default settings (`{makeRe: false}`):
+
+```js
+braces('{1..5}');
+//=> ['1', '2', '3', '4', '5']
+```
+
+With `{makeRe: true}`:
+
+```js
+braces('{1..5}', {makeRe: true});
+//=> ['[1-5]']
+
+braces('{3..9..3}', {makeRe: true});
+//=> ['(3|6|9)']
+```
+
+### options.bash
+
+Type: `Boolean`
+
+Default: `false`
+
+Enables complete support for the Bash specification. The downside is a 20-25% speed decrease.
+
+**Example**
+
+Using the default setting (`{bash: false}`):
+
+```js
+braces('a{b}c');
+//=> ['abc']
+```
+
+In bash (and minimatch), braces with one item are not expanded. To get the same result with braces, set `{bash: true}`:
+
+```js
+braces('a{b}c', {bash: true});
+//=> ['a{b}c']
+```
+
+### options.nodupes
+
+Type: `Boolean`
+
+Deafault: `true`
+
+Duplicates are removed by default. To keep duplicates, pass `{nodupes: false}` on the options
+
+## Bash 4.3 Support
+
+> Better support for Bash 4.3 than minimatch
+
+This project has comprehensive unit tests, including tests coverted from [Bash 4.3](www.gnu.org/software/bash/). Currently only 8 of 102 unit tests fail, and
+
+## Run benchmarks
+
+Install dev dependencies:
+
+```bash
+npm i -d && npm benchmark
+```
+
+### Latest results
+
+```bash
+#1: escape.js
+  brace-expansion.js x 114,934 ops/sec ±1.24% (93 runs sampled)
+  braces.js x 342,254 ops/sec ±0.84% (90 runs sampled)
+
+#2: exponent.js
+  brace-expansion.js x 12,359 ops/sec ±0.86% (96 runs sampled)
+  braces.js x 20,389 ops/sec ±0.71% (97 runs sampled)
+
+#3: multiple.js
+  brace-expansion.js x 114,469 ops/sec ±1.44% (94 runs sampled)
+  braces.js x 401,621 ops/sec ±0.87% (91 runs sampled)
+
+#4: nested.js
+  brace-expansion.js x 102,769 ops/sec ±1.55% (92 runs sampled)
+  braces.js x 314,088 ops/sec ±0.71% (98 runs sampled)
+
+#5: normal.js
+  brace-expansion.js x 157,577 ops/sec ±1.65% (91 runs sampled)
+  braces.js x 1,115,950 ops/sec ±0.74% (94 runs sampled)
+
+#6: range.js
+  brace-expansion.js x 138,822 ops/sec ±1.71% (91 runs sampled)
+  braces.js x 1,108,353 ops/sec ±0.85% (94 runs sampled)
+```
+
+## Related projects
+
+You might also be interested in these projects:
+
+* [expand-range](https://www.npmjs.com/package/expand-range): Fast, bash-like range expansion. Expand a range of numbers or letters, uppercase or lowercase. See… [more](https://www.npmjs.com/package/expand-range) | [homepage](https://github.com/jonschlinkert/expand-range)
+* [fill-range](https://www.npmjs.com/package/fill-range): Fill in a range of numbers or letters, optionally passing an increment or multiplier to… [more](https://www.npmjs.com/package/fill-range) | [homepage](https://github.com/jonschlinkert/fill-range)
+* [micromatch](https://www.npmjs.com/package/micromatch): Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch. | [homepage](https://github.com/jonschlinkert/micromatch)
+
+## Contributing
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](https://github.com/jonschlinkert/braces/issues/new).
+
+## Building docs
+
+Generate readme and API documentation with [verb](https://github.com/verbose/verb):
+
+```sh
+$ npm install verb && npm run docs
+```
+
+Or, if [verb](https://github.com/verbose/verb) is installed globally:
+
+```sh
+$ verb
+```
+
+## Running tests
+
+Install dev dependencies:
+
+```sh
+$ npm install -d && npm test
+```
+
+## Author
+
+**Jon Schlinkert**
+
+* [github/jonschlinkert](https://github.com/jonschlinkert)
+* [twitter/jonschlinkert](http://twitter.com/jonschlinkert)
+
+## License
+
+Copyright © 2016, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT license](https://github.com/jonschlinkert/braces/blob/master/LICENSE).
+
+***
+
+_This file was generated by [verb](https://github.com/verbose/verb), v0.9.0, on May 21, 2016._
\ No newline at end of file
diff --git a/node_modules/@babel/core/node_modules/braces/index.js b/node_modules/@babel/core/node_modules/braces/index.js
new file mode 100644
index 00000000..3b4c58d7
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/braces/index.js
@@ -0,0 +1,399 @@
+/*!
+ * braces <https://github.com/jonschlinkert/braces>
+ *
+ * Copyright (c) 2014-2015, Jon Schlinkert.
+ * Licensed under the MIT license.
+ */
+
+'use strict';
+
+/**
+ * Module dependencies
+ */
+
+var expand = require('expand-range');
+var repeat = require('repeat-element');
+var tokens = require('preserve');
+
+/**
+ * Expose `braces`
+ */
+
+module.exports = function(str, options) {
+  if (typeof str !== 'string') {
+    throw new Error('braces expects a string');
+  }
+  return braces(str, options);
+};
+
+/**
+ * Expand `{foo,bar}` or `{1..5}` braces in the
+ * given `string`.
+ *
+ * @param  {String} `str`
+ * @param  {Array} `arr`
+ * @param  {Object} `options`
+ * @return {Array}
+ */
+
+function braces(str, arr, options) {
+  if (str === '') {
+    return [];
+  }
+
+  if (!Array.isArray(arr)) {
+    options = arr;
+    arr = [];
+  }
+
+  var opts = options || {};
+  arr = arr || [];
+
+  if (typeof opts.nodupes === 'undefined') {
+    opts.nodupes = true;
+  }
+
+  var fn = opts.fn;
+  var es6;
+
+  if (typeof opts === 'function') {
+    fn = opts;
+    opts = {};
+  }
+
+  if (!(patternRe instanceof RegExp)) {
+    patternRe = patternRegex();
+  }
+
+  var matches = str.match(patternRe) || [];
+  var m = matches[0];
+
+  switch(m) {
+    case '\\,':
+      return escapeCommas(str, arr, opts);
+    case '\\.':
+      return escapeDots(str, arr, opts);
+    case '\/.':
+      return escapePaths(str, arr, opts);
+    case ' ':
+      return splitWhitespace(str);
+    case '{,}':
+      return exponential(str, opts, braces);
+    case '{}':
+      return emptyBraces(str, arr, opts);
+    case '\\{':
+    case '\\}':
+      return escapeBraces(str, arr, opts);
+    case '${':
+      if (!/\{[^{]+\{/.test(str)) {
+        return arr.concat(str);
+      } else {
+        es6 = true;
+        str = tokens.before(str, es6Regex());
+      }
+  }
+
+  if (!(braceRe instanceof RegExp)) {
+    braceRe = braceRegex();
+  }
+
+  var match = braceRe.exec(str);
+  if (match == null) {
+    return [str];
+  }
+
+  var outter = match[1];
+  var inner = match[2];
+  if (inner === '') { return [str]; }
+
+  var segs, segsLength;
+
+  if (inner.indexOf('..') !== -1) {
+    segs = expand(inner, opts, fn) || inner.split(',');
+    segsLength = segs.length;
+
+  } else if (inner[0] === '"' || inner[0] === '\'') {
+    return arr.concat(str.split(/['"]/).join(''));
+
+  } else {
+    segs = inner.split(',');
+    if (opts.makeRe) {
+      return braces(str.replace(outter, wrap(segs, '|')), opts);
+    }
+
+    segsLength = segs.length;
+    if (segsLength === 1 && opts.bash) {
+      segs[0] = wrap(segs[0], '\\');
+    }
+  }
+
+  var len = segs.length;
+  var i = 0, val;
+
+  while (len--) {
+    var path = segs[i++];
+
+    if (/(\.[^.\/])/.test(path)) {
+      if (segsLength > 1) {
+        return segs;
+      } else {
+        return [str];
+      }
+    }
+
+    val = splice(str, outter, path);
+
+    if (/\{[^{}]+?\}/.test(val)) {
+      arr = braces(val, arr, opts);
+    } else if (val !== '') {
+      if (opts.nodupes && arr.indexOf(val) !== -1) { continue; }
+      arr.push(es6 ? tokens.after(val) : val);
+    }
+  }
+
+  if (opts.strict) { return filter(arr, filterEmpty); }
+  return arr;
+}
+
+/**
+ * Expand exponential ranges
+ *
+ *   `a{,}{,}` => ['a', 'a', 'a', 'a']
+ */
+
+function exponential(str, options, fn) {
+  if (typeof options === 'function') {
+    fn = options;
+    options = null;
+  }
+
+  var opts = options || {};
+  var esc = '__ESC_EXP__';
+  var exp = 0;
+  var res;
+
+  var parts = str.split('{,}');
+  if (opts.nodupes) {
+    return fn(parts.join(''), opts);
+  }
+
+  exp = parts.length - 1;
+  res = fn(parts.join(esc), opts);
+  var len = res.length;
+  var arr = [];
+  var i = 0;
+
+  while (len--) {
+    var ele = res[i++];
+    var idx = ele.indexOf(esc);
+
+    if (idx === -1) {
+      arr.push(ele);
+
+    } else {
+      ele = ele.split('__ESC_EXP__').join('');
+      if (!!ele && opts.nodupes !== false) {
+        arr.push(ele);
+
+      } else {
+        var num = Math.pow(2, exp);
+        arr.push.apply(arr, repeat(ele, num));
+      }
+    }
+  }
+  return arr;
+}
+
+/**
+ * Wrap a value with parens, brackets or braces,
+ * based on the given character/separator.
+ *
+ * @param  {String|Array} `val`
+ * @param  {String} `ch`
+ * @return {String}
+ */
+
+function wrap(val, ch) {
+  if (ch === '|') {
+    return '(' + val.join(ch) + ')';
+  }
+  if (ch === ',') {
+    return '{' + val.join(ch) + '}';
+  }
+  if (ch === '-') {
+    return '[' + val.join(ch) + ']';
+  }
+  if (ch === '\\') {
+    return '\\{' + val + '\\}';
+  }
+}
+
+/**
+ * Handle empty braces: `{}`
+ */
+
+function emptyBraces(str, arr, opts) {
+  return braces(str.split('{}').join('\\{\\}'), arr, opts);
+}
+
+/**
+ * Filter out empty-ish values
+ */
+
+function filterEmpty(ele) {
+  return !!ele && ele !== '\\';
+}
+
+/**
+ * Handle patterns with whitespace
+ */
+
+function splitWhitespace(str) {
+  var segs = str.split(' ');
+  var len = segs.length;
+  var res = [];
+  var i = 0;
+
+  while (len--) {
+    res.push.apply(res, braces(segs[i++]));
+  }
+  return res;
+}
+
+/**
+ * Handle escaped braces: `\\{foo,bar}`
+ */
+
+function escapeBraces(str, arr, opts) {
+  if (!/\{[^{]+\{/.test(str)) {
+    return arr.concat(str.split('\\').join(''));
+  } else {
+    str = str.split('\\{').join('__LT_BRACE__');
+    str = str.split('\\}').join('__RT_BRACE__');
+    return map(braces(str, arr, opts), function(ele) {
+      ele = ele.split('__LT_BRACE__').join('{');
+      return ele.split('__RT_BRACE__').join('}');
+    });
+  }
+}
+
+/**
+ * Handle escaped dots: `{1\\.2}`
+ */
+
+function escapeDots(str, arr, opts) {
+  if (!/[^\\]\..+\\\./.test(str)) {
+    return arr.concat(str.split('\\').join(''));
+  } else {
+    str = str.split('\\.').join('__ESC_DOT__');
+    return map(braces(str, arr, opts), function(ele) {
+      return ele.split('__ESC_DOT__').join('.');
+    });
+  }
+}
+
+/**
+ * Handle escaped dots: `{1\\.2}`
+ */
+
+function escapePaths(str, arr, opts) {
+  str = str.split('\/.').join('__ESC_PATH__');
+  return map(braces(str, arr, opts), function(ele) {
+    return ele.split('__ESC_PATH__').join('\/.');
+  });
+}
+
+/**
+ * Handle escaped commas: `{a\\,b}`
+ */
+
+function escapeCommas(str, arr, opts) {
+  if (!/\w,/.test(str)) {
+    return arr.concat(str.split('\\').join(''));
+  } else {
+    str = str.split('\\,').join('__ESC_COMMA__');
+    return map(braces(str, arr, opts), function(ele) {
+      return ele.split('__ESC_COMMA__').join(',');
+    });
+  }
+}
+
+/**
+ * Regex for common patterns
+ */
+
+function patternRegex() {
+  return /\${|( (?=[{,}])|(?=[{,}]) )|{}|{,}|\\,(?=.*[{}])|\/\.(?=.*[{}])|\\\.(?={)|\\{|\\}/;
+}
+
+/**
+ * Braces regex.
+ */
+
+function braceRegex() {
+  return /.*(\\?\{([^}]+)\})/;
+}
+
+/**
+ * es6 delimiter regex.
+ */
+
+function es6Regex() {
+  return /\$\{([^}]+)\}/;
+}
+
+var braceRe;
+var patternRe;
+
+/**
+ * Faster alternative to `String.replace()` when the
+ * index of the token to be replaces can't be supplied
+ */
+
+function splice(str, token, replacement) {
+  var i = str.indexOf(token);
+  return str.substr(0, i) + replacement
+    + str.substr(i + token.length);
+}
+
+/**
+ * Fast array map
+ */
+
+function map(arr, fn) {
+  if (arr == null) {
+    return [];
+  }
+
+  var len = arr.length;
+  var res = new Array(len);
+  var i = -1;
+
+  while (++i < len) {
+    res[i] = fn(arr[i], i, arr);
+  }
+
+  return res;
+}
+
+/**
+ * Fast array filter
+ */
+
+function filter(arr, cb) {
+  if (arr == null) return [];
+  if (typeof cb !== 'function') {
+    throw new TypeError('braces: filter expects a callback function.');
+  }
+
+  var len = arr.length;
+  var res = arr.slice();
+  var i = 0;
+
+  while (len--) {
+    if (!cb(arr[len], i++)) {
+      res.splice(len, 1);
+    }
+  }
+  return res;
+}
diff --git a/node_modules/@babel/core/node_modules/braces/package.json b/node_modules/@babel/core/node_modules/braces/package.json
new file mode 100644
index 00000000..ab6bcdc3
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/braces/package.json
@@ -0,0 +1,83 @@
+{
+  "name": "braces",
+  "description": "Fastest brace expansion for node.js, with the most complete support for the Bash 4.3 braces specification.",
+  "version": "1.8.5",
+  "homepage": "https://github.com/jonschlinkert/braces",
+  "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
+  "repository": "jonschlinkert/braces",
+  "bugs": {
+    "url": "https://github.com/jonschlinkert/braces/issues"
+  },
+  "license": "MIT",
+  "files": [
+    "index.js"
+  ],
+  "main": "index.js",
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "dependencies": {
+    "expand-range": "^1.8.1",
+    "preserve": "^0.2.0",
+    "repeat-element": "^1.1.2"
+  },
+  "devDependencies": {
+    "benchmarked": "^0.1.5",
+    "brace-expansion": "^1.1.3",
+    "chalk": "^1.1.3",
+    "gulp-format-md": "^0.1.8",
+    "minimatch": "^3.0.0",
+    "minimist": "^1.2.0",
+    "mocha": "^2.4.5",
+    "should": "^8.3.1"
+  },
+  "keywords": [
+    "alpha",
+    "alphabetical",
+    "bash",
+    "brace",
+    "expand",
+    "expansion",
+    "filepath",
+    "fill",
+    "fs",
+    "glob",
+    "globbing",
+    "letter",
+    "match",
+    "matches",
+    "matching",
+    "number",
+    "numerical",
+    "path",
+    "range",
+    "ranges",
+    "sh"
+  ],
+  "verb": {
+    "plugins": [
+      "gulp-format-md"
+    ],
+    "reflinks": [
+      "verb"
+    ],
+    "toc": false,
+    "layout": "default",
+    "lint": {
+      "reflinks": true
+    },
+    "tasks": [
+      "readme"
+    ],
+    "related": {
+      "list": [
+        "micromatch",
+        "expand-range",
+        "fill-range"
+      ]
+    }
+  }
+}
diff --git a/node_modules/@babel/core/node_modules/debug/CHANGELOG.md b/node_modules/@babel/core/node_modules/debug/CHANGELOG.md
new file mode 100644
index 00000000..820d21e3
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/debug/CHANGELOG.md
@@ -0,0 +1,395 @@
+
+3.1.0 / 2017-09-26
+==================
+
+  * Add `DEBUG_HIDE_DATE` env var (#486)
+  * Remove ReDoS regexp in %o formatter (#504)
+  * Remove "component" from package.json
+  * Remove `component.json`
+  * Ignore package-lock.json
+  * Examples: fix colors printout
+  * Fix: browser detection
+  * Fix: spelling mistake (#496, @EdwardBetts)
+
+3.0.1 / 2017-08-24
+==================
+
+  * Fix: Disable colors in Edge and Internet Explorer (#489)
+
+3.0.0 / 2017-08-08
+==================
+
+  * Breaking: Remove DEBUG_FD (#406)
+  * Breaking: Use `Date#toISOString()` instead to `Date#toUTCString()` when output is not a TTY (#418)
+  * Breaking: Make millisecond timer namespace specific and allow 'always enabled' output (#408)
+  * Addition: document `enabled` flag (#465)
+  * Addition: add 256 colors mode (#481)
+  * Addition: `enabled()` updates existing debug instances, add `destroy()` function (#440)
+  * Update: component: update "ms" to v2.0.0
+  * Update: separate the Node and Browser tests in Travis-CI
+  * Update: refactor Readme, fixed documentation, added "Namespace Colors" section, redid screenshots
+  * Update: separate Node.js and web browser examples for organization
+  * Update: update "browserify" to v14.4.0
+  * Fix: fix Readme typo (#473)
+
+2.6.9 / 2017-09-22
+==================
+
+  * remove ReDoS regexp in %o formatter (#504)
+
+2.6.8 / 2017-05-18
+==================
+
+  * Fix: Check for undefined on browser globals (#462, @marbemac)
+
+2.6.7 / 2017-05-16
+==================
+
+  * Fix: Update ms to 2.0.0 to fix regular expression denial of service vulnerability (#458, @hubdotcom)
+  * Fix: Inline extend function in node implementation (#452, @dougwilson)
+  * Docs: Fix typo (#455, @msasad)
+
+2.6.5 / 2017-04-27
+==================
+  
+  * Fix: null reference check on window.documentElement.style.WebkitAppearance (#447, @thebigredgeek)
+  * Misc: clean up browser reference checks (#447, @thebigredgeek)
+  * Misc: add npm-debug.log to .gitignore (@thebigredgeek)
+
+
+2.6.4 / 2017-04-20
+==================
+
+  * Fix: bug that would occur if process.env.DEBUG is a non-string value. (#444, @LucianBuzzo)
+  * Chore: ignore bower.json in npm installations. (#437, @joaovieira)
+  * Misc: update "ms" to v0.7.3 (@tootallnate)
+
+2.6.3 / 2017-03-13
+==================
+
+  * Fix: Electron reference to `process.env.DEBUG` (#431, @paulcbetts)
+  * Docs: Changelog fix (@thebigredgeek)
+
+2.6.2 / 2017-03-10
+==================
+
+  * Fix: DEBUG_MAX_ARRAY_LENGTH (#420, @slavaGanzin)
+  * Docs: Add backers and sponsors from Open Collective (#422, @piamancini)
+  * Docs: Add Slackin invite badge (@tootallnate)
+
+2.6.1 / 2017-02-10
+==================
+
+  * Fix: Module's `export default` syntax fix for IE8 `Expected identifier` error
+  * Fix: Whitelist DEBUG_FD for values 1 and 2 only (#415, @pi0)
+  * Fix: IE8 "Expected identifier" error (#414, @vgoma)
+  * Fix: Namespaces would not disable once enabled (#409, @musikov)
+
+2.6.0 / 2016-12-28
+==================
+
+  * Fix: added better null pointer checks for browser useColors (@thebigredgeek)
+  * Improvement: removed explicit `window.debug` export (#404, @tootallnate)
+  * Improvement: deprecated `DEBUG_FD` environment variable (#405, @tootallnate)
+
+2.5.2 / 2016-12-25
+==================
+
+  * Fix: reference error on window within webworkers (#393, @KlausTrainer)
+  * Docs: fixed README typo (#391, @lurch)
+  * Docs: added notice about v3 api discussion (@thebigredgeek)
+
+2.5.1 / 2016-12-20
+==================
+
+  * Fix: babel-core compatibility
+
+2.5.0 / 2016-12-20
+==================
+
+  * Fix: wrong reference in bower file (@thebigredgeek)
+  * Fix: webworker compatibility (@thebigredgeek)
+  * Fix: output formatting issue (#388, @kribblo)
+  * Fix: babel-loader compatibility (#383, @escwald)
+  * Misc: removed built asset from repo and publications (@thebigredgeek)
+  * Misc: moved source files to /src (#378, @yamikuronue)
+  * Test: added karma integration and replaced babel with browserify for browser tests (#378, @yamikuronue)
+  * Test: coveralls integration (#378, @yamikuronue)
+  * Docs: simplified language in the opening paragraph (#373, @yamikuronue)
+
+2.4.5 / 2016-12-17
+==================
+
+  * Fix: `navigator` undefined in Rhino (#376, @jochenberger)
+  * Fix: custom log function (#379, @hsiliev)
+  * Improvement: bit of cleanup + linting fixes (@thebigredgeek)
+  * Improvement: rm non-maintainted `dist/` dir (#375, @freewil)
+  * Docs: simplified language in the opening paragraph. (#373, @yamikuronue)
+
+2.4.4 / 2016-12-14
+==================
+
+  * Fix: work around debug being loaded in preload scripts for electron (#368, @paulcbetts)
+
+2.4.3 / 2016-12-14
+==================
+
+  * Fix: navigation.userAgent error for react native (#364, @escwald)
+
+2.4.2 / 2016-12-14
+==================
+
+  * Fix: browser colors (#367, @tootallnate)
+  * Misc: travis ci integration (@thebigredgeek)
+  * Misc: added linting and testing boilerplate with sanity check (@thebigredgeek)
+
+2.4.1 / 2016-12-13
+==================
+
+  * Fix: typo that broke the package (#356)
+
+2.4.0 / 2016-12-13
+==================
+
+  * Fix: bower.json references unbuilt src entry point (#342, @justmatt)
+  * Fix: revert "handle regex special characters" (@tootallnate)
+  * Feature: configurable util.inspect()`options for NodeJS (#327, @tootallnate)
+  * Feature: %O`(big O) pretty-prints objects (#322, @tootallnate)
+  * Improvement: allow colors in workers (#335, @botverse)
+  * Improvement: use same color for same namespace. (#338, @lchenay)
+
+2.3.3 / 2016-11-09
+==================
+
+  * Fix: Catch `JSON.stringify()` errors (#195, Jovan Alleyne)
+  * Fix: Returning `localStorage` saved values (#331, Levi Thomason)
+  * Improvement: Don't create an empty object when no `process` (Nathan Rajlich)
+
+2.3.2 / 2016-11-09
+==================
+
+  * Fix: be super-safe in index.js as well (@TooTallNate)
+  * Fix: should check whether process exists (Tom Newby)
+
+2.3.1 / 2016-11-09
+==================
+
+  * Fix: Added electron compatibility (#324, @paulcbetts)
+  * Improvement: Added performance optimizations (@tootallnate)
+  * Readme: Corrected PowerShell environment variable example (#252, @gimre)
+  * Misc: Removed yarn lock file from source control (#321, @fengmk2)
+
+2.3.0 / 2016-11-07
+==================
+
+  * Fix: Consistent placement of ms diff at end of output (#215, @gorangajic)
+  * Fix: Escaping of regex special characters in namespace strings (#250, @zacronos)
+  * Fix: Fixed bug causing crash on react-native (#282, @vkarpov15)
+  * Feature: Enabled ES6+ compatible import via default export (#212 @bucaran)
+  * Feature: Added %O formatter to reflect Chrome's console.log capability (#279, @oncletom)
+  * Package: Update "ms" to 0.7.2 (#315, @DevSide)
+  * Package: removed superfluous version property from bower.json (#207 @kkirsche)
+  * Readme: fix USE_COLORS to DEBUG_COLORS
+  * Readme: Doc fixes for format string sugar (#269, @mlucool)
+  * Readme: Updated docs for DEBUG_FD and DEBUG_COLORS environment variables (#232, @mattlyons0)
+  * Readme: doc fixes for PowerShell (#271 #243, @exoticknight @unreadable)
+  * Readme: better docs for browser support (#224, @matthewmueller)
+  * Tooling: Added yarn integration for development (#317, @thebigredgeek)
+  * Misc: Renamed History.md to CHANGELOG.md (@thebigredgeek)
+  * Misc: Added license file (#226 #274, @CantemoInternal @sdaitzman)
+  * Misc: Updated contributors (@thebigredgeek)
+
+2.2.0 / 2015-05-09
+==================
+
+  * package: update "ms" to v0.7.1 (#202, @dougwilson)
+  * README: add logging to file example (#193, @DanielOchoa)
+  * README: fixed a typo (#191, @amir-s)
+  * browser: expose `storage` (#190, @stephenmathieson)
+  * Makefile: add a `distclean` target (#189, @stephenmathieson)
+
+2.1.3 / 2015-03-13
+==================
+
+  * Updated stdout/stderr example (#186)
+  * Updated example/stdout.js to match debug current behaviour
+  * Renamed example/stderr.js to stdout.js
+  * Update Readme.md (#184)
+  * replace high intensity foreground color for bold (#182, #183)
+
+2.1.2 / 2015-03-01
+==================
+
+  * dist: recompile
+  * update "ms" to v0.7.0
+  * package: update "browserify" to v9.0.3
+  * component: fix "ms.js" repo location
+  * changed bower package name
+  * updated documentation about using debug in a browser
+  * fix: security error on safari (#167, #168, @yields)
+
+2.1.1 / 2014-12-29
+==================
+
+  * browser: use `typeof` to check for `console` existence
+  * browser: check for `console.log` truthiness (fix IE 8/9)
+  * browser: add support for Chrome apps
+  * Readme: added Windows usage remarks
+  * Add `bower.json` to properly support bower install
+
+2.1.0 / 2014-10-15
+==================
+
+  * node: implement `DEBUG_FD` env variable support
+  * package: update "browserify" to v6.1.0
+  * package: add "license" field to package.json (#135, @panuhorsmalahti)
+
+2.0.0 / 2014-09-01
+==================
+
+  * package: update "browserify" to v5.11.0
+  * node: use stderr rather than stdout for logging (#29, @stephenmathieson)
+
+1.0.4 / 2014-07-15
+==================
+
+  * dist: recompile
+  * example: remove `console.info()` log usage
+  * example: add "Content-Type" UTF-8 header to browser example
+  * browser: place %c marker after the space character
+  * browser: reset the "content" color via `color: inherit`
+  * browser: add colors support for Firefox >= v31
+  * debug: prefer an instance `log()` function over the global one (#119)
+  * Readme: update documentation about styled console logs for FF v31 (#116, @wryk)
+
+1.0.3 / 2014-07-09
+==================
+
+  * Add support for multiple wildcards in namespaces (#122, @seegno)
+  * browser: fix lint
+
+1.0.2 / 2014-06-10
+==================
+
+  * browser: update color palette (#113, @gscottolson)
+  * common: make console logging function configurable (#108, @timoxley)
+  * node: fix %o colors on old node <= 0.8.x
+  * Makefile: find node path using shell/which (#109, @timoxley)
+
+1.0.1 / 2014-06-06
+==================
+
+  * browser: use `removeItem()` to clear localStorage
+  * browser, node: don't set DEBUG if namespaces is undefined (#107, @leedm777)
+  * package: add "contributors" section
+  * node: fix comment typo
+  * README: list authors
+
+1.0.0 / 2014-06-04
+==================
+
+  * make ms diff be global, not be scope
+  * debug: ignore empty strings in enable()
+  * node: make DEBUG_COLORS able to disable coloring
+  * *: export the `colors` array
+  * npmignore: don't publish the `dist` dir
+  * Makefile: refactor to use browserify
+  * package: add "browserify" as a dev dependency
+  * Readme: add Web Inspector Colors section
+  * node: reset terminal color for the debug content
+  * node: map "%o" to `util.inspect()`
+  * browser: map "%j" to `JSON.stringify()`
+  * debug: add custom "formatters"
+  * debug: use "ms" module for humanizing the diff
+  * Readme: add "bash" syntax highlighting
+  * browser: add Firebug color support
+  * browser: add colors for WebKit browsers
+  * node: apply log to `console`
+  * rewrite: abstract common logic for Node & browsers
+  * add .jshintrc file
+
+0.8.1 / 2014-04-14
+==================
+
+  * package: re-add the "component" section
+
+0.8.0 / 2014-03-30
+==================
+
+  * add `enable()` method for nodejs. Closes #27
+  * change from stderr to stdout
+  * remove unnecessary index.js file
+
+0.7.4 / 2013-11-13
+==================
+
+  * remove "browserify" key from package.json (fixes something in browserify)
+
+0.7.3 / 2013-10-30
+==================
+
+  * fix: catch localStorage security error when cookies are blocked (Chrome)
+  * add debug(err) support. Closes #46
+  * add .browser prop to package.json. Closes #42
+
+0.7.2 / 2013-02-06
+==================
+
+  * fix package.json
+  * fix: Mobile Safari (private mode) is broken with debug
+  * fix: Use unicode to send escape character to shell instead of octal to work with strict mode javascript
+
+0.7.1 / 2013-02-05
+==================
+
+  * add repository URL to package.json
+  * add DEBUG_COLORED to force colored output
+  * add browserify support
+  * fix component. Closes #24
+
+0.7.0 / 2012-05-04
+==================
+
+  * Added .component to package.json
+  * Added debug.component.js build
+
+0.6.0 / 2012-03-16
+==================
+
+  * Added support for "-" prefix in DEBUG [Vinay Pulim]
+  * Added `.enabled` flag to the node version [TooTallNate]
+
+0.5.0 / 2012-02-02
+==================
+
+  * Added: humanize diffs. Closes #8
+  * Added `debug.disable()` to the CS variant
+  * Removed padding. Closes #10
+  * Fixed: persist client-side variant again. Closes #9
+
+0.4.0 / 2012-02-01
+==================
+
+  * Added browser variant support for older browsers [TooTallNate]
+  * Added `debug.enable('project:*')` to browser variant [TooTallNate]
+  * Added padding to diff (moved it to the right)
+
+0.3.0 / 2012-01-26
+==================
+
+  * Added millisecond diff when isatty, otherwise UTC string
+
+0.2.0 / 2012-01-22
+==================
+
+  * Added wildcard support
+
+0.1.0 / 2011-12-02
+==================
+
+  * Added: remove colors unless stderr isatty [TooTallNate]
+
+0.0.1 / 2010-01-03
+==================
+
+  * Initial release
diff --git a/node_modules/@babel/core/node_modules/debug/LICENSE b/node_modules/@babel/core/node_modules/debug/LICENSE
new file mode 100644
index 00000000..658c933d
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/debug/LICENSE
@@ -0,0 +1,19 @@
+(The MIT License)
+
+Copyright (c) 2014 TJ Holowaychuk <tj@vision-media.ca>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software 
+and associated documentation files (the 'Software'), to deal in the Software without restriction, 
+including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial 
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT 
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
diff --git a/node_modules/@babel/core/node_modules/debug/README.md b/node_modules/@babel/core/node_modules/debug/README.md
new file mode 100644
index 00000000..0ee7634d
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/debug/README.md
@@ -0,0 +1,437 @@
+# debug
+[![Build Status](https://travis-ci.org/visionmedia/debug.svg?branch=master)](https://travis-ci.org/visionmedia/debug)  [![Coverage Status](https://coveralls.io/repos/github/visionmedia/debug/badge.svg?branch=master)](https://coveralls.io/github/visionmedia/debug?branch=master)  [![Slack](https://visionmedia-community-slackin.now.sh/badge.svg)](https://visionmedia-community-slackin.now.sh/) [![OpenCollective](https://opencollective.com/debug/backers/badge.svg)](#backers)
+[![OpenCollective](https://opencollective.com/debug/sponsors/badge.svg)](#sponsors)
+
+<img width="647" src="https://user-images.githubusercontent.com/71256/29091486-fa38524c-7c37-11e7-895f-e7ec8e1039b6.png">
+
+A tiny JavaScript debugging utility modelled after Node.js core's debugging
+technique. Works in Node.js and web browsers.
+
+## Installation
+
+```bash
+$ npm install debug
+```
+
+## Usage
+
+`debug` exposes a function; simply pass this function the name of your module, and it will return a decorated version of `console.error` for you to pass debug statements to. This will allow you to toggle the debug output for different parts of your module as well as the module as a whole.
+
+Example [_app.js_](./examples/node/app.js):
+
+```js
+var debug = require('debug')('http')
+  , http = require('http')
+  , name = 'My App';
+
+// fake app
+
+debug('booting %o', name);
+
+http.createServer(function(req, res){
+  debug(req.method + ' ' + req.url);
+  res.end('hello\n');
+}).listen(3000, function(){
+  debug('listening');
+});
+
+// fake worker of some kind
+
+require('./worker');
+```
+
+Example [_worker.js_](./examples/node/worker.js):
+
+```js
+var a = require('debug')('worker:a')
+  , b = require('debug')('worker:b');
+
+function work() {
+  a('doing lots of uninteresting work');
+  setTimeout(work, Math.random() * 1000);
+}
+
+work();
+
+function workb() {
+  b('doing some work');
+  setTimeout(workb, Math.random() * 2000);
+}
+
+workb();
+```
+
+The `DEBUG` environment variable is then used to enable these based on space or
+comma-delimited names.
+
+Here are some examples:
+
+<img width="647" alt="screen shot 2017-08-08 at 12 53 04 pm" src="https://user-images.githubusercontent.com/71256/29091703-a6302cdc-7c38-11e7-8304-7c0b3bc600cd.png">
+<img width="647" alt="screen shot 2017-08-08 at 12 53 38 pm" src="https://user-images.githubusercontent.com/71256/29091700-a62a6888-7c38-11e7-800b-db911291ca2b.png">
+<img width="647" alt="screen shot 2017-08-08 at 12 53 25 pm" src="https://user-images.githubusercontent.com/71256/29091701-a62ea114-7c38-11e7-826a-2692bedca740.png">
+
+#### Windows command prompt notes
+
+##### CMD
+
+On Windows the environment variable is set using the `set` command.
+
+```cmd
+set DEBUG=*,-not_this
+```
+
+Example:
+
+```cmd
+set DEBUG=* & node app.js
+```
+
+##### PowerShell (VS Code default)
+
+PowerShell uses different syntax to set environment variables.
+
+```cmd
+$env:DEBUG = "*,-not_this"
+```
+
+Example:
+
+```cmd
+$env:DEBUG='app';node app.js
+```
+
+Then, run the program to be debugged as usual.
+
+npm script example:
+```js
+  "windowsDebug": "@powershell -Command $env:DEBUG='*';node app.js",
+```
+
+## Namespace Colors
+
+Every debug instance has a color generated for it based on its namespace name.
+This helps when visually parsing the debug output to identify which debug instance
+a debug line belongs to.
+
+#### Node.js
+
+In Node.js, colors are enabled when stderr is a TTY. You also _should_ install
+the [`supports-color`](https://npmjs.org/supports-color) module alongside debug,
+otherwise debug will only use a small handful of basic colors.
+
+<img width="521" src="https://user-images.githubusercontent.com/71256/29092181-47f6a9e6-7c3a-11e7-9a14-1928d8a711cd.png">
+
+#### Web Browser
+
+Colors are also enabled on "Web Inspectors" that understand the `%c` formatting
+option. These are WebKit web inspectors, Firefox ([since version
+31](https://hacks.mozilla.org/2014/05/editable-box-model-multiple-selection-sublime-text-keys-much-more-firefox-developer-tools-episode-31/))
+and the Firebug plugin for Firefox (any version).
+
+<img width="524" src="https://user-images.githubusercontent.com/71256/29092033-b65f9f2e-7c39-11e7-8e32-f6f0d8e865c1.png">
+
+
+## Millisecond diff
+
+When actively developing an application it can be useful to see when the time spent between one `debug()` call and the next. Suppose for example you invoke `debug()` before requesting a resource, and after as well, the "+NNNms" will show you how much time was spent between calls.
+
+<img width="647" src="https://user-images.githubusercontent.com/71256/29091486-fa38524c-7c37-11e7-895f-e7ec8e1039b6.png">
+
+When stdout is not a TTY, `Date#toISOString()` is used, making it more useful for logging the debug information as shown below:
+
+<img width="647" src="https://user-images.githubusercontent.com/71256/29091956-6bd78372-7c39-11e7-8c55-c948396d6edd.png">
+
+
+## Conventions
+
+If you're using this in one or more of your libraries, you _should_ use the name of your library so that developers may toggle debugging as desired without guessing names. If you have more than one debuggers you _should_ prefix them with your library name and use ":" to separate features. For example "bodyParser" from Connect would then be "connect:bodyParser".  If you append a "*" to the end of your name, it will always be enabled regardless of the setting of the DEBUG environment variable.  You can then use it for normal output as well as debug output.
+
+## Wildcards
+
+The `*` character may be used as a wildcard. Suppose for example your library has
+debuggers named "connect:bodyParser", "connect:compress", "connect:session",
+instead of listing all three with
+`DEBUG=connect:bodyParser,connect:compress,connect:session`, you may simply do
+`DEBUG=connect:*`, or to run everything using this module simply use `DEBUG=*`.
+
+You can also exclude specific debuggers by prefixing them with a "-" character.
+For example, `DEBUG=*,-connect:*` would include all debuggers except those
+starting with "connect:".
+
+## Environment Variables
+
+When running through Node.js, you can set a few environment variables that will
+change the behavior of the debug logging:
+
+| Name      | Purpose                                         |
+|-----------|-------------------------------------------------|
+| `DEBUG`   | Enables/disables specific debugging namespaces. |
+| `DEBUG_HIDE_DATE` | Hide date from debug output (non-TTY).  |
+| `DEBUG_COLORS`| Whether or not to use colors in the debug output. |
+| `DEBUG_DEPTH` | Object inspection depth.                    |
+| `DEBUG_SHOW_HIDDEN` | Shows hidden properties on inspected objects. |
+
+
+__Note:__ The environment variables beginning with `DEBUG_` end up being
+converted into an Options object that gets used with `%o`/`%O` formatters.
+See the Node.js documentation for
+[`util.inspect()`](https://nodejs.org/api/util.html#util_util_inspect_object_options)
+for the complete list.
+
+## Formatters
+
+Debug uses [printf-style](https://wikipedia.org/wiki/Printf_format_string) formatting.
+Below are the officially supported formatters:
+
+| Formatter | Representation |
+|-----------|----------------|
+| `%O`      | Pretty-print an Object on multiple lines. |
+| `%o`      | Pretty-print an Object all on a single line. |
+| `%s`      | String. |
+| `%d`      | Number (both integer and float). |
+| `%j`      | JSON. Replaced with the string '[Circular]' if the argument contains circular references. |
+| `%%`      | Single percent sign ('%'). This does not consume an argument. |
+
+
+### Custom formatters
+
+You can add custom formatters by extending the `debug.formatters` object.
+For example, if you wanted to add support for rendering a Buffer as hex with
+`%h`, you could do something like:
+
+```js
+const createDebug = require('debug')
+createDebug.formatters.h = (v) => {
+  return v.toString('hex')
+}
+
+// …elsewhere
+const debug = createDebug('foo')
+debug('this is hex: %h', new Buffer('hello world'))
+//   foo this is hex: 68656c6c6f20776f726c6421 +0ms
+```
+
+
+## Browser Support
+
+You can build a browser-ready script using [browserify](https://github.com/substack/node-browserify),
+or just use the [browserify-as-a-service](https://wzrd.in/) [build](https://wzrd.in/standalone/debug@latest),
+if you don't want to build it yourself.
+
+Debug's enable state is currently persisted by `localStorage`.
+Consider the situation shown below where you have `worker:a` and `worker:b`,
+and wish to debug both. You can enable this using `localStorage.debug`:
+
+```js
+localStorage.debug = 'worker:*'
+```
+
+And then refresh the page.
+
+```js
+a = debug('worker:a');
+b = debug('worker:b');
+
+setInterval(function(){
+  a('doing some work');
+}, 1000);
+
+setInterval(function(){
+  b('doing some work');
+}, 1200);
+```
+
+
+## Output streams
+
+  By default `debug` will log to stderr, however this can be configured per-namespace by overriding the `log` method:
+
+Example [_stdout.js_](./examples/node/stdout.js):
+
+```js
+var debug = require('debug');
+var error = debug('app:error');
+
+// by default stderr is used
+error('goes to stderr!');
+
+var log = debug('app:log');
+// set this namespace to log via console.log
+log.log = console.log.bind(console); // don't forget to bind to console!
+log('goes to stdout');
+error('still goes to stderr!');
+
+// set all output to go via console.info
+// overrides all per-namespace log settings
+debug.log = console.info.bind(console);
+error('now goes to stdout via console.info');
+log('still goes to stdout, but via console.info now');
+```
+
+## Extend
+You can simply extend debugger 
+```js
+const log = require('debug')('auth');
+
+//creates new debug instance with extended namespace
+const logSign = log.extend('sign');
+const logLogin = log.extend('login');
+
+log('hello'); // auth hello
+logSign('hello'); //auth:sign hello
+logLogin('hello'); //auth:login hello
+```
+
+## Set dynamically
+
+You can also enable debug dynamically by calling the `enable()` method :
+
+```js
+let debug = require('debug');
+
+console.log(1, debug.enabled('test'));
+
+debug.enable('test');
+console.log(2, debug.enabled('test'));
+
+debug.disable();
+console.log(3, debug.enabled('test'));
+
+```
+
+print :   
+```
+1 false
+2 true
+3 false
+```
+
+Usage :  
+`enable(namespaces)`  
+`namespaces` can include modes separated by a colon and wildcards.
+   
+Note that calling `enable()` completely overrides previously set DEBUG variable : 
+
+```
+$ DEBUG=foo node -e 'var dbg = require("debug"); dbg.enable("bar"); console.log(dbg.enabled("foo"))'
+=> false
+```
+
+## Checking whether a debug target is enabled
+
+After you've created a debug instance, you can determine whether or not it is
+enabled by checking the `enabled` property:
+
+```javascript
+const debug = require('debug')('http');
+
+if (debug.enabled) {
+  // do stuff...
+}
+```
+
+You can also manually toggle this property to force the debug instance to be
+enabled or disabled.
+
+
+## Authors
+
+ - TJ Holowaychuk
+ - Nathan Rajlich
+ - Andrew Rhyne
+
+## Backers
+
+Support us with a monthly donation and help us continue our activities. [[Become a backer](https://opencollective.com/debug#backer)]
+
+<a href="https://opencollective.com/debug/backer/0/website" target="_blank"><img src="https://opencollective.com/debug/backer/0/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/1/website" target="_blank"><img src="https://opencollective.com/debug/backer/1/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/2/website" target="_blank"><img src="https://opencollective.com/debug/backer/2/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/3/website" target="_blank"><img src="https://opencollective.com/debug/backer/3/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/4/website" target="_blank"><img src="https://opencollective.com/debug/backer/4/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/5/website" target="_blank"><img src="https://opencollective.com/debug/backer/5/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/6/website" target="_blank"><img src="https://opencollective.com/debug/backer/6/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/7/website" target="_blank"><img src="https://opencollective.com/debug/backer/7/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/8/website" target="_blank"><img src="https://opencollective.com/debug/backer/8/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/9/website" target="_blank"><img src="https://opencollective.com/debug/backer/9/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/10/website" target="_blank"><img src="https://opencollective.com/debug/backer/10/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/11/website" target="_blank"><img src="https://opencollective.com/debug/backer/11/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/12/website" target="_blank"><img src="https://opencollective.com/debug/backer/12/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/13/website" target="_blank"><img src="https://opencollective.com/debug/backer/13/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/14/website" target="_blank"><img src="https://opencollective.com/debug/backer/14/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/15/website" target="_blank"><img src="https://opencollective.com/debug/backer/15/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/16/website" target="_blank"><img src="https://opencollective.com/debug/backer/16/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/17/website" target="_blank"><img src="https://opencollective.com/debug/backer/17/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/18/website" target="_blank"><img src="https://opencollective.com/debug/backer/18/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/19/website" target="_blank"><img src="https://opencollective.com/debug/backer/19/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/20/website" target="_blank"><img src="https://opencollective.com/debug/backer/20/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/21/website" target="_blank"><img src="https://opencollective.com/debug/backer/21/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/22/website" target="_blank"><img src="https://opencollective.com/debug/backer/22/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/23/website" target="_blank"><img src="https://opencollective.com/debug/backer/23/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/24/website" target="_blank"><img src="https://opencollective.com/debug/backer/24/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/25/website" target="_blank"><img src="https://opencollective.com/debug/backer/25/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/26/website" target="_blank"><img src="https://opencollective.com/debug/backer/26/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/27/website" target="_blank"><img src="https://opencollective.com/debug/backer/27/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/28/website" target="_blank"><img src="https://opencollective.com/debug/backer/28/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/29/website" target="_blank"><img src="https://opencollective.com/debug/backer/29/avatar.svg"></a>
+
+
+## Sponsors
+
+Become a sponsor and get your logo on our README on Github with a link to your site. [[Become a sponsor](https://opencollective.com/debug#sponsor)]
+
+<a href="https://opencollective.com/debug/sponsor/0/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/0/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/1/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/1/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/2/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/2/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/3/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/3/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/4/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/4/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/5/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/5/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/6/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/6/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/7/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/7/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/8/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/8/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/9/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/9/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/10/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/10/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/11/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/11/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/12/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/12/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/13/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/13/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/14/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/14/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/15/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/15/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/16/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/16/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/17/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/17/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/18/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/18/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/19/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/19/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/20/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/20/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/21/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/21/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/22/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/22/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/23/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/23/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/24/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/24/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/25/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/25/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/26/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/26/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/27/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/27/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/28/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/28/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/29/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/29/avatar.svg"></a>
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2014-2017 TJ Holowaychuk &lt;tj@vision-media.ca&gt;
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/@babel/core/node_modules/debug/dist/debug.js b/node_modules/@babel/core/node_modules/debug/dist/debug.js
new file mode 100644
index 00000000..f271e01c
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/debug/dist/debug.js
@@ -0,0 +1,886 @@
+"use strict";
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+(function (f) {
+  if ((typeof exports === "undefined" ? "undefined" : _typeof(exports)) === "object" && typeof module !== "undefined") {
+    module.exports = f();
+  } else if (typeof define === "function" && define.amd) {
+    define([], f);
+  } else {
+    var g;
+
+    if (typeof window !== "undefined") {
+      g = window;
+    } else if (typeof global !== "undefined") {
+      g = global;
+    } else if (typeof self !== "undefined") {
+      g = self;
+    } else {
+      g = this;
+    }
+
+    g.debug = f();
+  }
+})(function () {
+  var define, module, exports;
+  return function () {
+    function r(e, n, t) {
+      function o(i, f) {
+        if (!n[i]) {
+          if (!e[i]) {
+            var c = "function" == typeof require && require;
+            if (!f && c) return c(i, !0);
+            if (u) return u(i, !0);
+            var a = new Error("Cannot find module '" + i + "'");
+            throw a.code = "MODULE_NOT_FOUND", a;
+          }
+
+          var p = n[i] = {
+            exports: {}
+          };
+          e[i][0].call(p.exports, function (r) {
+            var n = e[i][1][r];
+            return o(n || r);
+          }, p, p.exports, r, e, n, t);
+        }
+
+        return n[i].exports;
+      }
+
+      for (var u = "function" == typeof require && require, i = 0; i < t.length; i++) {
+        o(t[i]);
+      }
+
+      return o;
+    }
+
+    return r;
+  }()({
+    1: [function (require, module, exports) {
+      /**
+       * Helpers.
+       */
+      var s = 1000;
+      var m = s * 60;
+      var h = m * 60;
+      var d = h * 24;
+      var w = d * 7;
+      var y = d * 365.25;
+      /**
+       * Parse or format the given `val`.
+       *
+       * Options:
+       *
+       *  - `long` verbose formatting [false]
+       *
+       * @param {String|Number} val
+       * @param {Object} [options]
+       * @throws {Error} throw an error if val is not a non-empty string or a number
+       * @return {String|Number}
+       * @api public
+       */
+
+      module.exports = function (val, options) {
+        options = options || {};
+
+        var type = _typeof(val);
+
+        if (type === 'string' && val.length > 0) {
+          return parse(val);
+        } else if (type === 'number' && isNaN(val) === false) {
+          return options.long ? fmtLong(val) : fmtShort(val);
+        }
+
+        throw new Error('val is not a non-empty string or a valid number. val=' + JSON.stringify(val));
+      };
+      /**
+       * Parse the given `str` and return milliseconds.
+       *
+       * @param {String} str
+       * @return {Number}
+       * @api private
+       */
+
+
+      function parse(str) {
+        str = String(str);
+
+        if (str.length > 100) {
+          return;
+        }
+
+        var match = /^((?:\d+)?\-?\d?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str);
+
+        if (!match) {
+          return;
+        }
+
+        var n = parseFloat(match[1]);
+        var type = (match[2] || 'ms').toLowerCase();
+
+        switch (type) {
+          case 'years':
+          case 'year':
+          case 'yrs':
+          case 'yr':
+          case 'y':
+            return n * y;
+
+          case 'weeks':
+          case 'week':
+          case 'w':
+            return n * w;
+
+          case 'days':
+          case 'day':
+          case 'd':
+            return n * d;
+
+          case 'hours':
+          case 'hour':
+          case 'hrs':
+          case 'hr':
+          case 'h':
+            return n * h;
+
+          case 'minutes':
+          case 'minute':
+          case 'mins':
+          case 'min':
+          case 'm':
+            return n * m;
+
+          case 'seconds':
+          case 'second':
+          case 'secs':
+          case 'sec':
+          case 's':
+            return n * s;
+
+          case 'milliseconds':
+          case 'millisecond':
+          case 'msecs':
+          case 'msec':
+          case 'ms':
+            return n;
+
+          default:
+            return undefined;
+        }
+      }
+      /**
+       * Short format for `ms`.
+       *
+       * @param {Number} ms
+       * @return {String}
+       * @api private
+       */
+
+
+      function fmtShort(ms) {
+        var msAbs = Math.abs(ms);
+
+        if (msAbs >= d) {
+          return Math.round(ms / d) + 'd';
+        }
+
+        if (msAbs >= h) {
+          return Math.round(ms / h) + 'h';
+        }
+
+        if (msAbs >= m) {
+          return Math.round(ms / m) + 'm';
+        }
+
+        if (msAbs >= s) {
+          return Math.round(ms / s) + 's';
+        }
+
+        return ms + 'ms';
+      }
+      /**
+       * Long format for `ms`.
+       *
+       * @param {Number} ms
+       * @return {String}
+       * @api private
+       */
+
+
+      function fmtLong(ms) {
+        var msAbs = Math.abs(ms);
+
+        if (msAbs >= d) {
+          return plural(ms, msAbs, d, 'day');
+        }
+
+        if (msAbs >= h) {
+          return plural(ms, msAbs, h, 'hour');
+        }
+
+        if (msAbs >= m) {
+          return plural(ms, msAbs, m, 'minute');
+        }
+
+        if (msAbs >= s) {
+          return plural(ms, msAbs, s, 'second');
+        }
+
+        return ms + ' ms';
+      }
+      /**
+       * Pluralization helper.
+       */
+
+
+      function plural(ms, msAbs, n, name) {
+        var isPlural = msAbs >= n * 1.5;
+        return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+      }
+    }, {}],
+    2: [function (require, module, exports) {
+      // shim for using process in browser
+      var process = module.exports = {}; // cached from whatever global is present so that test runners that stub it
+      // don't break things.  But we need to wrap it in a try catch in case it is
+      // wrapped in strict mode code which doesn't define any globals.  It's inside a
+      // function because try/catches deoptimize in certain engines.
+
+      var cachedSetTimeout;
+      var cachedClearTimeout;
+
+      function defaultSetTimout() {
+        throw new Error('setTimeout has not been defined');
+      }
+
+      function defaultClearTimeout() {
+        throw new Error('clearTimeout has not been defined');
+      }
+
+      (function () {
+        try {
+          if (typeof setTimeout === 'function') {
+            cachedSetTimeout = setTimeout;
+          } else {
+            cachedSetTimeout = defaultSetTimout;
+          }
+        } catch (e) {
+          cachedSetTimeout = defaultSetTimout;
+        }
+
+        try {
+          if (typeof clearTimeout === 'function') {
+            cachedClearTimeout = clearTimeout;
+          } else {
+            cachedClearTimeout = defaultClearTimeout;
+          }
+        } catch (e) {
+          cachedClearTimeout = defaultClearTimeout;
+        }
+      })();
+
+      function runTimeout(fun) {
+        if (cachedSetTimeout === setTimeout) {
+          //normal enviroments in sane situations
+          return setTimeout(fun, 0);
+        } // if setTimeout wasn't available but was latter defined
+
+
+        if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+          cachedSetTimeout = setTimeout;
+          return setTimeout(fun, 0);
+        }
+
+        try {
+          // when when somebody has screwed with setTimeout but no I.E. maddness
+          return cachedSetTimeout(fun, 0);
+        } catch (e) {
+          try {
+            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+            return cachedSetTimeout.call(null, fun, 0);
+          } catch (e) {
+            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
+            return cachedSetTimeout.call(this, fun, 0);
+          }
+        }
+      }
+
+      function runClearTimeout(marker) {
+        if (cachedClearTimeout === clearTimeout) {
+          //normal enviroments in sane situations
+          return clearTimeout(marker);
+        } // if clearTimeout wasn't available but was latter defined
+
+
+        if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+          cachedClearTimeout = clearTimeout;
+          return clearTimeout(marker);
+        }
+
+        try {
+          // when when somebody has screwed with setTimeout but no I.E. maddness
+          return cachedClearTimeout(marker);
+        } catch (e) {
+          try {
+            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
+            return cachedClearTimeout.call(null, marker);
+          } catch (e) {
+            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
+            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
+            return cachedClearTimeout.call(this, marker);
+          }
+        }
+      }
+
+      var queue = [];
+      var draining = false;
+      var currentQueue;
+      var queueIndex = -1;
+
+      function cleanUpNextTick() {
+        if (!draining || !currentQueue) {
+          return;
+        }
+
+        draining = false;
+
+        if (currentQueue.length) {
+          queue = currentQueue.concat(queue);
+        } else {
+          queueIndex = -1;
+        }
+
+        if (queue.length) {
+          drainQueue();
+        }
+      }
+
+      function drainQueue() {
+        if (draining) {
+          return;
+        }
+
+        var timeout = runTimeout(cleanUpNextTick);
+        draining = true;
+        var len = queue.length;
+
+        while (len) {
+          currentQueue = queue;
+          queue = [];
+
+          while (++queueIndex < len) {
+            if (currentQueue) {
+              currentQueue[queueIndex].run();
+            }
+          }
+
+          queueIndex = -1;
+          len = queue.length;
+        }
+
+        currentQueue = null;
+        draining = false;
+        runClearTimeout(timeout);
+      }
+
+      process.nextTick = function (fun) {
+        var args = new Array(arguments.length - 1);
+
+        if (arguments.length > 1) {
+          for (var i = 1; i < arguments.length; i++) {
+            args[i - 1] = arguments[i];
+          }
+        }
+
+        queue.push(new Item(fun, args));
+
+        if (queue.length === 1 && !draining) {
+          runTimeout(drainQueue);
+        }
+      }; // v8 likes predictible objects
+
+
+      function Item(fun, array) {
+        this.fun = fun;
+        this.array = array;
+      }
+
+      Item.prototype.run = function () {
+        this.fun.apply(null, this.array);
+      };
+
+      process.title = 'browser';
+      process.browser = true;
+      process.env = {};
+      process.argv = [];
+      process.version = ''; // empty string to avoid regexp issues
+
+      process.versions = {};
+
+      function noop() {}
+
+      process.on = noop;
+      process.addListener = noop;
+      process.once = noop;
+      process.off = noop;
+      process.removeListener = noop;
+      process.removeAllListeners = noop;
+      process.emit = noop;
+      process.prependListener = noop;
+      process.prependOnceListener = noop;
+
+      process.listeners = function (name) {
+        return [];
+      };
+
+      process.binding = function (name) {
+        throw new Error('process.binding is not supported');
+      };
+
+      process.cwd = function () {
+        return '/';
+      };
+
+      process.chdir = function (dir) {
+        throw new Error('process.chdir is not supported');
+      };
+
+      process.umask = function () {
+        return 0;
+      };
+    }, {}],
+    3: [function (require, module, exports) {
+      /**
+       * This is the common logic for both the Node.js and web browser
+       * implementations of `debug()`.
+       */
+      function setup(env) {
+        createDebug.debug = createDebug;
+        createDebug.default = createDebug;
+        createDebug.coerce = coerce;
+        createDebug.disable = disable;
+        createDebug.enable = enable;
+        createDebug.enabled = enabled;
+        createDebug.humanize = require('ms');
+        Object.keys(env).forEach(function (key) {
+          createDebug[key] = env[key];
+        });
+        /**
+        * Active `debug` instances.
+        */
+
+        createDebug.instances = [];
+        /**
+        * The currently active debug mode names, and names to skip.
+        */
+
+        createDebug.names = [];
+        createDebug.skips = [];
+        /**
+        * Map of special "%n" handling functions, for the debug "format" argument.
+        *
+        * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+        */
+
+        createDebug.formatters = {};
+        /**
+        * Selects a color for a debug namespace
+        * @param {String} namespace The namespace string for the for the debug instance to be colored
+        * @return {Number|String} An ANSI color code for the given namespace
+        * @api private
+        */
+
+        function selectColor(namespace) {
+          var hash = 0;
+
+          for (var i = 0; i < namespace.length; i++) {
+            hash = (hash << 5) - hash + namespace.charCodeAt(i);
+            hash |= 0; // Convert to 32bit integer
+          }
+
+          return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+        }
+
+        createDebug.selectColor = selectColor;
+        /**
+        * Create a debugger with the given `namespace`.
+        *
+        * @param {String} namespace
+        * @return {Function}
+        * @api public
+        */
+
+        function createDebug(namespace) {
+          var prevTime;
+
+          function debug() {
+            for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+              args[_key] = arguments[_key];
+            }
+
+            // Disabled?
+            if (!debug.enabled) {
+              return;
+            }
+
+            var self = debug; // Set `diff` timestamp
+
+            var curr = Number(new Date());
+            var ms = curr - (prevTime || curr);
+            self.diff = ms;
+            self.prev = prevTime;
+            self.curr = curr;
+            prevTime = curr;
+            args[0] = createDebug.coerce(args[0]);
+
+            if (typeof args[0] !== 'string') {
+              // Anything else let's inspect with %O
+              args.unshift('%O');
+            } // Apply any `formatters` transformations
+
+
+            var index = 0;
+            args[0] = args[0].replace(/%([a-zA-Z%])/g, function (match, format) {
+              // If we encounter an escaped % then don't increase the array index
+              if (match === '%%') {
+                return match;
+              }
+
+              index++;
+              var formatter = createDebug.formatters[format];
+
+              if (typeof formatter === 'function') {
+                var val = args[index];
+                match = formatter.call(self, val); // Now we need to remove `args[index]` since it's inlined in the `format`
+
+                args.splice(index, 1);
+                index--;
+              }
+
+              return match;
+            }); // Apply env-specific formatting (colors, etc.)
+
+            createDebug.formatArgs.call(self, args);
+            var logFn = self.log || createDebug.log;
+            logFn.apply(self, args);
+          }
+
+          debug.namespace = namespace;
+          debug.enabled = createDebug.enabled(namespace);
+          debug.useColors = createDebug.useColors();
+          debug.color = selectColor(namespace);
+          debug.destroy = destroy;
+          debug.extend = extend; // Debug.formatArgs = formatArgs;
+          // debug.rawLog = rawLog;
+          // env-specific initialization logic for debug instances
+
+          if (typeof createDebug.init === 'function') {
+            createDebug.init(debug);
+          }
+
+          createDebug.instances.push(debug);
+          return debug;
+        }
+
+        function destroy() {
+          var index = createDebug.instances.indexOf(this);
+
+          if (index !== -1) {
+            createDebug.instances.splice(index, 1);
+            return true;
+          }
+
+          return false;
+        }
+
+        function extend(namespace, delimiter) {
+          return createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
+        }
+        /**
+        * Enables a debug mode by namespaces. This can include modes
+        * separated by a colon and wildcards.
+        *
+        * @param {String} namespaces
+        * @api public
+        */
+
+
+        function enable(namespaces) {
+          createDebug.save(namespaces);
+          createDebug.names = [];
+          createDebug.skips = [];
+          var i;
+          var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
+          var len = split.length;
+
+          for (i = 0; i < len; i++) {
+            if (!split[i]) {
+              // ignore empty strings
+              continue;
+            }
+
+            namespaces = split[i].replace(/\*/g, '.*?');
+
+            if (namespaces[0] === '-') {
+              createDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
+            } else {
+              createDebug.names.push(new RegExp('^' + namespaces + '$'));
+            }
+          }
+
+          for (i = 0; i < createDebug.instances.length; i++) {
+            var instance = createDebug.instances[i];
+            instance.enabled = createDebug.enabled(instance.namespace);
+          }
+        }
+        /**
+        * Disable debug output.
+        *
+        * @api public
+        */
+
+
+        function disable() {
+          createDebug.enable('');
+        }
+        /**
+        * Returns true if the given mode name is enabled, false otherwise.
+        *
+        * @param {String} name
+        * @return {Boolean}
+        * @api public
+        */
+
+
+        function enabled(name) {
+          if (name[name.length - 1] === '*') {
+            return true;
+          }
+
+          var i;
+          var len;
+
+          for (i = 0, len = createDebug.skips.length; i < len; i++) {
+            if (createDebug.skips[i].test(name)) {
+              return false;
+            }
+          }
+
+          for (i = 0, len = createDebug.names.length; i < len; i++) {
+            if (createDebug.names[i].test(name)) {
+              return true;
+            }
+          }
+
+          return false;
+        }
+        /**
+        * Coerce `val`.
+        *
+        * @param {Mixed} val
+        * @return {Mixed}
+        * @api private
+        */
+
+
+        function coerce(val) {
+          if (val instanceof Error) {
+            return val.stack || val.message;
+          }
+
+          return val;
+        }
+
+        createDebug.enable(createDebug.load());
+        return createDebug;
+      }
+
+      module.exports = setup;
+    }, {
+      "ms": 1
+    }],
+    4: [function (require, module, exports) {
+      (function (process) {
+        /* eslint-env browser */
+
+        /**
+         * This is the web browser implementation of `debug()`.
+         */
+        exports.log = log;
+        exports.formatArgs = formatArgs;
+        exports.save = save;
+        exports.load = load;
+        exports.useColors = useColors;
+        exports.storage = localstorage();
+        /**
+         * Colors.
+         */
+
+        exports.colors = ['#0000CC', '#0000FF', '#0033CC', '#0033FF', '#0066CC', '#0066FF', '#0099CC', '#0099FF', '#00CC00', '#00CC33', '#00CC66', '#00CC99', '#00CCCC', '#00CCFF', '#3300CC', '#3300FF', '#3333CC', '#3333FF', '#3366CC', '#3366FF', '#3399CC', '#3399FF', '#33CC00', '#33CC33', '#33CC66', '#33CC99', '#33CCCC', '#33CCFF', '#6600CC', '#6600FF', '#6633CC', '#6633FF', '#66CC00', '#66CC33', '#9900CC', '#9900FF', '#9933CC', '#9933FF', '#99CC00', '#99CC33', '#CC0000', '#CC0033', '#CC0066', '#CC0099', '#CC00CC', '#CC00FF', '#CC3300', '#CC3333', '#CC3366', '#CC3399', '#CC33CC', '#CC33FF', '#CC6600', '#CC6633', '#CC9900', '#CC9933', '#CCCC00', '#CCCC33', '#FF0000', '#FF0033', '#FF0066', '#FF0099', '#FF00CC', '#FF00FF', '#FF3300', '#FF3333', '#FF3366', '#FF3399', '#FF33CC', '#FF33FF', '#FF6600', '#FF6633', '#FF9900', '#FF9933', '#FFCC00', '#FFCC33'];
+        /**
+         * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+         * and the Firebug extension (any Firefox version) are known
+         * to support "%c" CSS customizations.
+         *
+         * TODO: add a `localStorage` variable to explicitly enable/disable colors
+         */
+        // eslint-disable-next-line complexity
+
+        function useColors() {
+          // NB: In an Electron preload script, document will be defined but not fully
+          // initialized. Since we know we're in Chrome, we'll just detect this case
+          // explicitly
+          if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
+            return true;
+          } // Internet Explorer and Edge do not support colors.
+
+
+          if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+            return false;
+          } // Is webkit? http://stackoverflow.com/a/16459606/376773
+          // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
+
+
+          return typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+          typeof window !== 'undefined' && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+          // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+          typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+          typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+        }
+        /**
+         * Colorize log arguments if enabled.
+         *
+         * @api public
+         */
+
+
+        function formatArgs(args) {
+          args[0] = (this.useColors ? '%c' : '') + this.namespace + (this.useColors ? ' %c' : ' ') + args[0] + (this.useColors ? '%c ' : ' ') + '+' + module.exports.humanize(this.diff);
+
+          if (!this.useColors) {
+            return;
+          }
+
+          var c = 'color: ' + this.color;
+          args.splice(1, 0, c, 'color: inherit'); // The final "%c" is somewhat tricky, because there could be other
+          // arguments passed either before or after the %c, so we need to
+          // figure out the correct index to insert the CSS into
+
+          var index = 0;
+          var lastC = 0;
+          args[0].replace(/%[a-zA-Z%]/g, function (match) {
+            if (match === '%%') {
+              return;
+            }
+
+            index++;
+
+            if (match === '%c') {
+              // We only are interested in the *last* %c
+              // (the user may have provided their own)
+              lastC = index;
+            }
+          });
+          args.splice(lastC, 0, c);
+        }
+        /**
+         * Invokes `console.log()` when available.
+         * No-op when `console.log` is not a "function".
+         *
+         * @api public
+         */
+
+
+        function log() {
+          var _console;
+
+          // This hackery is required for IE8/9, where
+          // the `console.log` function doesn't have 'apply'
+          return (typeof console === "undefined" ? "undefined" : _typeof(console)) === 'object' && console.log && (_console = console).log.apply(_console, arguments);
+        }
+        /**
+         * Save `namespaces`.
+         *
+         * @param {String} namespaces
+         * @api private
+         */
+
+
+        function save(namespaces) {
+          try {
+            if (namespaces) {
+              exports.storage.setItem('debug', namespaces);
+            } else {
+              exports.storage.removeItem('debug');
+            }
+          } catch (error) {// Swallow
+            // XXX (@Qix-) should we be logging these?
+          }
+        }
+        /**
+         * Load `namespaces`.
+         *
+         * @return {String} returns the previously persisted debug modes
+         * @api private
+         */
+
+
+        function load() {
+          var r;
+
+          try {
+            r = exports.storage.getItem('debug');
+          } catch (error) {} // Swallow
+          // XXX (@Qix-) should we be logging these?
+          // If debug isn't set in LS, and we're in Electron, try to load $DEBUG
+
+
+          if (!r && typeof process !== 'undefined' && 'env' in process) {
+            r = process.env.DEBUG;
+          }
+
+          return r;
+        }
+        /**
+         * Localstorage attempts to return the localstorage.
+         *
+         * This is necessary because safari throws
+         * when a user disables cookies/localstorage
+         * and you attempt to access it.
+         *
+         * @return {LocalStorage}
+         * @api private
+         */
+
+
+        function localstorage() {
+          try {
+            // TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
+            // The Browser also has localStorage in the global context.
+            return localStorage;
+          } catch (error) {// Swallow
+            // XXX (@Qix-) should we be logging these?
+          }
+        }
+
+        module.exports = require('./common')(exports);
+        var formatters = module.exports.formatters;
+        /**
+         * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+         */
+
+        formatters.j = function (v) {
+          try {
+            return JSON.stringify(v);
+          } catch (error) {
+            return '[UnexpectedJSONParseError]: ' + error.message;
+          }
+        };
+      }).call(this, require('_process'));
+    }, {
+      "./common": 3,
+      "_process": 2
+    }]
+  }, {}, [4])(4);
+});
+
diff --git a/node_modules/@babel/core/node_modules/debug/node.js b/node_modules/@babel/core/node_modules/debug/node.js
new file mode 100644
index 00000000..7fc36fe6
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/debug/node.js
@@ -0,0 +1 @@
+module.exports = require('./src/node');
diff --git a/node_modules/@babel/core/node_modules/debug/package.json b/node_modules/@babel/core/node_modules/debug/package.json
new file mode 100644
index 00000000..3650bb0b
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/debug/package.json
@@ -0,0 +1,51 @@
+{
+  "name": "debug",
+  "version": "3.2.6",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/visionmedia/debug.git"
+  },
+  "description": "small debugging utility",
+  "keywords": [
+    "debug",
+    "log",
+    "debugger"
+  ],
+  "files": [
+    "src",
+    "node.js",
+    "dist/debug.js",
+    "LICENSE",
+    "README.md"
+  ],
+  "author": "TJ Holowaychuk <tj@vision-media.ca>",
+  "contributors": [
+    "Nathan Rajlich <nathan@tootallnate.net> (http://n8.io)",
+    "Andrew Rhyne <rhyneandrew@gmail.com>"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "ms": "^2.1.1"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.0.0",
+    "@babel/core": "^7.0.0",
+    "@babel/preset-env": "^7.0.0",
+    "browserify": "14.4.0",
+    "chai": "^3.5.0",
+    "concurrently": "^3.1.0",
+    "coveralls": "^3.0.2",
+    "istanbul": "^0.4.5",
+    "karma": "^3.0.0",
+    "karma-chai": "^0.1.0",
+    "karma-mocha": "^1.3.0",
+    "karma-phantomjs-launcher": "^1.0.2",
+    "mocha": "^5.2.0",
+    "mocha-lcov-reporter": "^1.2.0",
+    "rimraf": "^2.5.4",
+    "xo": "^0.23.0"
+  },
+  "main": "./src/index.js",
+  "browser": "./src/browser.js",
+  "unpkg": "./dist/debug.js"
+}
diff --git a/node_modules/@babel/core/node_modules/debug/src/browser.js b/node_modules/@babel/core/node_modules/debug/src/browser.js
new file mode 100644
index 00000000..c924b0ac
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/debug/src/browser.js
@@ -0,0 +1,180 @@
+"use strict";
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+/* eslint-env browser */
+
+/**
+ * This is the web browser implementation of `debug()`.
+ */
+exports.log = log;
+exports.formatArgs = formatArgs;
+exports.save = save;
+exports.load = load;
+exports.useColors = useColors;
+exports.storage = localstorage();
+/**
+ * Colors.
+ */
+
+exports.colors = ['#0000CC', '#0000FF', '#0033CC', '#0033FF', '#0066CC', '#0066FF', '#0099CC', '#0099FF', '#00CC00', '#00CC33', '#00CC66', '#00CC99', '#00CCCC', '#00CCFF', '#3300CC', '#3300FF', '#3333CC', '#3333FF', '#3366CC', '#3366FF', '#3399CC', '#3399FF', '#33CC00', '#33CC33', '#33CC66', '#33CC99', '#33CCCC', '#33CCFF', '#6600CC', '#6600FF', '#6633CC', '#6633FF', '#66CC00', '#66CC33', '#9900CC', '#9900FF', '#9933CC', '#9933FF', '#99CC00', '#99CC33', '#CC0000', '#CC0033', '#CC0066', '#CC0099', '#CC00CC', '#CC00FF', '#CC3300', '#CC3333', '#CC3366', '#CC3399', '#CC33CC', '#CC33FF', '#CC6600', '#CC6633', '#CC9900', '#CC9933', '#CCCC00', '#CCCC33', '#FF0000', '#FF0033', '#FF0066', '#FF0099', '#FF00CC', '#FF00FF', '#FF3300', '#FF3333', '#FF3366', '#FF3399', '#FF33CC', '#FF33FF', '#FF6600', '#FF6633', '#FF9900', '#FF9933', '#FFCC00', '#FFCC33'];
+/**
+ * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+ * and the Firebug extension (any Firefox version) are known
+ * to support "%c" CSS customizations.
+ *
+ * TODO: add a `localStorage` variable to explicitly enable/disable colors
+ */
+// eslint-disable-next-line complexity
+
+function useColors() {
+  // NB: In an Electron preload script, document will be defined but not fully
+  // initialized. Since we know we're in Chrome, we'll just detect this case
+  // explicitly
+  if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
+    return true;
+  } // Internet Explorer and Edge do not support colors.
+
+
+  if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+    return false;
+  } // Is webkit? http://stackoverflow.com/a/16459606/376773
+  // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
+
+
+  return typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+  typeof window !== 'undefined' && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+  // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+  typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+  typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+}
+/**
+ * Colorize log arguments if enabled.
+ *
+ * @api public
+ */
+
+
+function formatArgs(args) {
+  args[0] = (this.useColors ? '%c' : '') + this.namespace + (this.useColors ? ' %c' : ' ') + args[0] + (this.useColors ? '%c ' : ' ') + '+' + module.exports.humanize(this.diff);
+
+  if (!this.useColors) {
+    return;
+  }
+
+  var c = 'color: ' + this.color;
+  args.splice(1, 0, c, 'color: inherit'); // The final "%c" is somewhat tricky, because there could be other
+  // arguments passed either before or after the %c, so we need to
+  // figure out the correct index to insert the CSS into
+
+  var index = 0;
+  var lastC = 0;
+  args[0].replace(/%[a-zA-Z%]/g, function (match) {
+    if (match === '%%') {
+      return;
+    }
+
+    index++;
+
+    if (match === '%c') {
+      // We only are interested in the *last* %c
+      // (the user may have provided their own)
+      lastC = index;
+    }
+  });
+  args.splice(lastC, 0, c);
+}
+/**
+ * Invokes `console.log()` when available.
+ * No-op when `console.log` is not a "function".
+ *
+ * @api public
+ */
+
+
+function log() {
+  var _console;
+
+  // This hackery is required for IE8/9, where
+  // the `console.log` function doesn't have 'apply'
+  return (typeof console === "undefined" ? "undefined" : _typeof(console)) === 'object' && console.log && (_console = console).log.apply(_console, arguments);
+}
+/**
+ * Save `namespaces`.
+ *
+ * @param {String} namespaces
+ * @api private
+ */
+
+
+function save(namespaces) {
+  try {
+    if (namespaces) {
+      exports.storage.setItem('debug', namespaces);
+    } else {
+      exports.storage.removeItem('debug');
+    }
+  } catch (error) {// Swallow
+    // XXX (@Qix-) should we be logging these?
+  }
+}
+/**
+ * Load `namespaces`.
+ *
+ * @return {String} returns the previously persisted debug modes
+ * @api private
+ */
+
+
+function load() {
+  var r;
+
+  try {
+    r = exports.storage.getItem('debug');
+  } catch (error) {} // Swallow
+  // XXX (@Qix-) should we be logging these?
+  // If debug isn't set in LS, and we're in Electron, try to load $DEBUG
+
+
+  if (!r && typeof process !== 'undefined' && 'env' in process) {
+    r = process.env.DEBUG;
+  }
+
+  return r;
+}
+/**
+ * Localstorage attempts to return the localstorage.
+ *
+ * This is necessary because safari throws
+ * when a user disables cookies/localstorage
+ * and you attempt to access it.
+ *
+ * @return {LocalStorage}
+ * @api private
+ */
+
+
+function localstorage() {
+  try {
+    // TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
+    // The Browser also has localStorage in the global context.
+    return localStorage;
+  } catch (error) {// Swallow
+    // XXX (@Qix-) should we be logging these?
+  }
+}
+
+module.exports = require('./common')(exports);
+var formatters = module.exports.formatters;
+/**
+ * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+ */
+
+formatters.j = function (v) {
+  try {
+    return JSON.stringify(v);
+  } catch (error) {
+    return '[UnexpectedJSONParseError]: ' + error.message;
+  }
+};
+
diff --git a/node_modules/@babel/core/node_modules/debug/src/common.js b/node_modules/@babel/core/node_modules/debug/src/common.js
new file mode 100644
index 00000000..e0de3fb5
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/debug/src/common.js
@@ -0,0 +1,249 @@
+"use strict";
+
+/**
+ * This is the common logic for both the Node.js and web browser
+ * implementations of `debug()`.
+ */
+function setup(env) {
+  createDebug.debug = createDebug;
+  createDebug.default = createDebug;
+  createDebug.coerce = coerce;
+  createDebug.disable = disable;
+  createDebug.enable = enable;
+  createDebug.enabled = enabled;
+  createDebug.humanize = require('ms');
+  Object.keys(env).forEach(function (key) {
+    createDebug[key] = env[key];
+  });
+  /**
+  * Active `debug` instances.
+  */
+
+  createDebug.instances = [];
+  /**
+  * The currently active debug mode names, and names to skip.
+  */
+
+  createDebug.names = [];
+  createDebug.skips = [];
+  /**
+  * Map of special "%n" handling functions, for the debug "format" argument.
+  *
+  * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+  */
+
+  createDebug.formatters = {};
+  /**
+  * Selects a color for a debug namespace
+  * @param {String} namespace The namespace string for the for the debug instance to be colored
+  * @return {Number|String} An ANSI color code for the given namespace
+  * @api private
+  */
+
+  function selectColor(namespace) {
+    var hash = 0;
+
+    for (var i = 0; i < namespace.length; i++) {
+      hash = (hash << 5) - hash + namespace.charCodeAt(i);
+      hash |= 0; // Convert to 32bit integer
+    }
+
+    return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+  }
+
+  createDebug.selectColor = selectColor;
+  /**
+  * Create a debugger with the given `namespace`.
+  *
+  * @param {String} namespace
+  * @return {Function}
+  * @api public
+  */
+
+  function createDebug(namespace) {
+    var prevTime;
+
+    function debug() {
+      // Disabled?
+      if (!debug.enabled) {
+        return;
+      }
+
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      var self = debug; // Set `diff` timestamp
+
+      var curr = Number(new Date());
+      var ms = curr - (prevTime || curr);
+      self.diff = ms;
+      self.prev = prevTime;
+      self.curr = curr;
+      prevTime = curr;
+      args[0] = createDebug.coerce(args[0]);
+
+      if (typeof args[0] !== 'string') {
+        // Anything else let's inspect with %O
+        args.unshift('%O');
+      } // Apply any `formatters` transformations
+
+
+      var index = 0;
+      args[0] = args[0].replace(/%([a-zA-Z%])/g, function (match, format) {
+        // If we encounter an escaped % then don't increase the array index
+        if (match === '%%') {
+          return match;
+        }
+
+        index++;
+        var formatter = createDebug.formatters[format];
+
+        if (typeof formatter === 'function') {
+          var val = args[index];
+          match = formatter.call(self, val); // Now we need to remove `args[index]` since it's inlined in the `format`
+
+          args.splice(index, 1);
+          index--;
+        }
+
+        return match;
+      }); // Apply env-specific formatting (colors, etc.)
+
+      createDebug.formatArgs.call(self, args);
+      var logFn = self.log || createDebug.log;
+      logFn.apply(self, args);
+    }
+
+    debug.namespace = namespace;
+    debug.enabled = createDebug.enabled(namespace);
+    debug.useColors = createDebug.useColors();
+    debug.color = selectColor(namespace);
+    debug.destroy = destroy;
+    debug.extend = extend; // Debug.formatArgs = formatArgs;
+    // debug.rawLog = rawLog;
+    // env-specific initialization logic for debug instances
+
+    if (typeof createDebug.init === 'function') {
+      createDebug.init(debug);
+    }
+
+    createDebug.instances.push(debug);
+    return debug;
+  }
+
+  function destroy() {
+    var index = createDebug.instances.indexOf(this);
+
+    if (index !== -1) {
+      createDebug.instances.splice(index, 1);
+      return true;
+    }
+
+    return false;
+  }
+
+  function extend(namespace, delimiter) {
+    return createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
+  }
+  /**
+  * Enables a debug mode by namespaces. This can include modes
+  * separated by a colon and wildcards.
+  *
+  * @param {String} namespaces
+  * @api public
+  */
+
+
+  function enable(namespaces) {
+    createDebug.save(namespaces);
+    createDebug.names = [];
+    createDebug.skips = [];
+    var i;
+    var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
+    var len = split.length;
+
+    for (i = 0; i < len; i++) {
+      if (!split[i]) {
+        // ignore empty strings
+        continue;
+      }
+
+      namespaces = split[i].replace(/\*/g, '.*?');
+
+      if (namespaces[0] === '-') {
+        createDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
+      } else {
+        createDebug.names.push(new RegExp('^' + namespaces + '$'));
+      }
+    }
+
+    for (i = 0; i < createDebug.instances.length; i++) {
+      var instance = createDebug.instances[i];
+      instance.enabled = createDebug.enabled(instance.namespace);
+    }
+  }
+  /**
+  * Disable debug output.
+  *
+  * @api public
+  */
+
+
+  function disable() {
+    createDebug.enable('');
+  }
+  /**
+  * Returns true if the given mode name is enabled, false otherwise.
+  *
+  * @param {String} name
+  * @return {Boolean}
+  * @api public
+  */
+
+
+  function enabled(name) {
+    if (name[name.length - 1] === '*') {
+      return true;
+    }
+
+    var i;
+    var len;
+
+    for (i = 0, len = createDebug.skips.length; i < len; i++) {
+      if (createDebug.skips[i].test(name)) {
+        return false;
+      }
+    }
+
+    for (i = 0, len = createDebug.names.length; i < len; i++) {
+      if (createDebug.names[i].test(name)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+  /**
+  * Coerce `val`.
+  *
+  * @param {Mixed} val
+  * @return {Mixed}
+  * @api private
+  */
+
+
+  function coerce(val) {
+    if (val instanceof Error) {
+      return val.stack || val.message;
+    }
+
+    return val;
+  }
+
+  createDebug.enable(createDebug.load());
+  return createDebug;
+}
+
+module.exports = setup;
+
diff --git a/node_modules/@babel/core/node_modules/debug/src/index.js b/node_modules/@babel/core/node_modules/debug/src/index.js
new file mode 100644
index 00000000..02173159
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/debug/src/index.js
@@ -0,0 +1,12 @@
+"use strict";
+
+/**
+ * Detect Electron renderer / nwjs process, which is node, but we should
+ * treat as a browser.
+ */
+if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
+  module.exports = require('./browser.js');
+} else {
+  module.exports = require('./node.js');
+}
+
diff --git a/node_modules/@babel/core/node_modules/debug/src/node.js b/node_modules/@babel/core/node_modules/debug/src/node.js
new file mode 100644
index 00000000..dbbb5f10
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/debug/src/node.js
@@ -0,0 +1,174 @@
+"use strict";
+
+/**
+ * Module dependencies.
+ */
+var tty = require('tty');
+
+var util = require('util');
+/**
+ * This is the Node.js implementation of `debug()`.
+ */
+
+
+exports.init = init;
+exports.log = log;
+exports.formatArgs = formatArgs;
+exports.save = save;
+exports.load = load;
+exports.useColors = useColors;
+/**
+ * Colors.
+ */
+
+exports.colors = [6, 2, 3, 4, 5, 1];
+
+try {
+  // Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
+  // eslint-disable-next-line import/no-extraneous-dependencies
+  var supportsColor = require('supports-color');
+
+  if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+    exports.colors = [20, 21, 26, 27, 32, 33, 38, 39, 40, 41, 42, 43, 44, 45, 56, 57, 62, 63, 68, 69, 74, 75, 76, 77, 78, 79, 80, 81, 92, 93, 98, 99, 112, 113, 128, 129, 134, 135, 148, 149, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 178, 179, 184, 185, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 214, 215, 220, 221];
+  }
+} catch (error) {} // Swallow - we only care if `supports-color` is available; it doesn't have to be.
+
+/**
+ * Build up the default `inspectOpts` object from the environment variables.
+ *
+ *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+ */
+
+
+exports.inspectOpts = Object.keys(process.env).filter(function (key) {
+  return /^debug_/i.test(key);
+}).reduce(function (obj, key) {
+  // Camel-case
+  var prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, function (_, k) {
+    return k.toUpperCase();
+  }); // Coerce string value into JS value
+
+  var val = process.env[key];
+
+  if (/^(yes|on|true|enabled)$/i.test(val)) {
+    val = true;
+  } else if (/^(no|off|false|disabled)$/i.test(val)) {
+    val = false;
+  } else if (val === 'null') {
+    val = null;
+  } else {
+    val = Number(val);
+  }
+
+  obj[prop] = val;
+  return obj;
+}, {});
+/**
+ * Is stdout a TTY? Colored output is enabled when `true`.
+ */
+
+function useColors() {
+  return 'colors' in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+}
+/**
+ * Adds ANSI color escape codes if enabled.
+ *
+ * @api public
+ */
+
+
+function formatArgs(args) {
+  var name = this.namespace,
+      useColors = this.useColors;
+
+  if (useColors) {
+    var c = this.color;
+    var colorCode = "\x1B[3" + (c < 8 ? c : '8;5;' + c);
+    var prefix = "  ".concat(colorCode, ";1m").concat(name, " \x1B[0m");
+    args[0] = prefix + args[0].split('\n').join('\n' + prefix);
+    args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + "\x1B[0m");
+  } else {
+    args[0] = getDate() + name + ' ' + args[0];
+  }
+}
+
+function getDate() {
+  if (exports.inspectOpts.hideDate) {
+    return '';
+  }
+
+  return new Date().toISOString() + ' ';
+}
+/**
+ * Invokes `util.format()` with the specified arguments and writes to stderr.
+ */
+
+
+function log() {
+  return process.stderr.write(util.format.apply(util, arguments) + '\n');
+}
+/**
+ * Save `namespaces`.
+ *
+ * @param {String} namespaces
+ * @api private
+ */
+
+
+function save(namespaces) {
+  if (namespaces) {
+    process.env.DEBUG = namespaces;
+  } else {
+    // If you set a process.env field to null or undefined, it gets cast to the
+    // string 'null' or 'undefined'. Just delete instead.
+    delete process.env.DEBUG;
+  }
+}
+/**
+ * Load `namespaces`.
+ *
+ * @return {String} returns the previously persisted debug modes
+ * @api private
+ */
+
+
+function load() {
+  return process.env.DEBUG;
+}
+/**
+ * Init logic for `debug` instances.
+ *
+ * Create a new `inspectOpts` object in case `useColors` is set
+ * differently for a particular `debug` instance.
+ */
+
+
+function init(debug) {
+  debug.inspectOpts = {};
+  var keys = Object.keys(exports.inspectOpts);
+
+  for (var i = 0; i < keys.length; i++) {
+    debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+  }
+}
+
+module.exports = require('./common')(exports);
+var formatters = module.exports.formatters;
+/**
+ * Map %o to `util.inspect()`, all on a single line.
+ */
+
+formatters.o = function (v) {
+  this.inspectOpts.colors = this.useColors;
+  return util.inspect(v, this.inspectOpts).replace(/\s*\n\s*/g, ' ');
+};
+/**
+ * Map %O to `util.inspect()`, allowing multiple lines if needed.
+ */
+
+
+formatters.O = function (v) {
+  this.inspectOpts.colors = this.useColors;
+  return util.inspect(v, this.inspectOpts);
+};
+
diff --git a/node_modules/@babel/core/node_modules/expand-brackets/LICENSE b/node_modules/@babel/core/node_modules/expand-brackets/LICENSE
new file mode 100644
index 00000000..1e49edf8
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/expand-brackets/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2016, Jon Schlinkert.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/node_modules/@babel/core/node_modules/expand-brackets/README.md b/node_modules/@babel/core/node_modules/expand-brackets/README.md
new file mode 100644
index 00000000..d3c913e7
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/expand-brackets/README.md
@@ -0,0 +1,107 @@
+# expand-brackets [![NPM version](https://img.shields.io/npm/v/expand-brackets.svg?style=flat)](https://www.npmjs.com/package/expand-brackets) [![NPM downloads](https://img.shields.io/npm/dm/expand-brackets.svg?style=flat)](https://npmjs.org/package/expand-brackets) [![Build Status](https://img.shields.io/travis/jonschlinkert/expand-brackets.svg?style=flat)](https://travis-ci.org/jonschlinkert/expand-brackets)
+
+> Expand POSIX bracket expressions (character classes) in glob patterns.
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+$ npm install expand-brackets --save
+```
+
+## Usage
+
+```js
+var brackets = require('expand-brackets');
+
+brackets('[![:lower:]]');
+//=> '[^a-z]'
+```
+
+## .isMatch
+
+Return true if the given string matches the bracket expression:
+
+```js
+brackets.isMatch('A', '[![:lower:]]');
+//=> true
+
+brackets.isMatch('a', '[![:lower:]]');
+//=> false
+```
+
+## .makeRe
+
+Make a regular expression from a bracket expression:
+
+```js
+brackets.makeRe('[![:lower:]]');
+//=> /[^a-z]/
+```
+
+The following named POSIX bracket expressions are supported:
+
+* `[:alnum:]`: Alphanumeric characters (`a-zA-Z0-9]`)
+* `[:alpha:]`: Alphabetic characters (`a-zA-Z]`)
+* `[:blank:]`: Space and tab (`[ t]`)
+* `[:digit:]`: Digits (`[0-9]`)
+* `[:lower:]`: Lowercase letters (`[a-z]`)
+* `[:punct:]`: Punctuation and symbols. (`[!"#$%&'()*+, -./:;<=>?@ [\]^_``{|}~]`)
+* `[:upper:]`: Uppercase letters (`[A-Z]`)
+* `[:word:]`: Word characters (letters, numbers and underscores) (`[A-Za-z0-9_]`)
+* `[:xdigit:]`: Hexadecimal digits (`[A-Fa-f0-9]`)
+
+Collating sequences are not supported.
+
+## Related projects
+
+You might also be interested in these projects:
+
+* [extglob](https://www.npmjs.com/package/extglob): Convert extended globs to regex-compatible strings. Add (almost) the expressive power of regular expressions to… [more](https://www.npmjs.com/package/extglob) | [homepage](https://github.com/jonschlinkert/extglob)
+* [is-extglob](https://www.npmjs.com/package/is-extglob): Returns true if a string has an extglob. | [homepage](https://github.com/jonschlinkert/is-extglob)
+* [is-glob](https://www.npmjs.com/package/is-glob): Returns `true` if the given string looks like a glob pattern or an extglob pattern.… [more](https://www.npmjs.com/package/is-glob) | [homepage](https://github.com/jonschlinkert/is-glob)
+* [is-posix-bracket](https://www.npmjs.com/package/is-posix-bracket): Returns true if the given string is a POSIX bracket expression (POSIX character class). | [homepage](https://github.com/jonschlinkert/is-posix-bracket)
+* [micromatch](https://www.npmjs.com/package/micromatch): Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch. Just… [more](https://www.npmjs.com/package/micromatch) | [homepage](https://github.com/jonschlinkert/micromatch)
+
+## Contributing
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](https://github.com/jonschlinkert/expand-brackets/issues/new).
+
+## Building docs
+
+Generate readme and API documentation with [verb](https://github.com/verbose/verb):
+
+```sh
+$ npm install verb && npm run docs
+```
+
+Or, if [verb](https://github.com/verbose/verb) is installed globally:
+
+```sh
+$ verb
+```
+
+## Running tests
+
+Install dev dependencies:
+
+```sh
+$ npm install -d && npm test
+```
+
+## Author
+
+**Jon Schlinkert**
+
+* [github/jonschlinkert](https://github.com/jonschlinkert)
+* [twitter/jonschlinkert](http://twitter.com/jonschlinkert)
+
+## License
+
+verb © 2016, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT license](https://github.com/jonschlinkert/expand-brackets/blob/master/LICENSE).
+
+***
+
+_This file was generated by [verb](https://github.com/verbose/verb), v, on April 01, 2016._
\ No newline at end of file
diff --git a/node_modules/@babel/core/node_modules/expand-brackets/index.js b/node_modules/@babel/core/node_modules/expand-brackets/index.js
new file mode 100644
index 00000000..b843cc2b
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/expand-brackets/index.js
@@ -0,0 +1,163 @@
+/*!
+ * expand-brackets <https://github.com/jonschlinkert/expand-brackets>
+ *
+ * Copyright (c) 2015 Jon Schlinkert.
+ * Licensed under the MIT license.
+ */
+
+'use strict';
+
+var isPosixBracket = require('is-posix-bracket');
+
+/**
+ * POSIX character classes
+ */
+
+var POSIX = {
+  alnum: 'a-zA-Z0-9',
+  alpha: 'a-zA-Z',
+  blank: ' \\t',
+  cntrl: '\\x00-\\x1F\\x7F',
+  digit: '0-9',
+  graph: '\\x21-\\x7E',
+  lower: 'a-z',
+  print: '\\x20-\\x7E',
+  punct: '-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
+  space: ' \\t\\r\\n\\v\\f',
+  upper: 'A-Z',
+  word:  'A-Za-z0-9_',
+  xdigit: 'A-Fa-f0-9',
+};
+
+/**
+ * Expose `brackets`
+ */
+
+module.exports = brackets;
+
+function brackets(str) {
+  if (!isPosixBracket(str)) {
+    return str;
+  }
+
+  var negated = false;
+  if (str.indexOf('[^') !== -1) {
+    negated = true;
+    str = str.split('[^').join('[');
+  }
+  if (str.indexOf('[!') !== -1) {
+    negated = true;
+    str = str.split('[!').join('[');
+  }
+
+  var a = str.split('[');
+  var b = str.split(']');
+  var imbalanced = a.length !== b.length;
+
+  var parts = str.split(/(?::\]\[:|\[?\[:|:\]\]?)/);
+  var len = parts.length, i = 0;
+  var end = '', beg = '';
+  var res = [];
+
+  // start at the end (innermost) first
+  while (len--) {
+    var inner = parts[i++];
+    if (inner === '^[!' || inner === '[!') {
+      inner = '';
+      negated = true;
+    }
+
+    var prefix = negated ? '^' : '';
+    var ch = POSIX[inner];
+
+    if (ch) {
+      res.push('[' + prefix + ch + ']');
+    } else if (inner) {
+      if (/^\[?\w-\w\]?$/.test(inner)) {
+        if (i === parts.length) {
+          res.push('[' + prefix + inner);
+        } else if (i === 1) {
+          res.push(prefix + inner + ']');
+        } else {
+          res.push(prefix + inner);
+        }
+      } else {
+        if (i === 1) {
+          beg += inner;
+        } else if (i === parts.length) {
+          end += inner;
+        } else {
+          res.push('[' + prefix + inner + ']');
+        }
+      }
+    }
+  }
+
+  var result = res.join('|');
+  var rlen = res.length || 1;
+  if (rlen > 1) {
+    result = '(?:' + result + ')';
+    rlen = 1;
+  }
+  if (beg) {
+    rlen++;
+    if (beg.charAt(0) === '[') {
+      if (imbalanced) {
+        beg = '\\[' + beg.slice(1);
+      } else {
+        beg += ']';
+      }
+    }
+    result = beg + result;
+  }
+  if (end) {
+    rlen++;
+    if (end.slice(-1) === ']') {
+      if (imbalanced) {
+        end = end.slice(0, end.length - 1) + '\\]';
+      } else {
+        end = '[' + end;
+      }
+    }
+    result += end;
+  }
+
+  if (rlen > 1) {
+    result = result.split('][').join(']|[');
+    if (result.indexOf('|') !== -1 && !/\(\?/.test(result)) {
+      result = '(?:' + result + ')';
+    }
+  }
+
+  result = result.replace(/\[+=|=\]+/g, '\\b');
+  return result;
+}
+
+brackets.makeRe = function(pattern) {
+  try {
+    return new RegExp(brackets(pattern));
+  } catch (err) {}
+};
+
+brackets.isMatch = function(str, pattern) {
+  try {
+    return brackets.makeRe(pattern).test(str);
+  } catch (err) {
+    return false;
+  }
+};
+
+brackets.match = function(arr, pattern) {
+  var len = arr.length, i = 0;
+  var res = arr.slice();
+
+  var re = brackets.makeRe(pattern);
+  while (i < len) {
+    var ele = arr[i++];
+    if (!re.test(ele)) {
+      continue;
+    }
+    res.splice(i, 1);
+  }
+  return res;
+};
diff --git a/node_modules/@babel/core/node_modules/expand-brackets/package.json b/node_modules/@babel/core/node_modules/expand-brackets/package.json
new file mode 100644
index 00000000..99dddafc
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/expand-brackets/package.json
@@ -0,0 +1,62 @@
+{
+  "name": "expand-brackets",
+  "description": "Expand POSIX bracket expressions (character classes) in glob patterns.",
+  "version": "0.1.5",
+  "homepage": "https://github.com/jonschlinkert/expand-brackets",
+  "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
+  "repository": "jonschlinkert/expand-brackets",
+  "bugs": {
+    "url": "https://github.com/jonschlinkert/expand-brackets/issues"
+  },
+  "license": "MIT",
+  "files": [
+    "index.js"
+  ],
+  "main": "index.js",
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "dependencies": {
+    "is-posix-bracket": "^0.1.0"
+  },
+  "devDependencies": {
+    "gulp-format-md": "^0.1.7",
+    "mocha": "^2.2.5",
+    "should": "^7.0.2"
+  },
+  "keywords": [
+    "bracket",
+    "character class",
+    "expression",
+    "posix"
+  ],
+  "verb": {
+    "run": true,
+    "toc": false,
+    "layout": "default",
+    "tasks": [
+      "readme"
+    ],
+    "plugins": [
+      "gulp-format-md"
+    ],
+    "related": {
+      "list": [
+        "extglob",
+        "is-extglob",
+        "is-glob",
+        "is-posix-bracket",
+        "micromatch"
+      ]
+    },
+    "reflinks": [
+      "verb"
+    ],
+    "lint": {
+      "reflinks": true
+    }
+  }
+}
diff --git a/node_modules/@babel/core/node_modules/extglob/LICENSE b/node_modules/@babel/core/node_modules/extglob/LICENSE
new file mode 100644
index 00000000..65f90aca
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/extglob/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015, Jon Schlinkert.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/node_modules/@babel/core/node_modules/extglob/README.md b/node_modules/@babel/core/node_modules/extglob/README.md
new file mode 100644
index 00000000..66644066
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/extglob/README.md
@@ -0,0 +1,88 @@
+# extglob [![NPM version](https://badge.fury.io/js/extglob.svg)](http://badge.fury.io/js/extglob)  [![Build Status](https://travis-ci.org/jonschlinkert/extglob.svg)](https://travis-ci.org/jonschlinkert/extglob)
+
+> Convert extended globs to regex-compatible strings. Add (almost) the expressive power of regular expressions to glob patterns.
+
+Install with [npm](https://www.npmjs.com/)
+
+```sh
+$ npm i extglob --save
+```
+
+Used by [micromatch](https://github.com/jonschlinkert/micromatch).
+
+**Features**
+
+* Convert an extglob string to a regex-compatible string. **Only converts extglobs**, to handle full globs use [micromatch](https://github.com/jonschlinkert/micromatch).
+* Pass `{regex: true}` to return a regex
+* Handles nested patterns
+* More complete (and correct) support than [minimatch](https://github.com/isaacs/minimatch)
+
+## Usage
+
+```js
+var extglob = require('extglob');
+
+extglob('?(z)');
+//=> '(?:z)?'
+extglob('*(z)');
+//=> '(?:z)*'
+extglob('+(z)');
+//=> '(?:z)+'
+extglob('@(z)');
+//=> '(?:z)'
+extglob('!(z)');
+//=> '(?!^(?:(?!z)[^/]*?)).*$'
+```
+
+**Optionally return regex**
+
+```js
+extglob('!(z)', {regex: true});
+//=> /(?!^(?:(?!z)[^/]*?)).*$/
+```
+
+## Extglob patterns
+
+To learn more about how extglobs work, see the docs for [Bash pattern matching](https://www.gnu.org/software/bash/manual/html_node/Pattern-Matching.html):
+
+* `?(pattern)`: Match zero or one occurrence of the given pattern.
+* `*(pattern)`: Match zero or more occurrences of the given pattern.
+* `+(pattern)`: Match one or more occurrences of the given pattern.
+* `@(pattern)`: Match one of the given pattern.
+* `!(pattern)`: Match anything except one of the given pattern.
+
+## Related
+
+* [braces](https://github.com/jonschlinkert/braces): Fastest brace expansion for node.js, with the most complete support for the Bash 4.3 braces… [more](https://github.com/jonschlinkert/braces)
+* [expand-brackets](https://github.com/jonschlinkert/expand-brackets): Expand POSIX bracket expressions (character classes) in glob patterns.
+* [expand-range](https://github.com/jonschlinkert/expand-range): Fast, bash-like range expansion. Expand a range of numbers or letters, uppercase or lowercase. See… [more](https://github.com/jonschlinkert/expand-range)
+* [fill-range](https://github.com/jonschlinkert/fill-range): Fill in a range of numbers or letters, optionally passing an increment or multiplier to… [more](https://github.com/jonschlinkert/fill-range)
+* [micromatch](https://github.com/jonschlinkert/micromatch): Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch. Just… [more](https://github.com/jonschlinkert/micromatch)
+
+## Run tests
+
+Install dev dependencies:
+
+```sh
+$ npm i -d && npm test
+```
+
+## Contributing
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](https://github.com/jonschlinkert/extglob/issues/new)
+
+## Author
+
+**Jon Schlinkert**
+
++ [github/jonschlinkert](https://github.com/jonschlinkert)
++ [twitter/jonschlinkert](http://twitter.com/jonschlinkert)
+
+## License
+
+Copyright © 2015 Jon Schlinkert
+Released under the MIT license.
+
+***
+
+_This file was generated by [verb-cli](https://github.com/assemble/verb-cli) on August 01, 2015._
\ No newline at end of file
diff --git a/node_modules/@babel/core/node_modules/extglob/index.js b/node_modules/@babel/core/node_modules/extglob/index.js
new file mode 100644
index 00000000..2e774d4a
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/extglob/index.js
@@ -0,0 +1,178 @@
+/*!
+ * extglob <https://github.com/jonschlinkert/extglob>
+ *
+ * Copyright (c) 2015, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+'use strict';
+
+/**
+ * Module dependencies
+ */
+
+var isExtglob = require('is-extglob');
+var re, cache = {};
+
+/**
+ * Expose `extglob`
+ */
+
+module.exports = extglob;
+
+/**
+ * Convert the given extglob `string` to a regex-compatible
+ * string.
+ *
+ * ```js
+ * var extglob = require('extglob');
+ * extglob('!(a?(b))');
+ * //=> '(?!a(?:b)?)[^/]*?'
+ * ```
+ *
+ * @param {String} `str` The string to convert.
+ * @param {Object} `options`
+ *   @option {Boolean} [options] `esc` If `false` special characters will not be escaped. Defaults to `true`.
+ *   @option {Boolean} [options] `regex` If `true` a regular expression is returned instead of a string.
+ * @return {String}
+ * @api public
+ */
+
+
+function extglob(str, opts) {
+  opts = opts || {};
+  var o = {}, i = 0;
+
+  // fix common character reversals
+  // '*!(.js)' => '*.!(js)'
+  str = str.replace(/!\(([^\w*()])/g, '$1!(');
+
+  // support file extension negation
+  str = str.replace(/([*\/])\.!\([*]\)/g, function (m, ch) {
+    if (ch === '/') {
+      return escape('\\/[^.]+');
+    }
+    return escape('[^.]+');
+  });
+
+  // create a unique key for caching by
+  // combining the string and options
+  var key = str
+    + String(!!opts.regex)
+    + String(!!opts.contains)
+    + String(!!opts.escape);
+
+  if (cache.hasOwnProperty(key)) {
+    return cache[key];
+  }
+
+  if (!(re instanceof RegExp)) {
+    re = regex();
+  }
+
+  opts.negate = false;
+  var m;
+
+  while (m = re.exec(str)) {
+    var prefix = m[1];
+    var inner = m[3];
+    if (prefix === '!') {
+      opts.negate = true;
+    }
+
+    var id = '__EXTGLOB_' + (i++) + '__';
+    // use the prefix of the _last_ (outtermost) pattern
+    o[id] = wrap(inner, prefix, opts.escape);
+    str = str.split(m[0]).join(id);
+  }
+
+  var keys = Object.keys(o);
+  var len = keys.length;
+
+  // we have to loop again to allow us to convert
+  // patterns in reverse order (starting with the
+  // innermost/last pattern first)
+  while (len--) {
+    var prop = keys[len];
+    str = str.split(prop).join(o[prop]);
+  }
+
+  var result = opts.regex
+    ? toRegex(str, opts.contains, opts.negate)
+    : str;
+
+  result = result.split('.').join('\\.');
+
+  // cache the result and return it
+  return (cache[key] = result);
+}
+
+/**
+ * Convert `string` to a regex string.
+ *
+ * @param  {String} `str`
+ * @param  {String} `prefix` Character that determines how to wrap the string.
+ * @param  {Boolean} `esc` If `false` special characters will not be escaped. Defaults to `true`.
+ * @return {String}
+ */
+
+function wrap(inner, prefix, esc) {
+  if (esc) inner = escape(inner);
+
+  switch (prefix) {
+    case '!':
+      return '(?!' + inner + ')[^/]' + (esc ? '%%%~' : '*?');
+    case '@':
+      return '(?:' + inner + ')';
+    case '+':
+      return '(?:' + inner + ')+';
+    case '*':
+      return '(?:' + inner + ')' + (esc ? '%%' : '*')
+    case '?':
+      return '(?:' + inner + '|)';
+    default:
+      return inner;
+  }
+}
+
+function escape(str) {
+  str = str.split('*').join('[^/]%%%~');
+  str = str.split('.').join('\\.');
+  return str;
+}
+
+/**
+ * extglob regex.
+ */
+
+function regex() {
+  return /(\\?[@?!+*$]\\?)(\(([^()]*?)\))/;
+}
+
+/**
+ * Negation regex
+ */
+
+function negate(str) {
+  return '(?!^' + str + ').*$';
+}
+
+/**
+ * Create the regex to do the matching. If
+ * the leading character in the `pattern` is `!`
+ * a negation regex is returned.
+ *
+ * @param {String} `pattern`
+ * @param {Boolean} `contains` Allow loose matching.
+ * @param {Boolean} `isNegated` True if the pattern is a negation pattern.
+ */
+
+function toRegex(pattern, contains, isNegated) {
+  var prefix = contains ? '^' : '';
+  var after = contains ? '$' : '';
+  pattern = ('(?:' + pattern + ')' + after);
+  if (isNegated) {
+    pattern = prefix + negate(pattern);
+  }
+  return new RegExp(prefix + pattern);
+}
diff --git a/node_modules/@babel/core/node_modules/extglob/package.json b/node_modules/@babel/core/node_modules/extglob/package.json
new file mode 100644
index 00000000..969cbe56
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/extglob/package.json
@@ -0,0 +1,60 @@
+{
+  "name": "extglob",
+  "description": "Convert extended globs to regex-compatible strings. Add (almost) the expressive power of regular expressions to glob patterns.",
+  "version": "0.3.2",
+  "homepage": "https://github.com/jonschlinkert/extglob",
+  "author": {
+    "name": "Jon Schlinkert",
+    "url": "https://github.com/jonschlinkert"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/jonschlinkert/extglob.git"
+  },
+  "bugs": {
+    "url": "https://github.com/jonschlinkert/extglob/issues"
+  },
+  "license": "MIT",
+  "files": [
+    "index.js"
+  ],
+  "main": "index.js",
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "dependencies": {
+    "is-extglob": "^1.0.0"
+  },
+  "devDependencies": {
+    "ansi-green": "^0.1.1",
+    "micromatch": "^2.1.6",
+    "minimatch": "^2.0.1",
+    "minimist": "^1.1.0",
+    "mocha": "*",
+    "should": "*",
+    "success-symbol": "^0.1.0"
+  },
+  "keywords": [
+    "bash",
+    "extended",
+    "extglob",
+    "glob",
+    "ksh",
+    "match",
+    "wildcard"
+  ],
+  "verb": {
+    "related": {
+      "list": [
+        "micromatch",
+        "expand-brackets",
+        "braces",
+        "fill-range",
+        "expand-range"
+      ]
+    }
+  }
+}
diff --git a/node_modules/@babel/core/node_modules/micromatch/LICENSE b/node_modules/@babel/core/node_modules/micromatch/LICENSE
new file mode 100755
index 00000000..fa30c4cb
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/micromatch/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2015, Jon Schlinkert.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/node_modules/@babel/core/node_modules/micromatch/README.md b/node_modules/@babel/core/node_modules/micromatch/README.md
new file mode 100644
index 00000000..8fb39191
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/micromatch/README.md
@@ -0,0 +1,689 @@
+# micromatch [![NPM version](https://img.shields.io/npm/v/micromatch.svg?style=flat)](https://www.npmjs.com/package/micromatch) [![NPM downloads](https://img.shields.io/npm/dm/micromatch.svg?style=flat)](https://npmjs.org/package/micromatch) [![Build Status](https://img.shields.io/travis/jonschlinkert/micromatch.svg?style=flat)](https://travis-ci.org/jonschlinkert/micromatch)
+
+> Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch.
+
+Micromatch supports all of the same matching features as [minimatch](https://github.com/isaacs/minimatch) and [multimatch](https://github.com/sindresorhus/multimatch).
+
+* [mm()](#usage) is the same as [multimatch()](https://github.com/sindresorhus/multimatch)
+* [mm.match()](#match) is the same as [minimatch.match()](https://github.com/isaacs/minimatch)
+* use [mm.isMatch()](#ismatch) instead of [minimatch()](https://github.com/isaacs/minimatch)
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+$ npm install --save micromatch
+```
+
+## Start matching!
+
+```js
+var mm = require('micromatch');
+console.log(mm(['']))
+```
+
+***
+
+### Features
+
+* [Drop-in replacement](#switch-from-minimatch) for [minimatch](https://github.com/isaacs/minimatch) and [multimatch](https://github.com/sindresorhus/multimatch)
+* Built-in support for multiple glob patterns, like `['foo/*.js', '!bar.js']`
+* [Brace Expansion](https://github.com/jonschlinkert/braces) (`foo/bar-{1..5}.md`, `one/{two,three}/four.md`)
+* Typical glob patterns, like `**/*`, `a/b/*.js`, or `['foo/*.js', '!bar.js']`
+* Methods like `.isMatch()`, `.contains()` and `.any()`
+
+**Extended globbing features:**
+
+* Logical `OR` (`foo/bar/(abc|xyz).js`)
+* Regex character classes (`foo/bar/baz-[1-5].js`)
+* POSIX [bracket expressions](https://github.com/jonschlinkert/expand-brackets) (`**/[[:alpha:][:digit:]]/`)
+* [extglobs](https://github.com/jonschlinkert/extglob) (`**/+(x|y)`, `!(a|b)`, etc).
+
+You can combine these to create whatever matching patterns you need.
+
+**Example**
+
+```js
+// double-negation!
+mm(['fa', 'fb', 'f', 'fo'], '!(f!(o))');
+//=> ['fo']
+```
+
+## Why switch to micromatch?
+
+* Native support for multiple glob patterns, no need for wrappers like [multimatch](https://github.com/sindresorhus/multimatch)
+* [10-55x faster](#benchmarks) and more performant than [minimatch](https://github.com/isaacs/minimatch) and [multimatch](https://github.com/sindresorhus/multimatch). This is achieved through a combination of caching and regex optimization strategies, a fundamentally different approach than minimatch.
+* More extensive support for the Bash 4.3 specification
+* More complete extglob support
+* Extensive [unit tests](./test) (approx. 1,300 tests). Minimatch fails many of the tests.
+
+### Switch from minimatch
+
+Use `mm.isMatch()` instead of `minimatch()`:
+
+```js
+mm.isMatch('foo', 'b*');
+//=> false
+```
+
+Use `mm.match()` instead of `minimatch.match()`:
+
+```js
+mm.match(['foo', 'bar'], 'b*');
+//=> 'bar'
+```
+
+### Switch from multimatch
+
+Same signature:
+
+```js
+mm(['foo', 'bar', 'baz'], ['f*', '*z']);
+//=> ['foo', 'baz']
+```
+
+***
+
+## Usage
+
+Add micromatch to your node.js project:
+
+```js
+var mm = require('micromatch');
+```
+
+**Signature**
+
+```js
+mm(array_of_strings, glob_patterns[, options]);
+```
+
+**Example**
+
+```js
+mm(['foo', 'bar', 'baz'], 'b*');
+//=> ['bar', 'baz']
+```
+
+### Usage examples
+
+**Brace expansion**
+
+Match files with `.js` or `.txt` extensions.
+
+```js
+mm(['a.js', 'b.md', 'c.txt'], '*.{js,txt}');
+//=> ['a.js', 'c.txt']
+```
+
+**Extglobs**
+
+Match anything except for files with the `.md` extension.
+
+```js
+mm(files, '**/*.!(md)');
+
+//=> ['a.js', 'c.txt']
+```
+
+**Multiple patterns**
+
+Match using an array of patterns.
+
+```js
+mm(['a.md', 'b.js', 'c.txt', 'd.json'], ['*.md', '*.txt']);
+//=> ['a.md', 'c.txt']
+```
+
+**Negation patterns:**
+
+Behavior is designed to be what users would expect, based on conventions that are already well-established.
+
+* [minimatch](https://github.com/isaacs/minimatch) behavior is used when the pattern is a string, so patterns are **inclusive by default**.
+* [multimatch](https://github.com/sindresorhus/multimatch) behavior is used when an array of patterns is passed, so patterns are **exclusive by default**.
+
+```js
+mm(['a.js', 'b.md', 'c.txt'], '!*.{js,txt}');
+//=> ['b.md']
+
+mm(['a.md', 'b.js', 'c.txt', 'd.json'], ['*.*', '!*.{js,txt}']);
+//=> ['a.md', 'd.json']
+```
+
+***
+
+## API methods
+
+```js
+var mm = require('micromatch');
+```
+
+### .match
+
+```js
+mm.match(array, globString);
+```
+
+Return an array of files that match the given glob pattern. Useful if you only need to use a single glob pattern.
+
+**Example**
+
+```js
+mm.match(['ab', 'a/b', 'bb', 'b/c'], '?b');
+//=> ['ab', 'bb']
+
+mm.match(['ab', 'a/b', 'bb', 'b/c'], '*/b');
+//=> ['a/b']
+```
+
+### .isMatch
+
+```js
+mm.isMatch(filepath, globString);
+```
+
+Returns true if a file path matches the given glob pattern.
+
+**Example**
+
+```js
+mm.isMatch('.verb.md', '*.md');
+//=> false
+
+mm.isMatch('.verb.md', '*.md', {dot: true});
+//=> true
+```
+
+### .contains
+
+Returns true if any part of a file path matches the given glob pattern. Think of this is "has path" versus "is path".
+
+**Example**
+
+`.isMatch()` would return false for both of the following:
+
+```js
+mm.contains('a/b/c', 'a/b');
+//=> true
+
+mm.contains('a/b/c', 'a/*');
+//=> true
+```
+
+### .matcher
+
+Returns a function for matching using the supplied pattern. e.g. create your own "matcher". The advantage of this method is that the pattern can be compiled outside of a loop.
+
+**Pattern**
+
+Can be any of the following:
+
+* `glob/string`
+* `regex`
+* `function`
+
+**Example**
+
+```js
+var isMatch = mm.matcher('*.md');
+var files = [];
+
+['a.md', 'b.txt', 'c.md'].forEach(function(fp) {
+  if (isMatch(fp)) {
+    files.push(fp);
+  }
+});
+```
+
+### .filter
+
+Returns a function that can be passed to `Array#filter()`.
+
+**Params**
+
+* `patterns` **{String|Array}**:
+
+**Examples**
+
+Single glob:
+
+```js
+var fn = mm.filter('*.md');
+['a.js', 'b.txt', 'c.md'].filter(fn);
+//=> ['c.md']
+
+var fn = mm.filter('[a-c]');
+['a', 'b', 'c', 'd', 'e'].filter(fn);
+//=> ['a', 'b', 'c']
+```
+
+Array of glob patterns:
+
+```js
+var arr = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15];
+
+var fn = mm.filter(['{1..10}', '![7-9]', '!{3..4}']);
+arr.filter(fn);
+//=> [1, 2, 5, 6, 10]
+```
+
+_(Internally this function generates the matching function by using the [matcher](#matcher) method. You can use the [matcher](#matcher) method directly to create your own filter function)_
+
+### .any
+
+Returns true if a file path matches any of the given patterns.
+
+```js
+mm.any(filepath, patterns, options);
+```
+
+**Params**
+
+* filepath `{String}`: The file path to test.
+* patterns `{String|Array}`: One or more glob patterns
+* options: `{Object}`: options to pass to the `.matcher()` method.
+
+**Example**
+
+```js
+mm.any('abc', ['!*z']);
+//=> true
+mm.any('abc', ['a*', 'z*']);
+//=> true
+mm.any('abc', 'a*');
+//=> true
+mm.any('abc', ['z*']);
+//=> false
+```
+
+### .expand
+
+Returns an object with a regex-compatible string and tokens.
+
+```js
+mm.expand('*.js');
+
+// when `track` is enabled (for debugging), the `history` array is used
+// to record each mutation to the glob pattern as it's converted to regex
+{ options: { track: false, dot: undefined, makeRe: true, negated: false },
+  pattern: '(.*\\/|^)bar\\/(?:(?!(?:^|\\/)\\.).)*?',
+  history: [],
+  tokens:
+   { path:
+      { whole: '**/bar/**',
+        dirname: '**/bar/',
+        filename: '**',
+        basename: '**',
+        extname: '',
+        ext: '' },
+     is:
+      { glob: true,
+        negated: false,
+        globstar: true,
+        dotfile: false,
+        dotdir: false },
+     match: {},
+     original: '**/bar/**',
+     pattern: '**/bar/**',
+     base: '' } }
+```
+
+### .makeRe
+
+Create a regular expression for matching file paths based on the given pattern:
+
+```js
+mm.makeRe('*.js');
+//=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+```
+
+## Options
+
+### options.unixify
+
+Normalize slashes in file paths and glob patterns to forward slashes.
+
+Type: `{Boolean}`
+
+Default: `undefined` on non-windows, `true` on windows.
+
+### options.dot
+
+Match dotfiles. Same behavior as [minimatch](https://github.com/isaacs/minimatch).
+
+Type: `{Boolean}`
+
+Default: `false`
+
+### options.unescape
+
+Unescape slashes in glob patterns. Use cautiously, especially on windows.
+
+Type: `{Boolean}`
+
+Default: `undefined`
+
+**Example**
+
+```js
+mm.isMatch('abc', '\\a\\b\\c', {unescape: true});
+//=> true
+```
+
+### options.nodupes
+
+Remove duplicate elements from the result array.
+
+Type: `{Boolean}`
+
+Default: `undefined`
+
+**Example**
+
+Example of using the `unescape` and `nodupes` options together:
+
+```js
+mm.match(['abc', '\\a\\b\\c'], '\\a\\b\\c', {unescape: true});
+//=> ['abc', 'abc']
+
+mm.match(['abc', '\\a\\b\\c'], '\\a\\b\\c', {unescape: true, nodupes: true});
+//=> ['abc']
+```
+
+### options.matchBase
+
+Allow glob patterns without slashes to match a file path based on its basename. . Same behavior as [minimatch](https://github.com/isaacs/minimatch).
+
+Type: `{Boolean}`
+
+Default: `false`
+
+**Example**
+
+```js
+mm(['a/b.js', 'a/c.md'], '*.js');
+//=> []
+
+mm(['a/b.js', 'a/c.md'], '*.js', {matchBase: true});
+//=> ['a/b.js']
+```
+
+### options.nobraces
+
+Don't expand braces in glob patterns. Same behavior as [minimatch](https://github.com/isaacs/minimatch) `nobrace`.
+
+Type: `{Boolean}`
+
+Default: `undefined`
+
+See [braces](https://github.com/jonschlinkert/braces) for more information about extended brace expansion.
+
+### options.nobrackets
+
+Don't expand POSIX bracket expressions.
+
+Type: `{Boolean}`
+
+Default: `undefined`
+
+See [expand-brackets](https://github.com/jonschlinkert/expand-brackets) for more information about extended bracket expressions.
+
+### options.noextglob
+
+Don't expand extended globs.
+
+Type: `{Boolean}`
+
+Default: `undefined`
+
+See [extglob](https://github.com/jonschlinkert/extglob) for more information about extended globs.
+
+### options.nocase
+
+Use a case-insensitive regex for matching files. Same behavior as [minimatch](https://github.com/isaacs/minimatch).
+
+Type: `{Boolean}`
+
+Default: `false`
+
+### options.nonegate
+
+Disallow negation (`!`) patterns.
+
+Type: `{Boolean}`
+
+Default: `false`
+
+### options.nonull
+
+If `true`, when no matches are found the actual (array-ified) glob pattern is returned instead of an empty array. Same behavior as [minimatch](https://github.com/isaacs/minimatch).
+
+Type: `{Boolean}`
+
+Default: `false`
+
+### options.cache
+
+Cache the platform (e.g. `win32`) to prevent this from being looked up for every filepath.
+
+Type: `{Boolean}`
+
+Default: `true`
+
+***
+
+## Other features
+
+Micromatch also supports the following.
+
+### Extended globbing
+
+#### extglobs
+
+Extended globbing, as described by the bash man page:
+
+| **pattern** | **regex equivalent** | **description** | 
+| --- | --- | --- |
+| `?(pattern-list)` | `(... | ...)?` | Matches zero or one occurrence of the given patterns |
+| `*(pattern-list)` | `(... | ...)*` | Matches zero or more occurrences of the given patterns |
+| `+(pattern-list)` | `(... | ...)+` | Matches one or more occurrences of the given patterns |
+| `@(pattern-list)` | `(... | ...)` <sup>*</sup> | Matches one of the given patterns |
+| `!(pattern-list)` | N/A | Matches anything except one of the given patterns |
+
+<sup><strong>*</strong></sup> `@` isn't a RegEx character.
+
+Powered by [extglob](https://github.com/jonschlinkert/extglob). Visit that library for the full range of options or to report extglob related issues.
+
+See [extglob](https://github.com/jonschlinkert/extglob) for more information about extended globs.
+
+#### brace expansion
+
+In simple cases, brace expansion appears to work the same way as the logical `OR` operator. For example, `(a|b)` will achieve the same result as `{a,b}`.
+
+Here are some powerful features unique to brace expansion (versus character classes):
+
+* range expansion: `a{1..3}b/*.js` expands to: `['a1b/*.js', 'a2b/*.js', 'a3b/*.js']`
+* nesting: `a{c,{d,e}}b/*.js` expands to: `['acb/*.js', 'adb/*.js', 'aeb/*.js']`
+
+Visit [braces](https://github.com/jonschlinkert/braces) to ask questions and create an issue related to brace-expansion, or to see the full range of features and options related to brace expansion.
+
+#### regex character classes
+
+With the exception of brace expansion (`{a,b}`, `{1..5}`, etc), most of the special characters convert directly to regex, so you can expect them to follow the same rules and produce the same results as regex.
+
+For example, given the list: `['a.js', 'b.js', 'c.js', 'd.js', 'E.js']`:
+
+* `[ac].js`: matches both `a` and `c`, returning `['a.js', 'c.js']`
+* `[b-d].js`: matches from `b` to `d`, returning `['b.js', 'c.js', 'd.js']`
+* `[b-d].js`: matches from `b` to `d`, returning `['b.js', 'c.js', 'd.js']`
+* `a/[A-Z].js`: matches and uppercase letter, returning `['a/E.md']`
+
+Learn about [regex character classes](http://www.regular-expressions.info/charclass.html).
+
+#### regex groups
+
+Given `['a.js', 'b.js', 'c.js', 'd.js', 'E.js']`:
+
+* `(a|c).js`: would match either `a` or `c`, returning `['a.js', 'c.js']`
+* `(b|d).js`: would match either `b` or `d`, returning `['b.js', 'd.js']`
+* `(b|[A-Z]).js`: would match either `b` or an uppercase letter, returning `['b.js', 'E.js']`
+
+As with regex, parenthese can be nested, so patterns like `((a|b)|c)/b` will work. But it might be easier to achieve your goal using brace expansion.
+
+#### POSIX bracket expressions
+
+**Example**
+
+```js
+mm.isMatch('a1', '[[:alpha:][:digit:]]');
+//=> true
+```
+
+See [expand-brackets](https://github.com/jonschlinkert/expand-brackets) for more information about extended bracket expressions.
+
+***
+
+## Notes
+
+Whenever possible parsing behavior for patterns is based on globbing specifications in Bash 4.3. Patterns that aren't described by Bash follow wildmatch spec (used by git).
+
+## Benchmarks
+
+Run the [benchmarks](./benchmark):
+
+```bash
+node benchmark
+```
+
+As of July 15, 2016:
+
+```bash
+#1: basename-braces
+  micromatch x 26,420 ops/sec ±0.89% (91 runs sampled)
+  minimatch x 3,507 ops/sec ±0.64% (97 runs sampled)
+
+#2: basename
+  micromatch x 25,315 ops/sec ±0.82% (93 runs sampled)
+  minimatch x 4,398 ops/sec ±0.86% (94 runs sampled)
+
+#3: braces-no-glob
+  micromatch x 341,254 ops/sec ±0.78% (93 runs sampled)
+  minimatch x 30,197 ops/sec ±1.12% (91 runs sampled)
+
+#4: braces
+  micromatch x 54,649 ops/sec ±0.74% (94 runs sampled)
+  minimatch x 3,095 ops/sec ±0.82% (95 runs sampled)
+
+#5: immediate
+  micromatch x 16,719 ops/sec ±0.79% (95 runs sampled)
+  minimatch x 4,348 ops/sec ±0.86% (96 runs sampled)
+
+#6: large
+  micromatch x 721 ops/sec ±0.77% (94 runs sampled)
+  minimatch x 17.73 ops/sec ±1.08% (50 runs sampled)
+
+#7: long
+  micromatch x 5,051 ops/sec ±0.87% (97 runs sampled)
+  minimatch x 628 ops/sec ±0.83% (94 runs sampled)
+
+#8: mid
+  micromatch x 51,280 ops/sec ±0.80% (95 runs sampled)
+  minimatch x 1,923 ops/sec ±0.84% (95 runs sampled)
+
+#9: multi-patterns
+  micromatch x 22,440 ops/sec ±0.97% (94 runs sampled)
+  minimatch x 2,481 ops/sec ±1.10% (94 runs sampled)
+
+#10: no-glob
+  micromatch x 722,823 ops/sec ±1.30% (87 runs sampled)
+  minimatch x 52,967 ops/sec ±1.09% (94 runs sampled)
+
+#11: range
+  micromatch x 243,471 ops/sec ±0.79% (94 runs sampled)
+  minimatch x 11,736 ops/sec ±0.82% (96 runs sampled)
+
+#12: shallow
+  micromatch x 190,874 ops/sec ±0.98% (95 runs sampled)
+  minimatch x 21,699 ops/sec ±0.81% (97 runs sampled)
+
+#13: short
+  micromatch x 496,393 ops/sec ±3.86% (90 runs sampled)
+  minimatch x 53,765 ops/sec ±0.75% (95 runs sampled)
+```
+
+## Tests
+
+### Running tests
+
+Install dev dependencies:
+
+```sh
+$ npm install -d && npm test
+```
+
+### Coverage
+
+As of July 15, 2016:
+
+```sh
+Statements : 100% (441/441)
+Branches   : 100% (270/270)
+Functions  : 100% (54/54)
+Lines      : 100% (429/429)
+```
+
+## Contributing
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
+
+Please be sure to run the benchmarks before/after any code changes to judge the impact before you do a PR. thanks!
+
+## Related
+
+* [braces](https://www.npmjs.com/package/braces): Fastest brace expansion for node.js, with the most complete support for the Bash 4.3 braces… [more](https://github.com/jonschlinkert/braces) | [homepage](https://github.com/jonschlinkert/braces "Fastest brace expansion for node.js, with the most complete support for the Bash 4.3 braces specification.")
+* [expand-brackets](https://www.npmjs.com/package/expand-brackets): Expand POSIX bracket expressions (character classes) in glob patterns. | [homepage](https://github.com/jonschlinkert/expand-brackets "Expand POSIX bracket expressions (character classes) in glob patterns.")
+* [expand-range](https://www.npmjs.com/package/expand-range): Fast, bash-like range expansion. Expand a range of numbers or letters, uppercase or lowercase. See… [more](https://github.com/jonschlinkert/expand-range) | [homepage](https://github.com/jonschlinkert/expand-range "Fast, bash-like range expansion. Expand a range of numbers or letters, uppercase or lowercase. See the benchmarks. Used by micromatch.")
+* [extglob](https://www.npmjs.com/package/extglob): Convert extended globs to regex-compatible strings. Add (almost) the expressive power of regular expressions to… [more](https://github.com/jonschlinkert/extglob) | [homepage](https://github.com/jonschlinkert/extglob "Convert extended globs to regex-compatible strings. Add (almost) the expressive power of regular expressions to glob patterns.")
+* [fill-range](https://www.npmjs.com/package/fill-range): Fill in a range of numbers or letters, optionally passing an increment or multiplier to… [more](https://github.com/jonschlinkert/fill-range) | [homepage](https://github.com/jonschlinkert/fill-range "Fill in a range of numbers or letters, optionally passing an increment or multiplier to use.")
+* [gulp-micromatch](https://www.npmjs.com/package/gulp-micromatch): Filter vinyl files with glob patterns, string, regexp, array, object or matcher function. micromatch stream. | [homepage](https://github.com/tunnckocore/gulp-micromatch#readme "Filter vinyl files with glob patterns, string, regexp, array, object or matcher function. micromatch stream.")
+* [is-glob](https://www.npmjs.com/package/is-glob): Returns `true` if the given string looks like a glob pattern or an extglob pattern… [more](https://github.com/jonschlinkert/is-glob) | [homepage](https://github.com/jonschlinkert/is-glob "Returns `true` if the given string looks like a glob pattern or an extglob pattern. This makes it easy to create code that only uses external modules like node-glob when necessary, resulting in much faster code execution and initialization time, and a bet")
+* [parse-glob](https://www.npmjs.com/package/parse-glob): Parse a glob pattern into an object of tokens. | [homepage](https://github.com/jonschlinkert/parse-glob "Parse a glob pattern into an object of tokens.")
+
+## Contributing
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
+
+## Building docs
+
+_(This document was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme) (a [verb](https://github.com/verbose/verb) generator), please don't edit the readme directly. Any changes to the readme must be made in [.verb.md](.verb.md).)_
+
+To generate the readme and API documentation with [verb](https://github.com/verbose/verb):
+
+```sh
+$ npm install -g verb verb-generate-readme && verb
+```
+
+## Running tests
+
+Install dev dependencies:
+
+```sh
+$ npm install -d && npm test
+```
+
+## Author
+
+**Jon Schlinkert**
+
+* [github/jonschlinkert](https://github.com/jonschlinkert)
+* [twitter/jonschlinkert](http://twitter.com/jonschlinkert)
+
+## License
+
+Copyright © 2016, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT license](https://github.com/jonschlinkert/micromatch/blob/master/LICENSE).
+
+***
+
+_This file was generated by [verb](https://github.com/verbose/verb), v0.9.0, on July 15, 2016._
\ No newline at end of file
diff --git a/node_modules/@babel/core/node_modules/micromatch/index.js b/node_modules/@babel/core/node_modules/micromatch/index.js
new file mode 100755
index 00000000..f898ec17
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/micromatch/index.js
@@ -0,0 +1,431 @@
+/*!
+ * micromatch <https://github.com/jonschlinkert/micromatch>
+ *
+ * Copyright (c) 2014-2015, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+'use strict';
+
+var expand = require('./lib/expand');
+var utils = require('./lib/utils');
+
+/**
+ * The main function. Pass an array of filepaths,
+ * and a string or array of glob patterns
+ *
+ * @param  {Array|String} `files`
+ * @param  {Array|String} `patterns`
+ * @param  {Object} `opts`
+ * @return {Array} Array of matches
+ */
+
+function micromatch(files, patterns, opts) {
+  if (!files || !patterns) return [];
+  opts = opts || {};
+
+  if (typeof opts.cache === 'undefined') {
+    opts.cache = true;
+  }
+
+  if (!Array.isArray(patterns)) {
+    return match(files, patterns, opts);
+  }
+
+  var len = patterns.length, i = 0;
+  var omit = [], keep = [];
+
+  while (len--) {
+    var glob = patterns[i++];
+    if (typeof glob === 'string' && glob.charCodeAt(0) === 33 /* ! */) {
+      omit.push.apply(omit, match(files, glob.slice(1), opts));
+    } else {
+      keep.push.apply(keep, match(files, glob, opts));
+    }
+  }
+  return utils.diff(keep, omit);
+}
+
+/**
+ * Return an array of files that match the given glob pattern.
+ *
+ * This function is called by the main `micromatch` function If you only
+ * need to pass a single pattern you might get very minor speed improvements
+ * using this function.
+ *
+ * @param  {Array} `files`
+ * @param  {String} `pattern`
+ * @param  {Object} `options`
+ * @return {Array}
+ */
+
+function match(files, pattern, opts) {
+  if (utils.typeOf(files) !== 'string' && !Array.isArray(files)) {
+    throw new Error(msg('match', 'files', 'a string or array'));
+  }
+
+  files = utils.arrayify(files);
+  opts = opts || {};
+
+  var negate = opts.negate || false;
+  var orig = pattern;
+
+  if (typeof pattern === 'string') {
+    negate = pattern.charAt(0) === '!';
+    if (negate) {
+      pattern = pattern.slice(1);
+    }
+
+    // we need to remove the character regardless,
+    // so the above logic is still needed
+    if (opts.nonegate === true) {
+      negate = false;
+    }
+  }
+
+  var _isMatch = matcher(pattern, opts);
+  var len = files.length, i = 0;
+  var res = [];
+
+  while (i < len) {
+    var file = files[i++];
+    var fp = utils.unixify(file, opts);
+
+    if (!_isMatch(fp)) { continue; }
+    res.push(fp);
+  }
+
+  if (res.length === 0) {
+    if (opts.failglob === true) {
+      throw new Error('micromatch.match() found no matches for: "' + orig + '".');
+    }
+
+    if (opts.nonull || opts.nullglob) {
+      res.push(utils.unescapeGlob(orig));
+    }
+  }
+
+  // if `negate` was defined, diff negated files
+  if (negate) { res = utils.diff(files, res); }
+
+  // if `ignore` was defined, diff ignored filed
+  if (opts.ignore && opts.ignore.length) {
+    pattern = opts.ignore;
+    opts = utils.omit(opts, ['ignore']);
+    res = utils.diff(res, micromatch(res, pattern, opts));
+  }
+
+  if (opts.nodupes) {
+    return utils.unique(res);
+  }
+  return res;
+}
+
+/**
+ * Returns a function that takes a glob pattern or array of glob patterns
+ * to be used with `Array#filter()`. (Internally this function generates
+ * the matching function using the [matcher] method).
+ *
+ * ```js
+ * var fn = mm.filter('[a-c]');
+ * ['a', 'b', 'c', 'd', 'e'].filter(fn);
+ * //=> ['a', 'b', 'c']
+ * ```
+ * @param  {String|Array} `patterns` Can be a glob or array of globs.
+ * @param  {Options} `opts` Options to pass to the [matcher] method.
+ * @return {Function} Filter function to be passed to `Array#filter()`.
+ */
+
+function filter(patterns, opts) {
+  if (!Array.isArray(patterns) && typeof patterns !== 'string') {
+    throw new TypeError(msg('filter', 'patterns', 'a string or array'));
+  }
+
+  patterns = utils.arrayify(patterns);
+  var len = patterns.length, i = 0;
+  var patternMatchers = Array(len);
+  while (i < len) {
+    patternMatchers[i] = matcher(patterns[i++], opts);
+  }
+
+  return function(fp) {
+    if (fp == null) return [];
+    var len = patternMatchers.length, i = 0;
+    var res = true;
+
+    fp = utils.unixify(fp, opts);
+    while (i < len) {
+      var fn = patternMatchers[i++];
+      if (!fn(fp)) {
+        res = false;
+        break;
+      }
+    }
+    return res;
+  };
+}
+
+/**
+ * Returns true if the filepath contains the given
+ * pattern. Can also return a function for matching.
+ *
+ * ```js
+ * isMatch('foo.md', '*.md', {});
+ * //=> true
+ *
+ * isMatch('*.md', {})('foo.md')
+ * //=> true
+ * ```
+ * @param  {String} `fp`
+ * @param  {String} `pattern`
+ * @param  {Object} `opts`
+ * @return {Boolean}
+ */
+
+function isMatch(fp, pattern, opts) {
+  if (typeof fp !== 'string') {
+    throw new TypeError(msg('isMatch', 'filepath', 'a string'));
+  }
+
+  fp = utils.unixify(fp, opts);
+  if (utils.typeOf(pattern) === 'object') {
+    return matcher(fp, pattern);
+  }
+  return matcher(pattern, opts)(fp);
+}
+
+/**
+ * Returns true if the filepath matches the
+ * given pattern.
+ */
+
+function contains(fp, pattern, opts) {
+  if (typeof fp !== 'string') {
+    throw new TypeError(msg('contains', 'pattern', 'a string'));
+  }
+
+  opts = opts || {};
+  opts.contains = (pattern !== '');
+  fp = utils.unixify(fp, opts);
+
+  if (opts.contains && !utils.isGlob(pattern)) {
+    return fp.indexOf(pattern) !== -1;
+  }
+  return matcher(pattern, opts)(fp);
+}
+
+/**
+ * Returns true if a file path matches any of the
+ * given patterns.
+ *
+ * @param  {String} `fp` The filepath to test.
+ * @param  {String|Array} `patterns` Glob patterns to use.
+ * @param  {Object} `opts` Options to pass to the `matcher()` function.
+ * @return {String}
+ */
+
+function any(fp, patterns, opts) {
+  if (!Array.isArray(patterns) && typeof patterns !== 'string') {
+    throw new TypeError(msg('any', 'patterns', 'a string or array'));
+  }
+
+  patterns = utils.arrayify(patterns);
+  var len = patterns.length;
+
+  fp = utils.unixify(fp, opts);
+  while (len--) {
+    var isMatch = matcher(patterns[len], opts);
+    if (isMatch(fp)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Filter the keys of an object with the given `glob` pattern
+ * and `options`
+ *
+ * @param  {Object} `object`
+ * @param  {Pattern} `object`
+ * @return {Array}
+ */
+
+function matchKeys(obj, glob, options) {
+  if (utils.typeOf(obj) !== 'object') {
+    throw new TypeError(msg('matchKeys', 'first argument', 'an object'));
+  }
+
+  var fn = matcher(glob, options);
+  var res = {};
+
+  for (var key in obj) {
+    if (obj.hasOwnProperty(key) && fn(key)) {
+      res[key] = obj[key];
+    }
+  }
+  return res;
+}
+
+/**
+ * Return a function for matching based on the
+ * given `pattern` and `options`.
+ *
+ * @param  {String} `pattern`
+ * @param  {Object} `options`
+ * @return {Function}
+ */
+
+function matcher(pattern, opts) {
+  // pattern is a function
+  if (typeof pattern === 'function') {
+    return pattern;
+  }
+  // pattern is a regex
+  if (pattern instanceof RegExp) {
+    return function(fp) {
+      return pattern.test(fp);
+    };
+  }
+
+  if (typeof pattern !== 'string') {
+    throw new TypeError(msg('matcher', 'pattern', 'a string, regex, or function'));
+  }
+
+  // strings, all the way down...
+  pattern = utils.unixify(pattern, opts);
+
+  // pattern is a non-glob string
+  if (!utils.isGlob(pattern)) {
+    return utils.matchPath(pattern, opts);
+  }
+  // pattern is a glob string
+  var re = makeRe(pattern, opts);
+
+  // `matchBase` is defined
+  if (opts && opts.matchBase) {
+    return utils.hasFilename(re, opts);
+  }
+  // `matchBase` is not defined
+  return function(fp) {
+    fp = utils.unixify(fp, opts);
+    return re.test(fp);
+  };
+}
+
+/**
+ * Create and cache a regular expression for matching
+ * file paths.
+ *
+ * If the leading character in the `glob` is `!`, a negation
+ * regex is returned.
+ *
+ * @param  {String} `glob`
+ * @param  {Object} `options`
+ * @return {RegExp}
+ */
+
+function toRegex(glob, options) {
+  // clone options to prevent  mutating the original object
+  var opts = Object.create(options || {});
+  var flags = opts.flags || '';
+  if (opts.nocase && flags.indexOf('i') === -1) {
+    flags += 'i';
+  }
+
+  var parsed = expand(glob, opts);
+
+  // pass in tokens to avoid parsing more than once
+  opts.negated = opts.negated || parsed.negated;
+  opts.negate = opts.negated;
+  glob = wrapGlob(parsed.pattern, opts);
+  var re;
+
+  try {
+    re = new RegExp(glob, flags);
+    return re;
+  } catch (err) {
+    err.reason = 'micromatch invalid regex: (' + re + ')';
+    if (opts.strict) throw new SyntaxError(err);
+  }
+
+  // we're only here if a bad pattern was used and the user
+  // passed `options.silent`, so match nothing
+  return /$^/;
+}
+
+/**
+ * Create the regex to do the matching. If the leading
+ * character in the `glob` is `!` a negation regex is returned.
+ *
+ * @param {String} `glob`
+ * @param {Boolean} `negate`
+ */
+
+function wrapGlob(glob, opts) {
+  var prefix = (opts && !opts.contains) ? '^' : '';
+  var after = (opts && !opts.contains) ? '$' : '';
+  glob = ('(?:' + glob + ')' + after);
+  if (opts && opts.negate) {
+    return prefix + ('(?!^' + glob + ').*$');
+  }
+  return prefix + glob;
+}
+
+/**
+ * Create and cache a regular expression for matching file paths.
+ * If the leading character in the `glob` is `!`, a negation
+ * regex is returned.
+ *
+ * @param  {String} `glob`
+ * @param  {Object} `options`
+ * @return {RegExp}
+ */
+
+function makeRe(glob, opts) {
+  if (utils.typeOf(glob) !== 'string') {
+    throw new Error(msg('makeRe', 'glob', 'a string'));
+  }
+  return utils.cache(toRegex, glob, opts);
+}
+
+/**
+ * Make error messages consistent. Follows this format:
+ *
+ * ```js
+ * msg(methodName, argNumber, nativeType);
+ * // example:
+ * msg('matchKeys', 'first', 'an object');
+ * ```
+ *
+ * @param  {String} `method`
+ * @param  {String} `num`
+ * @param  {String} `type`
+ * @return {String}
+ */
+
+function msg(method, what, type) {
+  return 'micromatch.' + method + '(): ' + what + ' should be ' + type + '.';
+}
+
+/**
+ * Public methods
+ */
+
+/* eslint no-multi-spaces: 0 */
+micromatch.any       = any;
+micromatch.braces    = micromatch.braceExpand = utils.braces;
+micromatch.contains  = contains;
+micromatch.expand    = expand;
+micromatch.filter    = filter;
+micromatch.isMatch   = isMatch;
+micromatch.makeRe    = makeRe;
+micromatch.match     = match;
+micromatch.matcher   = matcher;
+micromatch.matchKeys = matchKeys;
+
+/**
+ * Expose `micromatch`
+ */
+
+module.exports = micromatch;
diff --git a/node_modules/@babel/core/node_modules/micromatch/lib/chars.js b/node_modules/@babel/core/node_modules/micromatch/lib/chars.js
new file mode 100644
index 00000000..a1ffe371
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/micromatch/lib/chars.js
@@ -0,0 +1,67 @@
+'use strict';
+
+var chars = {}, unesc, temp;
+
+function reverse(object, prepender) {
+  return Object.keys(object).reduce(function(reversed, key) {
+    var newKey = prepender ? prepender + key : key; // Optionally prepend a string to key.
+    reversed[object[key]] = newKey; // Swap key and value.
+    return reversed; // Return the result.
+  }, {});
+}
+
+/**
+ * Regex for common characters
+ */
+
+chars.escapeRegex = {
+  '?': /\?/g,
+  '@': /\@/g,
+  '!': /\!/g,
+  '+': /\+/g,
+  '*': /\*/g,
+  '(': /\(/g,
+  ')': /\)/g,
+  '[': /\[/g,
+  ']': /\]/g
+};
+
+/**
+ * Escape characters
+ */
+
+chars.ESC = {
+  '?': '__UNESC_QMRK__',
+  '@': '__UNESC_AMPE__',
+  '!': '__UNESC_EXCL__',
+  '+': '__UNESC_PLUS__',
+  '*': '__UNESC_STAR__',
+  ',': '__UNESC_COMMA__',
+  '(': '__UNESC_LTPAREN__',
+  ')': '__UNESC_RTPAREN__',
+  '[': '__UNESC_LTBRACK__',
+  ']': '__UNESC_RTBRACK__'
+};
+
+/**
+ * Unescape characters
+ */
+
+chars.UNESC = unesc || (unesc = reverse(chars.ESC, '\\'));
+
+chars.ESC_TEMP = {
+  '?': '__TEMP_QMRK__',
+  '@': '__TEMP_AMPE__',
+  '!': '__TEMP_EXCL__',
+  '*': '__TEMP_STAR__',
+  '+': '__TEMP_PLUS__',
+  ',': '__TEMP_COMMA__',
+  '(': '__TEMP_LTPAREN__',
+  ')': '__TEMP_RTPAREN__',
+  '[': '__TEMP_LTBRACK__',
+  ']': '__TEMP_RTBRACK__'
+};
+
+chars.TEMP = temp || (temp = reverse(chars.ESC_TEMP));
+
+module.exports = chars;
diff --git a/node_modules/@babel/core/node_modules/micromatch/lib/expand.js b/node_modules/@babel/core/node_modules/micromatch/lib/expand.js
new file mode 100644
index 00000000..e99b081e
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/micromatch/lib/expand.js
@@ -0,0 +1,304 @@
+/*!
+ * micromatch <https://github.com/jonschlinkert/micromatch>
+ *
+ * Copyright (c) 2014-2015, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+'use strict';
+
+var utils = require('./utils');
+var Glob = require('./glob');
+
+/**
+ * Expose `expand`
+ */
+
+module.exports = expand;
+
+/**
+ * Expand a glob pattern to resolve braces and
+ * similar patterns before converting to regex.
+ *
+ * @param  {String|Array} `pattern`
+ * @param  {Array} `files`
+ * @param  {Options} `opts`
+ * @return {Array}
+ */
+
+function expand(pattern, options) {
+  if (typeof pattern !== 'string') {
+    throw new TypeError('micromatch.expand(): argument should be a string.');
+  }
+
+  var glob = new Glob(pattern, options || {});
+  var opts = glob.options;
+
+  if (!utils.isGlob(pattern)) {
+    glob.pattern = glob.pattern.replace(/([\/.])/g, '\\$1');
+    return glob;
+  }
+
+  glob.pattern = glob.pattern.replace(/(\+)(?!\()/g, '\\$1');
+  glob.pattern = glob.pattern.split('$').join('\\$');
+
+  if (typeof opts.braces !== 'boolean' && typeof opts.nobraces !== 'boolean') {
+    opts.braces = true;
+  }
+
+  if (glob.pattern === '.*') {
+    return {
+      pattern: '\\.' + star,
+      tokens: tok,
+      options: opts
+    };
+  }
+
+  if (glob.pattern === '*') {
+    return {
+      pattern: oneStar(opts.dot),
+      tokens: tok,
+      options: opts
+    };
+  }
+
+  // parse the glob pattern into tokens
+  glob.parse();
+  var tok = glob.tokens;
+  tok.is.negated = opts.negated;
+
+  // dotfile handling
+  if ((opts.dotfiles === true || tok.is.dotfile) && opts.dot !== false) {
+    opts.dotfiles = true;
+    opts.dot = true;
+  }
+
+  if ((opts.dotdirs === true || tok.is.dotdir) && opts.dot !== false) {
+    opts.dotdirs = true;
+    opts.dot = true;
+  }
+
+  // check for braces with a dotfile pattern
+  if (/[{,]\./.test(glob.pattern)) {
+    opts.makeRe = false;
+    opts.dot = true;
+  }
+
+  if (opts.nonegate !== true) {
+    opts.negated = glob.negated;
+  }
+
+  // if the leading character is a dot or a slash, escape it
+  if (glob.pattern.charAt(0) === '.' && glob.pattern.charAt(1) !== '/') {
+    glob.pattern = '\\' + glob.pattern;
+  }
+
+  /**
+   * Extended globs
+   */
+
+  // expand braces, e.g `{1..5}`
+  glob.track('before braces');
+  if (tok.is.braces) {
+    glob.braces();
+  }
+  glob.track('after braces');
+
+  // expand extglobs, e.g `foo/!(a|b)`
+  glob.track('before extglob');
+  if (tok.is.extglob) {
+    glob.extglob();
+  }
+  glob.track('after extglob');
+
+  // expand brackets, e.g `[[:alpha:]]`
+  glob.track('before brackets');
+  if (tok.is.brackets) {
+    glob.brackets();
+  }
+  glob.track('after brackets');
+
+  // special patterns
+  glob._replace('[!', '[^');
+  glob._replace('(?', '(%~');
+  glob._replace(/\[\]/, '\\[\\]');
+  glob._replace('/[', '/' + (opts.dot ? dotfiles : nodot) + '[', true);
+  glob._replace('/?', '/' + (opts.dot ? dotfiles : nodot) + '[^/]', true);
+  glob._replace('/.', '/(?=.)\\.', true);
+
+  // windows drives
+  glob._replace(/^(\w):([\\\/]+?)/gi, '(?=.)$1:$2', true);
+
+  // negate slashes in exclusion ranges
+  if (glob.pattern.indexOf('[^') !== -1) {
+    glob.pattern = negateSlash(glob.pattern);
+  }
+
+  if (opts.globstar !== false && glob.pattern === '**') {
+    glob.pattern = globstar(opts.dot);
+
+  } else {
+    glob.pattern = balance(glob.pattern, '[', ']');
+    glob.escape(glob.pattern);
+
+    // if the pattern has `**`
+    if (tok.is.globstar) {
+      glob.pattern = collapse(glob.pattern, '/**');
+      glob.pattern = collapse(glob.pattern, '**/');
+      glob._replace('/**/', '(?:/' + globstar(opts.dot) + '/|/)', true);
+      glob._replace(/\*{2,}/g, '**');
+
+      // 'foo/*'
+      glob._replace(/(\w+)\*(?!\/)/g, '$1[^/]*?', true);
+      glob._replace(/\*\*\/\*(\w)/g, globstar(opts.dot) + '\\/' + (opts.dot ? dotfiles : nodot) + '[^/]*?$1', true);
+
+      if (opts.dot !== true) {
+        glob._replace(/\*\*\/(.)/g, '(?:**\\/|)$1');
+      }
+
+      // 'foo/**' or '{**,*}', but not 'foo**'
+      if (tok.path.dirname !== '' || /,\*\*|\*\*,/.test(glob.orig)) {
+        glob._replace('**', globstar(opts.dot), true);
+      }
+    }
+
+    // ends with /*
+    glob._replace(/\/\*$/, '\\/' + oneStar(opts.dot), true);
+    // ends with *, no slashes
+    glob._replace(/(?!\/)\*$/, star, true);
+    // has 'n*.' (partial wildcard w/ file extension)
+    glob._replace(/([^\/]+)\*/, '$1' + oneStar(true), true);
+    // has '*'
+    glob._replace('*', oneStar(opts.dot), true);
+    glob._replace('?.', '?\\.', true);
+    glob._replace('?:', '?:', true);
+
+    glob._replace(/\?+/g, function(match) {
+      var len = match.length;
+      if (len === 1) {
+        return qmark;
+      }
+      return qmark + '{' + len + '}';
+    });
+
+    // escape '.abc' => '\\.abc'
+    glob._replace(/\.([*\w]+)/g, '\\.$1');
+    // fix '[^\\\\/]'
+    glob._replace(/\[\^[\\\/]+\]/g, qmark);
+    // '///' => '\/'
+    glob._replace(/\/+/g, '\\/');
+    // '\\\\\\' => '\\'
+    glob._replace(/\\{2,}/g, '\\');
+  }
+
+  // unescape previously escaped patterns
+  glob.unescape(glob.pattern);
+  glob._replace('__UNESC_STAR__', '*');
+
+  // escape dots that follow qmarks
+  glob._replace('?.', '?\\.');
+
+  // remove unnecessary slashes in character classes
+  glob._replace('[^\\/]', qmark);
+
+  if (glob.pattern.length > 1) {
+    if (/^[\[?*]/.test(glob.pattern)) {
+      // only prepend the string if we don't want to match dotfiles
+      glob.pattern = (opts.dot ? dotfiles : nodot) + glob.pattern;
+    }
+  }
+
+  return glob;
+}
+
+/**
+ * Collapse repeated character sequences.
+ *
+ * ```js
+ * collapse('a/../../../b', '../');
+ * //=> 'a/../b'
+ * ```
+ *
+ * @param  {String} `str`
+ * @param  {String} `ch` Character sequence to collapse
+ * @return {String}
+ */
+
+function collapse(str, ch) {
+  var res = str.split(ch);
+  var isFirst = res[0] === '';
+  var isLast = res[res.length - 1] === '';
+  res = res.filter(Boolean);
+  if (isFirst) res.unshift('');
+  if (isLast) res.push('');
+  return res.join(ch);
+}
+
+/**
+ * Negate slashes in exclusion ranges, per glob spec:
+ *
+ * ```js
+ * negateSlash('[^foo]');
+ * //=> '[^\\/foo]'
+ * ```
+ *
+ * @param  {String} `str` glob pattern
+ * @return {String}
+ */
+
+function negateSlash(str) {
+  return str.replace(/\[\^([^\]]*?)\]/g, function(match, inner) {
+    if (inner.indexOf('/') === -1) {
+      inner = '\\/' + inner;
+    }
+    return '[^' + inner + ']';
+  });
+}
+
+/**
+ * Escape imbalanced braces/bracket. This is a very
+ * basic, naive implementation that only does enough
+ * to serve the purpose.
+ */
+
+function balance(str, a, b) {
+  var aarr = str.split(a);
+  var alen = aarr.join('').length;
+  var blen = str.split(b).join('').length;
+
+  if (alen !== blen) {
+    str = aarr.join('\\' + a);
+    return str.split(b).join('\\' + b);
+  }
+  return str;
+}
+
+/**
+ * Special patterns to be converted to regex.
+ * Heuristics are used to simplify patterns
+ * and speed up processing.
+ */
+
+/* eslint no-multi-spaces: 0 */
+var qmark       = '[^/]';
+var star        = qmark + '*?';
+var nodot       = '(?!\\.)(?=.)';
+var dotfileGlob = '(?:\\/|^)\\.{1,2}($|\\/)';
+var dotfiles    = '(?!' + dotfileGlob + ')(?=.)';
+var twoStarDot  = '(?:(?!' + dotfileGlob + ').)*?';
+
+/**
+ * Create a regex for `*`.
+ *
+ * If `dot` is true, or the pattern does not begin with
+ * a leading star, then return the simpler regex.
+ */
+
+function oneStar(dotfile) {
+  return dotfile ? '(?!' + dotfileGlob + ')(?=.)' + star : (nodot + star);
+}
+
+function globstar(dotfile) {
+  if (dotfile) { return twoStarDot; }
+  return '(?:(?!(?:\\/|^)\\.).)*?';
+}
diff --git a/node_modules/@babel/core/node_modules/micromatch/lib/glob.js b/node_modules/@babel/core/node_modules/micromatch/lib/glob.js
new file mode 100644
index 00000000..c6133267
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/micromatch/lib/glob.js
@@ -0,0 +1,193 @@
+'use strict';
+
+var chars = require('./chars');
+var utils = require('./utils');
+
+/**
+ * Expose `Glob`
+ */
+
+var Glob = module.exports = function Glob(pattern, options) {
+  if (!(this instanceof Glob)) {
+    return new Glob(pattern, options);
+  }
+  this.options = options || {};
+  this.pattern = pattern;
+  this.history = [];
+  this.tokens = {};
+  this.init(pattern);
+};
+
+/**
+ * Initialize defaults
+ */
+
+Glob.prototype.init = function(pattern) {
+  this.orig = pattern;
+  this.negated = this.isNegated();
+  this.options.track = this.options.track || false;
+  this.options.makeRe = true;
+};
+
+/**
+ * Push a change into `glob.history`. Useful
+ * for debugging.
+ */
+
+Glob.prototype.track = function(msg) {
+  if (this.options.track) {
+    this.history.push({msg: msg, pattern: this.pattern});
+  }
+};
+
+/**
+ * Return true if `glob.pattern` was negated
+ * with `!`, also remove the `!` from the pattern.
+ *
+ * @return {Boolean}
+ */
+
+Glob.prototype.isNegated = function() {
+  if (this.pattern.charCodeAt(0) === 33 /* '!' */) {
+    this.pattern = this.pattern.slice(1);
+    return true;
+  }
+  return false;
+};
+
+/**
+ * Expand braces in the given glob pattern.
+ *
+ * We only need to use the [braces] lib when
+ * patterns are nested.
+ */
+
+Glob.prototype.braces = function() {
+  if (this.options.nobraces !== true && this.options.nobrace !== true) {
+    // naive/fast check for imbalanced characters
+    var a = this.pattern.match(/[\{\(\[]/g);
+    var b = this.pattern.match(/[\}\)\]]/g);
+
+    // if imbalanced, don't optimize the pattern
+    if (a && b && (a.length !== b.length)) {
+      this.options.makeRe = false;
+    }
+
+    // expand brace patterns and join the resulting array
+    var expanded = utils.braces(this.pattern, this.options);
+    this.pattern = expanded.join('|');
+  }
+};
+
+/**
+ * Expand bracket expressions in `glob.pattern`
+ */
+
+Glob.prototype.brackets = function() {
+  if (this.options.nobrackets !== true) {
+    this.pattern = utils.brackets(this.pattern);
+  }
+};
+
+/**
+ * Expand bracket expressions in `glob.pattern`
+ */
+
+Glob.prototype.extglob = function() {
+  if (this.options.noextglob === true) return;
+
+  if (utils.isExtglob(this.pattern)) {
+    this.pattern = utils.extglob(this.pattern, {escape: true});
+  }
+};
+
+/**
+ * Parse the given pattern
+ */
+
+Glob.prototype.parse = function(pattern) {
+  this.tokens = utils.parseGlob(pattern || this.pattern, true);
+  return this.tokens;
+};
+
+/**
+ * Replace `a` with `b`. Also tracks the change before and
+ * after each replacement. This is disabled by default, but
+ * can be enabled by setting `options.track` to true.
+ *
+ * Also, when the pattern is a string, `.split()` is used,
+ * because it's much faster than replace.
+ *
+ * @param  {RegExp|String} `a`
+ * @param  {String} `b`
+ * @param  {Boolean} `escape` When `true`, escapes `*` and `?` in the replacement.
+ * @return {String}
+ */
+
+Glob.prototype._replace = function(a, b, escape) {
+  this.track('before (find): "' + a + '" (replace with): "' + b + '"');
+  if (escape) b = esc(b);
+  if (a && b && typeof a === 'string') {
+    this.pattern = this.pattern.split(a).join(b);
+  } else {
+    this.pattern = this.pattern.replace(a, b);
+  }
+  this.track('after');
+};
+
+/**
+ * Escape special characters in the given string.
+ *
+ * @param  {String} `str` Glob pattern
+ * @return {String}
+ */
+
+Glob.prototype.escape = function(str) {
+  this.track('before escape: ');
+  var re = /["\\](['"]?[^"'\\]['"]?)/g;
+
+  this.pattern = str.replace(re, function($0, $1) {
+    var o = chars.ESC;
+    var ch = o && o[$1];
+    if (ch) {
+      return ch;
+    }
+    if (/[a-z]/i.test($0)) {
+      return $0.split('\\').join('');
+    }
+    return $0;
+  });
+
+  this.track('after escape: ');
+};
+
+/**
+ * Unescape special characters in the given string.
+ *
+ * @param  {String} `str`
+ * @return {String}
+ */
+
+Glob.prototype.unescape = function(str) {
+  var re = /__([A-Z]+)_([A-Z]+)__/g;
+  this.pattern = str.replace(re, function($0, $1) {
+    return chars[$1][$0];
+  });
+  this.pattern = unesc(this.pattern);
+};
+
+/**
+ * Escape/unescape utils
+ */
+
+function esc(str) {
+  str = str.split('?').join('%~');
+  str = str.split('*').join('%%');
+  return str;
+}
+
+function unesc(str) {
+  str = str.split('%~').join('?');
+  str = str.split('%%').join('*');
+  return str;
+}
diff --git a/node_modules/@babel/core/node_modules/micromatch/lib/utils.js b/node_modules/@babel/core/node_modules/micromatch/lib/utils.js
new file mode 100644
index 00000000..7c24a510
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/micromatch/lib/utils.js
@@ -0,0 +1,149 @@
+'use strict';
+
+var win32 = process && process.platform === 'win32';
+var path = require('path');
+var fileRe = require('filename-regex');
+var utils = module.exports;
+
+/**
+ * Module dependencies
+ */
+
+utils.diff = require('arr-diff');
+utils.unique = require('array-unique');
+utils.braces = require('braces');
+utils.brackets = require('expand-brackets');
+utils.extglob = require('extglob');
+utils.isExtglob = require('is-extglob');
+utils.isGlob = require('is-glob');
+utils.typeOf = require('kind-of');
+utils.normalize = require('normalize-path');
+utils.omit = require('object.omit');
+utils.parseGlob = require('parse-glob');
+utils.cache = require('regex-cache');
+
+/**
+ * Get the filename of a filepath
+ *
+ * @param {String} `string`
+ * @return {String}
+ */
+
+utils.filename = function filename(fp) {
+  var seg = fp.match(fileRe());
+  return seg && seg[0];
+};
+
+/**
+ * Returns a function that returns true if the given
+ * pattern is the same as a given `filepath`
+ *
+ * @param {String} `pattern`
+ * @return {Function}
+ */
+
+utils.isPath = function isPath(pattern, opts) {
+  opts = opts || {};
+  return function(fp) {
+    var unixified = utils.unixify(fp, opts);
+    if(opts.nocase){
+      return pattern.toLowerCase() === unixified.toLowerCase();
+    }
+    return pattern === unixified;
+  };
+};
+
+/**
+ * Returns a function that returns true if the given
+ * pattern contains a `filepath`
+ *
+ * @param {String} `pattern`
+ * @return {Function}
+ */
+
+utils.hasPath = function hasPath(pattern, opts) {
+  return function(fp) {
+    return utils.unixify(pattern, opts).indexOf(fp) !== -1;
+  };
+};
+
+/**
+ * Returns a function that returns true if the given
+ * pattern matches or contains a `filepath`
+ *
+ * @param {String} `pattern`
+ * @return {Function}
+ */
+
+utils.matchPath = function matchPath(pattern, opts) {
+  var fn = (opts && opts.contains)
+    ? utils.hasPath(pattern, opts)
+    : utils.isPath(pattern, opts);
+  return fn;
+};
+
+/**
+ * Returns a function that returns true if the given
+ * regex matches the `filename` of a file path.
+ *
+ * @param {RegExp} `re`
+ * @return {Boolean}
+ */
+
+utils.hasFilename = function hasFilename(re) {
+  return function(fp) {
+    var name = utils.filename(fp);
+    return name && re.test(name);
+  };
+};
+
+/**
+ * Coerce `val` to an array
+ *
+ * @param  {*} val
+ * @return {Array}
+ */
+
+utils.arrayify = function arrayify(val) {
+  return !Array.isArray(val)
+    ? [val]
+    : val;
+};
+
+/**
+ * Normalize all slashes in a file path or glob pattern to
+ * forward slashes.
+ */
+
+utils.unixify = function unixify(fp, opts) {
+  if (opts && opts.unixify === false) return fp;
+  if (opts && opts.unixify === true || win32 || path.sep === '\\') {
+    return utils.normalize(fp, false);
+  }
+  if (opts && opts.unescape === true) {
+    return fp ? fp.toString().replace(/\\(\w)/g, '$1') : '';
+  }
+  return fp;
+};
+
+/**
+ * Escape/unescape utils
+ */
+
+utils.escapePath = function escapePath(fp) {
+  return fp.replace(/[\\.]/g, '\\$&');
+};
+
+utils.unescapeGlob = function unescapeGlob(fp) {
+  return fp.replace(/[\\"']/g, '');
+};
+
+utils.escapeRe = function escapeRe(str) {
+  return str.replace(/[-[\\$*+?.#^\s{}(|)\]]/g, '\\$&');
+};
+
+/**
+ * Expose `utils`
+ */
+
+module.exports = utils;
diff --git a/node_modules/@babel/core/node_modules/micromatch/package.json b/node_modules/@babel/core/node_modules/micromatch/package.json
new file mode 100644
index 00000000..f2aef5b1
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/micromatch/package.json
@@ -0,0 +1,114 @@
+{
+  "name": "micromatch",
+  "description": "Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch.",
+  "version": "2.3.11",
+  "homepage": "https://github.com/jonschlinkert/micromatch",
+  "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
+  "repository": "jonschlinkert/micromatch",
+  "bugs": {
+    "url": "https://github.com/jonschlinkert/micromatch/issues"
+  },
+  "license": "MIT",
+  "files": [
+    "index.js",
+    "lib"
+  ],
+  "main": "index.js",
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "dependencies": {
+    "arr-diff": "^2.0.0",
+    "array-unique": "^0.2.1",
+    "braces": "^1.8.2",
+    "expand-brackets": "^0.1.4",
+    "extglob": "^0.3.1",
+    "filename-regex": "^2.0.0",
+    "is-extglob": "^1.0.0",
+    "is-glob": "^2.0.1",
+    "kind-of": "^3.0.2",
+    "normalize-path": "^2.0.1",
+    "object.omit": "^2.0.0",
+    "parse-glob": "^3.0.4",
+    "regex-cache": "^0.4.2"
+  },
+  "devDependencies": {
+    "benchmarked": "^0.1.4",
+    "chalk": "^1.1.1",
+    "gulp": "^3.9.0",
+    "gulp-eslint": "^1.1.1",
+    "gulp-format-md": "^0.1.8",
+    "gulp-istanbul": "^0.10.1",
+    "gulp-mocha": "^2.1.3",
+    "minimatch": "^3.0.0",
+    "minimist": "^1.2.0",
+    "mocha": "^2",
+    "multimatch": "^2.0.0",
+    "should": "^8",
+    "write": "^0.2.1"
+  },
+  "keywords": [
+    "bash",
+    "expand",
+    "expansion",
+    "expression",
+    "file",
+    "files",
+    "filter",
+    "find",
+    "glob",
+    "globbing",
+    "globs",
+    "globstar",
+    "match",
+    "matcher",
+    "matches",
+    "matching",
+    "minimatch",
+    "multimatch",
+    "path",
+    "pattern",
+    "patterns",
+    "regex",
+    "regexp",
+    "regular",
+    "shell",
+    "wildcard"
+  ],
+  "verb": {
+    "related": {
+      "list": [
+        "braces",
+        "expand-brackets",
+        "expand-range",
+        "extglob",
+        "fill-range",
+        "gulp-micromatch",
+        "is-glob",
+        "parse-glob"
+      ]
+    },
+    "reflinks": [
+      "braces",
+      "expand-brackets",
+      "extglob",
+      "minimatch",
+      "multimatch",
+      "verb"
+    ],
+    "toc": false,
+    "layout": false,
+    "tasks": [
+      "readme"
+    ],
+    "plugins": [
+      "gulp-format-md"
+    ],
+    "lint": {
+      "reflinks": true
+    }
+  }
+}
diff --git a/node_modules/@babel/core/node_modules/ms/index.js b/node_modules/@babel/core/node_modules/ms/index.js
new file mode 100644
index 00000000..72297501
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/ms/index.js
@@ -0,0 +1,162 @@
+/**
+ * Helpers.
+ */
+
+var s = 1000;
+var m = s * 60;
+var h = m * 60;
+var d = h * 24;
+var w = d * 7;
+var y = d * 365.25;
+
+/**
+ * Parse or format the given `val`.
+ *
+ * Options:
+ *
+ *  - `long` verbose formatting [false]
+ *
+ * @param {String|Number} val
+ * @param {Object} [options]
+ * @throws {Error} throw an error if val is not a non-empty string or a number
+ * @return {String|Number}
+ * @api public
+ */
+
+module.exports = function(val, options) {
+  options = options || {};
+  var type = typeof val;
+  if (type === 'string' && val.length > 0) {
+    return parse(val);
+  } else if (type === 'number' && isNaN(val) === false) {
+    return options.long ? fmtLong(val) : fmtShort(val);
+  }
+  throw new Error(
+    'val is not a non-empty string or a valid number. val=' +
+      JSON.stringify(val)
+  );
+};
+
+/**
+ * Parse the given `str` and return milliseconds.
+ *
+ * @param {String} str
+ * @return {Number}
+ * @api private
+ */
+
+function parse(str) {
+  str = String(str);
+  if (str.length > 100) {
+    return;
+  }
+  var match = /^((?:\d+)?\-?\d?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+    str
+  );
+  if (!match) {
+    return;
+  }
+  var n = parseFloat(match[1]);
+  var type = (match[2] || 'ms').toLowerCase();
+  switch (type) {
+    case 'years':
+    case 'year':
+    case 'yrs':
+    case 'yr':
+    case 'y':
+      return n * y;
+    case 'weeks':
+    case 'week':
+    case 'w':
+      return n * w;
+    case 'days':
+    case 'day':
+    case 'd':
+      return n * d;
+    case 'hours':
+    case 'hour':
+    case 'hrs':
+    case 'hr':
+    case 'h':
+      return n * h;
+    case 'minutes':
+    case 'minute':
+    case 'mins':
+    case 'min':
+    case 'm':
+      return n * m;
+    case 'seconds':
+    case 'second':
+    case 'secs':
+    case 'sec':
+    case 's':
+      return n * s;
+    case 'milliseconds':
+    case 'millisecond':
+    case 'msecs':
+    case 'msec':
+    case 'ms':
+      return n;
+    default:
+      return undefined;
+  }
+}
+
+/**
+ * Short format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function fmtShort(ms) {
+  var msAbs = Math.abs(ms);
+  if (msAbs >= d) {
+    return Math.round(ms / d) + 'd';
+  }
+  if (msAbs >= h) {
+    return Math.round(ms / h) + 'h';
+  }
+  if (msAbs >= m) {
+    return Math.round(ms / m) + 'm';
+  }
+  if (msAbs >= s) {
+    return Math.round(ms / s) + 's';
+  }
+  return ms + 'ms';
+}
+
+/**
+ * Long format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function fmtLong(ms) {
+  var msAbs = Math.abs(ms);
+  if (msAbs >= d) {
+    return plural(ms, msAbs, d, 'day');
+  }
+  if (msAbs >= h) {
+    return plural(ms, msAbs, h, 'hour');
+  }
+  if (msAbs >= m) {
+    return plural(ms, msAbs, m, 'minute');
+  }
+  if (msAbs >= s) {
+    return plural(ms, msAbs, s, 'second');
+  }
+  return ms + ' ms';
+}
+
+/**
+ * Pluralization helper.
+ */
+
+function plural(ms, msAbs, n, name) {
+  var isPlural = msAbs >= n * 1.5;
+  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+}
diff --git a/node_modules/@babel/core/node_modules/ms/license.md b/node_modules/@babel/core/node_modules/ms/license.md
new file mode 100644
index 00000000..69b61253
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/ms/license.md
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Zeit, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/node_modules/@babel/core/node_modules/ms/package.json b/node_modules/@babel/core/node_modules/ms/package.json
new file mode 100644
index 00000000..fc28cb39
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/ms/package.json
@@ -0,0 +1,37 @@
+{
+  "name": "ms",
+  "version": "2.1.1",
+  "description": "Tiny millisecond conversion utility",
+  "repository": "zeit/ms",
+  "main": "./index",
+  "files": [
+    "index.js"
+  ],
+  "scripts": {
+    "precommit": "lint-staged",
+    "lint": "eslint lib/* bin/*",
+    "test": "mocha tests.js"
+  },
+  "eslintConfig": {
+    "extends": "eslint:recommended",
+    "env": {
+      "node": true,
+      "es6": true
+    }
+  },
+  "lint-staged": {
+    "*.js": [
+      "npm run lint",
+      "prettier --single-quote --write",
+      "git add"
+    ]
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "eslint": "4.12.1",
+    "expect.js": "0.3.1",
+    "husky": "0.14.3",
+    "lint-staged": "5.0.0",
+    "mocha": "4.0.1"
+  }
+}
diff --git a/node_modules/@babel/core/node_modules/ms/readme.md b/node_modules/@babel/core/node_modules/ms/readme.md
new file mode 100644
index 00000000..bb767293
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/ms/readme.md
@@ -0,0 +1,60 @@
+# ms
+
+[![Build Status](https://travis-ci.org/zeit/ms.svg?branch=master)](https://travis-ci.org/zeit/ms)
+[![Slack Channel](http://zeit-slackin.now.sh/badge.svg)](https://zeit.chat/)
+
+Use this package to easily convert various time formats to milliseconds.
+
+## Examples
+
+```js
+ms('2 days')  // 172800000
+ms('1d')      // 86400000
+ms('10h')     // 36000000
+ms('2.5 hrs') // 9000000
+ms('2h')      // 7200000
+ms('1m')      // 60000
+ms('5s')      // 5000
+ms('1y')      // 31557600000
+ms('100')     // 100
+ms('-3 days') // -259200000
+ms('-1h')     // -3600000
+ms('-200')    // -200
+```
+
+### Convert from Milliseconds
+
+```js
+ms(60000)             // "1m"
+ms(2 * 60000)         // "2m"
+ms(-3 * 60000)        // "-3m"
+ms(ms('10 hours'))    // "10h"
+```
+
+### Time Format Written-Out
+
+```js
+ms(60000, { long: true })             // "1 minute"
+ms(2 * 60000, { long: true })         // "2 minutes"
+ms(-3 * 60000, { long: true })        // "-3 minutes"
+ms(ms('10 hours'), { long: true })    // "10 hours"
+```
+
+## Features
+
+- Works both in [Node.js](https://nodejs.org) and in the browser
+- If a number is supplied to `ms`, a string with a unit is returned
+- If a string that contains the number is supplied, it returns it as a number (e.g.: it returns `100` for `'100'`)
+- If you pass a string with a number and a valid unit, the number of equivalent milliseconds is returned
+
+## Related Packages
+
+- [ms.macro](https://github.com/knpwrs/ms.macro) - Run `ms` as a macro at build-time.
+
+## Caught a Bug?
+
+1. [Fork](https://help.github.com/articles/fork-a-repo/) this repository to your own GitHub account and then [clone](https://help.github.com/articles/cloning-a-repository/) it to your local device
+2. Link the package to the global module directory: `npm link`
+3. Within the module you want to test your local development instance of ms, just link it to the dependencies: `npm link ms`. Instead of the default one from npm, Node.js will now use your clone of ms!
+
+As always, you can run the tests using: `npm test`
diff --git a/node_modules/@babel/core/node_modules/source-map/CHANGELOG.md b/node_modules/@babel/core/node_modules/source-map/CHANGELOG.md
new file mode 100644
index 00000000..3a8c066c
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/source-map/CHANGELOG.md
@@ -0,0 +1,301 @@
+# Change Log
+
+## 0.5.6
+
+* Fix for regression when people were using numbers as names in source maps. See
+  #236.
+
+## 0.5.5
+
+* Fix "regression" of unsupported, implementation behavior that half the world
+  happens to have come to depend on. See #235.
+
+* Fix regression involving function hoisting in SpiderMonkey. See #233.
+
+## 0.5.4
+
+* Large performance improvements to source-map serialization. See #228 and #229.
+
+## 0.5.3
+
+* Do not include unnecessary distribution files. See
+  commit ef7006f8d1647e0a83fdc60f04f5a7ca54886f86.
+
+## 0.5.2
+
+* Include browser distributions of the library in package.json's `files`. See
+  issue #212.
+
+## 0.5.1
+
+* Fix latent bugs in IndexedSourceMapConsumer.prototype._parseMappings. See
+  ff05274becc9e6e1295ed60f3ea090d31d843379.
+
+## 0.5.0
+
+* Node 0.8 is no longer supported.
+
+* Use webpack instead of dryice for bundling.
+
+* Big speedups serializing source maps. See pull request #203.
+
+* Fix a bug with `SourceMapConsumer.prototype.sourceContentFor` and sources that
+  explicitly start with the source root. See issue #199.
+
+## 0.4.4
+
+* Fix an issue where using a `SourceMapGenerator` after having created a
+  `SourceMapConsumer` from it via `SourceMapConsumer.fromSourceMap` failed. See
+  issue #191.
+
+* Fix an issue with where `SourceMapGenerator` would mistakenly consider
+  different mappings as duplicates of each other and avoid generating them. See
+  issue #192.
+
+## 0.4.3
+
+* A very large number of performance improvements, particularly when parsing
+  source maps. Collectively about 75% of time shaved off of the source map
+  parsing benchmark!
+
+* Fix a bug in `SourceMapConsumer.prototype.allGeneratedPositionsFor` and fuzzy
+  searching in the presence of a column option. See issue #177.
+
+* Fix a bug with joining a source and its source root when the source is above
+  the root. See issue #182.
+
+* Add the `SourceMapConsumer.prototype.hasContentsOfAllSources` method to
+  determine when all sources' contents are inlined into the source map. See
+  issue #190.
+
+## 0.4.2
+
+* Add an `.npmignore` file so that the benchmarks aren't pulled down by
+  dependent projects. Issue #169.
+
+* Add an optional `column` argument to
+  `SourceMapConsumer.prototype.allGeneratedPositionsFor` and better handle lines
+  with no mappings. Issues #172 and #173.
+
+## 0.4.1
+
+* Fix accidentally defining a global variable. #170.
+
+## 0.4.0
+
+* The default direction for fuzzy searching was changed back to its original
+  direction. See #164.
+
+* There is now a `bias` option you can supply to `SourceMapConsumer` to control
+  the fuzzy searching direction. See #167.
+
+* About an 8% speed up in parsing source maps. See #159.
+
+* Added a benchmark for parsing and generating source maps.
+
+## 0.3.0
+
+* Change the default direction that searching for positions fuzzes when there is
+  not an exact match. See #154.
+
+* Support for environments using json2.js for JSON serialization. See #156.
+
+## 0.2.0
+
+* Support for consuming "indexed" source maps which do not have any remote
+  sections. See pull request #127. This introduces a minor backwards
+  incompatibility if you are monkey patching `SourceMapConsumer.prototype`
+  methods.
+
+## 0.1.43
+
+* Performance improvements for `SourceMapGenerator` and `SourceNode`. See issue
+  #148 for some discussion and issues #150, #151, and #152 for implementations.
+
+## 0.1.42
+
+* Fix an issue where `SourceNode`s from different versions of the source-map
+  library couldn't be used in conjunction with each other. See issue #142.
+
+## 0.1.41
+
+* Fix a bug with getting the source content of relative sources with a "./"
+  prefix. See issue #145 and [Bug 1090768](bugzil.la/1090768).
+
+* Add the `SourceMapConsumer.prototype.computeColumnSpans` method to compute the
+  column span of each mapping.
+
+* Add the `SourceMapConsumer.prototype.allGeneratedPositionsFor` method to find
+  all generated positions associated with a given original source and line.
+
+## 0.1.40
+
+* Performance improvements for parsing source maps in SourceMapConsumer.
+
+## 0.1.39
+
+* Fix a bug where setting a source's contents to null before any source content
+  had been set before threw a TypeError. See issue #131.
+
+## 0.1.38
+
+* Fix a bug where finding relative paths from an empty path were creating
+  absolute paths. See issue #129.
+
+## 0.1.37
+
+* Fix a bug where if the source root was an empty string, relative source paths
+  would turn into absolute source paths. Issue #124.
+
+## 0.1.36
+
+* Allow the `names` mapping property to be an empty string. Issue #121.
+
+## 0.1.35
+
+* A third optional parameter was added to `SourceNode.fromStringWithSourceMap`
+  to specify a path that relative sources in the second parameter should be
+  relative to. Issue #105.
+
+* If no file property is given to a `SourceMapGenerator`, then the resulting
+  source map will no longer have a `null` file property. The property will
+  simply not exist. Issue #104.
+
+* Fixed a bug where consecutive newlines were ignored in `SourceNode`s.
+  Issue #116.
+
+## 0.1.34
+
+* Make `SourceNode` work with windows style ("\r\n") newlines. Issue #103.
+
+* Fix bug involving source contents and the
+  `SourceMapGenerator.prototype.applySourceMap`. Issue #100.
+
+## 0.1.33
+
+* Fix some edge cases surrounding path joining and URL resolution.
+
+* Add a third parameter for relative path to
+  `SourceMapGenerator.prototype.applySourceMap`.
+
+* Fix issues with mappings and EOLs.
+
+## 0.1.32
+
+* Fixed a bug where SourceMapConsumer couldn't handle negative relative columns
+  (issue 92).
+
+* Fixed test runner to actually report number of failed tests as its process
+  exit code.
+
+* Fixed a typo when reporting bad mappings (issue 87).
+
+## 0.1.31
+
+* Delay parsing the mappings in SourceMapConsumer until queried for a source
+  location.
+
+* Support Sass source maps (which at the time of writing deviate from the spec
+  in small ways) in SourceMapConsumer.
+
+## 0.1.30
+
+* Do not join source root with a source, when the source is a data URI.
+
+* Extend the test runner to allow running single specific test files at a time.
+
+* Performance improvements in `SourceNode.prototype.walk` and
+  `SourceMapConsumer.prototype.eachMapping`.
+
+* Source map browser builds will now work inside Workers.
+
+* Better error messages when attempting to add an invalid mapping to a
+  `SourceMapGenerator`.
+
+## 0.1.29
+
+* Allow duplicate entries in the `names` and `sources` arrays of source maps
+  (usually from TypeScript) we are parsing. Fixes github issue 72.
+
+## 0.1.28
+
+* Skip duplicate mappings when creating source maps from SourceNode; github
+  issue 75.
+
+## 0.1.27
+
+* Don't throw an error when the `file` property is missing in SourceMapConsumer,
+  we don't use it anyway.
+
+## 0.1.26
+
+* Fix SourceNode.fromStringWithSourceMap for empty maps. Fixes github issue 70.
+
+## 0.1.25
+
+* Make compatible with browserify
+
+## 0.1.24
+
+* Fix issue with absolute paths and `file://` URIs. See
+  https://bugzilla.mozilla.org/show_bug.cgi?id=885597
+
+## 0.1.23
+
+* Fix issue with absolute paths and sourcesContent, github issue 64.
+
+## 0.1.22
+
+* Ignore duplicate mappings in SourceMapGenerator. Fixes github issue 21.
+
+## 0.1.21
+
+* Fixed handling of sources that start with a slash so that they are relative to
+  the source root's host.
+
+## 0.1.20
+
+* Fixed github issue #43: absolute URLs aren't joined with the source root
+  anymore.
+
+## 0.1.19
+
+* Using Travis CI to run tests.
+
+## 0.1.18
+
+* Fixed a bug in the handling of sourceRoot.
+
+## 0.1.17
+
+* Added SourceNode.fromStringWithSourceMap.
+
+## 0.1.16
+
+* Added missing documentation.
+
+* Fixed the generating of empty mappings in SourceNode.
+
+## 0.1.15
+
+* Added SourceMapGenerator.applySourceMap.
+
+## 0.1.14
+
+* The sourceRoot is now handled consistently.
+
+## 0.1.13
+
+* Added SourceMapGenerator.fromSourceMap.
+
+## 0.1.12
+
+* SourceNode now generates empty mappings too.
+
+## 0.1.11
+
+* Added name support to SourceNode.
+
+## 0.1.10
+
+* Added sourcesContent support to the customer and generator.
diff --git a/node_modules/@babel/core/node_modules/source-map/LICENSE b/node_modules/@babel/core/node_modules/source-map/LICENSE
new file mode 100644
index 00000000..ed1b7cf2
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/source-map/LICENSE
@@ -0,0 +1,28 @@
+
+Copyright (c) 2009-2011, Mozilla Foundation and contributors
+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 names of the Mozilla Foundation nor the names of project
+  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 HOLDER 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.
diff --git a/node_modules/@babel/core/node_modules/source-map/README.md b/node_modules/@babel/core/node_modules/source-map/README.md
new file mode 100644
index 00000000..32813394
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/source-map/README.md
@@ -0,0 +1,729 @@
+# Source Map
+
+[![Build Status](https://travis-ci.org/mozilla/source-map.png?branch=master)](https://travis-ci.org/mozilla/source-map)
+
+[![NPM](https://nodei.co/npm/source-map.png?downloads=true&downloadRank=true)](https://www.npmjs.com/package/source-map)
+
+This is a library to generate and consume the source map format
+[described here][format].
+
+[format]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit
+
+## Use with Node
+
+    $ npm install source-map
+
+## Use on the Web
+
+    <script src="https://raw.githubusercontent.com/mozilla/source-map/master/dist/source-map.min.js" defer></script>
+
+--------------------------------------------------------------------------------
+
+<!-- `npm run toc` to regenerate the Table of Contents -->
+
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+## Table of Contents
+
+- [Examples](#examples)
+  - [Consuming a source map](#consuming-a-source-map)
+  - [Generating a source map](#generating-a-source-map)
+    - [With SourceNode (high level API)](#with-sourcenode-high-level-api)
+    - [With SourceMapGenerator (low level API)](#with-sourcemapgenerator-low-level-api)
+- [API](#api)
+  - [SourceMapConsumer](#sourcemapconsumer)
+    - [new SourceMapConsumer(rawSourceMap)](#new-sourcemapconsumerrawsourcemap)
+    - [SourceMapConsumer.prototype.computeColumnSpans()](#sourcemapconsumerprototypecomputecolumnspans)
+    - [SourceMapConsumer.prototype.originalPositionFor(generatedPosition)](#sourcemapconsumerprototypeoriginalpositionforgeneratedposition)
+    - [SourceMapConsumer.prototype.generatedPositionFor(originalPosition)](#sourcemapconsumerprototypegeneratedpositionfororiginalposition)
+    - [SourceMapConsumer.prototype.allGeneratedPositionsFor(originalPosition)](#sourcemapconsumerprototypeallgeneratedpositionsfororiginalposition)
+    - [SourceMapConsumer.prototype.hasContentsOfAllSources()](#sourcemapconsumerprototypehascontentsofallsources)
+    - [SourceMapConsumer.prototype.sourceContentFor(source[, returnNullOnMissing])](#sourcemapconsumerprototypesourcecontentforsource-returnnullonmissing)
+    - [SourceMapConsumer.prototype.eachMapping(callback, context, order)](#sourcemapconsumerprototypeeachmappingcallback-context-order)
+  - [SourceMapGenerator](#sourcemapgenerator)
+    - [new SourceMapGenerator([startOfSourceMap])](#new-sourcemapgeneratorstartofsourcemap)
+    - [SourceMapGenerator.fromSourceMap(sourceMapConsumer)](#sourcemapgeneratorfromsourcemapsourcemapconsumer)
+    - [SourceMapGenerator.prototype.addMapping(mapping)](#sourcemapgeneratorprototypeaddmappingmapping)
+    - [SourceMapGenerator.prototype.setSourceContent(sourceFile, sourceContent)](#sourcemapgeneratorprototypesetsourcecontentsourcefile-sourcecontent)
+    - [SourceMapGenerator.prototype.applySourceMap(sourceMapConsumer[, sourceFile[, sourceMapPath]])](#sourcemapgeneratorprototypeapplysourcemapsourcemapconsumer-sourcefile-sourcemappath)
+    - [SourceMapGenerator.prototype.toString()](#sourcemapgeneratorprototypetostring)
+  - [SourceNode](#sourcenode)
+    - [new SourceNode([line, column, source[, chunk[, name]]])](#new-sourcenodeline-column-source-chunk-name)
+    - [SourceNode.fromStringWithSourceMap(code, sourceMapConsumer[, relativePath])](#sourcenodefromstringwithsourcemapcode-sourcemapconsumer-relativepath)
+    - [SourceNode.prototype.add(chunk)](#sourcenodeprototypeaddchunk)
+    - [SourceNode.prototype.prepend(chunk)](#sourcenodeprototypeprependchunk)
+    - [SourceNode.prototype.setSourceContent(sourceFile, sourceContent)](#sourcenodeprototypesetsourcecontentsourcefile-sourcecontent)
+    - [SourceNode.prototype.walk(fn)](#sourcenodeprototypewalkfn)
+    - [SourceNode.prototype.walkSourceContents(fn)](#sourcenodeprototypewalksourcecontentsfn)
+    - [SourceNode.prototype.join(sep)](#sourcenodeprototypejoinsep)
+    - [SourceNode.prototype.replaceRight(pattern, replacement)](#sourcenodeprototypereplacerightpattern-replacement)
+    - [SourceNode.prototype.toString()](#sourcenodeprototypetostring)
+    - [SourceNode.prototype.toStringWithSourceMap([startOfSourceMap])](#sourcenodeprototypetostringwithsourcemapstartofsourcemap)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+
+## Examples
+
+### Consuming a source map
+
+```js
+var rawSourceMap = {
+  version: 3,
+  file: 'min.js',
+  names: ['bar', 'baz', 'n'],
+  sources: ['one.js', 'two.js'],
+  sourceRoot: 'http://example.com/www/js/',
+  mappings: 'CAAC,IAAI,IAAM,SAAUA,GAClB,OAAOC,IAAID;CCDb,IAAI,IAAM,SAAUE,GAClB,OAAOA'
+};
+
+var smc = new SourceMapConsumer(rawSourceMap);
+
+console.log(smc.sources);
+// [ 'http://example.com/www/js/one.js',
+//   'http://example.com/www/js/two.js' ]
+
+console.log(smc.originalPositionFor({
+  line: 2,
+  column: 28
+}));
+// { source: 'http://example.com/www/js/two.js',
+//   line: 2,
+//   column: 10,
+//   name: 'n' }
+
+console.log(smc.generatedPositionFor({
+  source: 'http://example.com/www/js/two.js',
+  line: 2,
+  column: 10
+}));
+// { line: 2, column: 28 }
+
+smc.eachMapping(function (m) {
+  // ...
+});
+```
+
+### Generating a source map
+
+In depth guide:
+[**Compiling to JavaScript, and Debugging with Source Maps**](https://hacks.mozilla.org/2013/05/compiling-to-javascript-and-debugging-with-source-maps/)
+
+#### With SourceNode (high level API)
+
+```js
+function compile(ast) {
+  switch (ast.type) {
+  case 'BinaryExpression':
+    return new SourceNode(
+      ast.location.line,
+      ast.location.column,
+      ast.location.source,
+      [compile(ast.left), " + ", compile(ast.right)]
+    );
+  case 'Literal':
+    return new SourceNode(
+      ast.location.line,
+      ast.location.column,
+      ast.location.source,
+      String(ast.value)
+    );
+  // ...
+  default:
+    throw new Error("Bad AST");
+  }
+}
+
+var ast = parse("40 + 2", "add.js");
+console.log(compile(ast).toStringWithSourceMap({
+  file: 'add.js'
+}));
+// { code: '40 + 2',
+//   map: [object SourceMapGenerator] }
+```
+
+#### With SourceMapGenerator (low level API)
+
+```js
+var map = new SourceMapGenerator({
+  file: "source-mapped.js"
+});
+
+map.addMapping({
+  generated: {
+    line: 10,
+    column: 35
+  },
+  source: "foo.js",
+  original: {
+    line: 33,
+    column: 2
+  },
+  name: "christopher"
+});
+
+console.log(map.toString());
+// '{"version":3,"file":"source-mapped.js","sources":["foo.js"],"names":["christopher"],"mappings":";;;;;;;;;mCAgCEA"}'
+```
+
+## API
+
+Get a reference to the module:
+
+```js
+// Node.js
+var sourceMap = require('source-map');
+
+// Browser builds
+var sourceMap = window.sourceMap;
+
+// Inside Firefox
+const sourceMap = require("devtools/toolkit/sourcemap/source-map.js");
+```
+
+### SourceMapConsumer
+
+A SourceMapConsumer 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.
+
+#### new SourceMapConsumer(rawSourceMap)
+
+The only parameter is the raw source map (either as a string which can be
+`JSON.parse`'d, or 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 referenced 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 filename this source map is associated with.
+
+```js
+var consumer = new sourceMap.SourceMapConsumer(rawSourceMapJsonData);
+```
+
+#### SourceMapConsumer.prototype.computeColumnSpans()
+
+Compute the last column for each generated mapping. The last column is
+inclusive.
+
+```js
+// Before:
+consumer.allGeneratedPositionsFor({ line: 2, source: "foo.coffee" })
+// [ { line: 2,
+//     column: 1 },
+//   { line: 2,
+//     column: 10 },
+//   { line: 2,
+//     column: 20 } ]
+
+consumer.computeColumnSpans();
+
+// After:
+consumer.allGeneratedPositionsFor({ line: 2, source: "foo.coffee" })
+// [ { line: 2,
+//     column: 1,
+//     lastColumn: 9 },
+//   { line: 2,
+//     column: 10,
+//     lastColumn: 19 },
+//   { line: 2,
+//     column: 20,
+//     lastColumn: Infinity } ]
+
+```
+
+#### SourceMapConsumer.prototype.originalPositionFor(generatedPosition)
+
+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 if this information is not
+  available.
+
+* `line`: The line number in the original source, or null if this information is
+  not available.
+
+* `column`: The column number in the original source, or null if this
+  information is not available.
+
+* `name`: The original identifier, or null if this information is not available.
+
+```js
+consumer.originalPositionFor({ line: 2, column: 10 })
+// { source: 'foo.coffee',
+//   line: 2,
+//   column: 2,
+//   name: null }
+
+consumer.originalPositionFor({ line: 99999999999999999, column: 999999999999999 })
+// { source: null,
+//   line: null,
+//   column: null,
+//   name: null }
+```
+
+#### SourceMapConsumer.prototype.generatedPositionFor(originalPosition)
+
+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.
+
+```js
+consumer.generatedPositionFor({ source: "example.js", line: 2, column: 10 })
+// { line: 1,
+//   column: 56 }
+```
+
+#### SourceMapConsumer.prototype.allGeneratedPositionsFor(originalPosition)
+
+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.
+
+```js
+consumer.allGeneratedpositionsfor({ line: 2, source: "foo.coffee" })
+// [ { line: 2,
+//     column: 1 },
+//   { line: 2,
+//     column: 10 },
+//   { line: 2,
+//     column: 20 } ]
+```
+
+#### SourceMapConsumer.prototype.hasContentsOfAllSources()
+
+Return true if we have the embedded source content for every source listed in
+the source map, false otherwise.
+
+In other words, if this method returns `true`, then
+`consumer.sourceContentFor(s)` will succeed for every source `s` in
+`consumer.sources`.
+
+```js
+// ...
+if (consumer.hasContentsOfAllSources()) {
+  consumerReadyCallback(consumer);
+} else {
+  fetchSources(consumer, consumerReadyCallback);
+}
+// ...
+```
+
+#### SourceMapConsumer.prototype.sourceContentFor(source[, returnNullOnMissing])
+
+Returns the original source content for the source provided. The only
+argument is the URL of the original source file.
+
+If the source content for the given source is not found, then an error is
+thrown. Optionally, pass `true` as the second param to have `null` returned
+instead.
+
+```js
+consumer.sources
+// [ "my-cool-lib.clj" ]
+
+consumer.sourceContentFor("my-cool-lib.clj")
+// "..."
+
+consumer.sourceContentFor("this is not in the source map");
+// Error: "this is not in the source map" is not in the source map
+
+consumer.sourceContentFor("this is not in the source map", true);
+// null
+```
+
+#### SourceMapConsumer.prototype.eachMapping(callback, context, order)
+
+Iterate over each mapping between an original source/line/column and a
+generated line/column in this source map.
+
+* `callback`: The function that is called with each mapping. Mappings have the
+  form `{ source, generatedLine, generatedColumn, originalLine, originalColumn,
+  name }`
+
+* `context`: Optional. If specified, this object will be the value of `this`
+  every time that `callback` is called.
+
+* `order`: 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`.
+
+```js
+consumer.eachMapping(function (m) { console.log(m); })
+// ...
+// { source: 'illmatic.js',
+//   generatedLine: 1,
+//   generatedColumn: 0,
+//   originalLine: 1,
+//   originalColumn: 0,
+//   name: null }
+// { source: 'illmatic.js',
+//   generatedLine: 2,
+//   generatedColumn: 0,
+//   originalLine: 2,
+//   originalColumn: 0,
+//   name: null }
+// ...
+```
+### SourceMapGenerator
+
+An instance of the SourceMapGenerator represents a source map which is being
+built incrementally.
+
+#### new SourceMapGenerator([startOfSourceMap])
+
+You may pass an object with the following properties:
+
+* `file`: The filename of the generated source that this source map is
+  associated with.
+
+* `sourceRoot`: A root for all relative URLs in this source map.
+
+* `skipValidation`: Optional. When `true`, disables validation of mappings as
+  they are added. This can improve performance but should be used with
+  discretion, as a last resort. Even then, one should avoid using this flag when
+  running tests, if possible.
+
+```js
+var generator = new sourceMap.SourceMapGenerator({
+  file: "my-generated-javascript-file.js",
+  sourceRoot: "http://example.com/app/js/"
+});
+```
+
+#### SourceMapGenerator.fromSourceMap(sourceMapConsumer)
+
+Creates a new `SourceMapGenerator` from an existing `SourceMapConsumer` instance.
+
+* `sourceMapConsumer` The SourceMap.
+
+```js
+var generator = sourceMap.SourceMapGenerator.fromSourceMap(consumer);
+```
+
+#### SourceMapGenerator.prototype.addMapping(mapping)
+
+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.
+
+```js
+generator.addMapping({
+  source: "module-one.scm",
+  original: { line: 128, column: 0 },
+  generated: { line: 3, column: 456 }
+})
+```
+
+#### SourceMapGenerator.prototype.setSourceContent(sourceFile, sourceContent)
+
+Set the source content for an original source file.
+
+* `sourceFile` the URL of the original source file.
+
+* `sourceContent` the content of the source file.
+
+```js
+generator.setSourceContent("module-one.scm",
+                           fs.readFileSync("path/to/module-one.scm"))
+```
+
+#### SourceMapGenerator.prototype.applySourceMap(sourceMapConsumer[, sourceFile[, sourceMapPath]])
+
+Applies a SourceMap for a source file to the SourceMap.
+Each mapping to the supplied source file is rewritten using the
+supplied SourceMap. Note: The resolution for the resulting mappings
+is the minimum of this map and the supplied map.
+
+* `sourceMapConsumer`: The SourceMap to be applied.
+
+* `sourceFile`: Optional. The filename of the source file.
+  If omitted, sourceMapConsumer.file will be used, if it exists.
+  Otherwise an error will be thrown.
+
+* `sourceMapPath`: Optional. The dirname of the path to the SourceMap
+  to be applied. If relative, it is relative to the SourceMap.
+
+  This parameter is needed when the two SourceMaps aren't in the same
+  directory, and the SourceMap to be applied contains relative source
+  paths. If so, those relative source paths need to be rewritten
+  relative to the SourceMap.
+
+  If omitted, it is assumed that both SourceMaps are in the same directory,
+  thus not needing any rewriting. (Supplying `'.'` has the same effect.)
+
+#### SourceMapGenerator.prototype.toString()
+
+Renders the source map being generated to a string.
+
+```js
+generator.toString()
+// '{"version":3,"sources":["module-one.scm"],"names":[],"mappings":"...snip...","file":"my-generated-javascript-file.js","sourceRoot":"http://example.com/app/js/"}'
+```
+
+### SourceNode
+
+SourceNodes provide a way to abstract over interpolating and/or concatenating
+snippets of generated JavaScript source code, while maintaining the line and
+column information associated between those snippets and the original source
+code. This is useful as the final intermediate representation a compiler might
+use before outputting the generated JS and source map.
+
+#### new SourceNode([line, column, source[, chunk[, name]]])
+
+* `line`: The original line number associated with this source node, or null if
+  it isn't associated with an original line.
+
+* `column`: The original column number associated with this source node, or null
+  if it isn't associated with an original column.
+
+* `source`: The original source's filename; null if no filename is provided.
+
+* `chunk`: Optional. Is immediately passed to `SourceNode.prototype.add`, see
+  below.
+
+* `name`: Optional. The original identifier.
+
+```js
+var node = new SourceNode(1, 2, "a.cpp", [
+  new SourceNode(3, 4, "b.cpp", "extern int status;\n"),
+  new SourceNode(5, 6, "c.cpp", "std::string* make_string(size_t n);\n"),
+  new SourceNode(7, 8, "d.cpp", "int main(int argc, char** argv) {}\n"),
+]);
+```
+
+#### SourceNode.fromStringWithSourceMap(code, sourceMapConsumer[, relativePath])
+
+Creates a SourceNode from generated code and a SourceMapConsumer.
+
+* `code`: The generated code
+
+* `sourceMapConsumer` The SourceMap for the generated code
+
+* `relativePath` The optional path that relative sources in `sourceMapConsumer`
+  should be relative to.
+
+```js
+var consumer = new SourceMapConsumer(fs.readFileSync("path/to/my-file.js.map", "utf8"));
+var node = SourceNode.fromStringWithSourceMap(fs.readFileSync("path/to/my-file.js"),
+                                              consumer);
+```
+
+#### SourceNode.prototype.add(chunk)
+
+Add a chunk of generated JS to this source node.
+
+* `chunk`: A string snippet of generated JS code, another instance of
+   `SourceNode`, or an array where each member is one of those things.
+
+```js
+node.add(" + ");
+node.add(otherNode);
+node.add([leftHandOperandNode, " + ", rightHandOperandNode]);
+```
+
+#### SourceNode.prototype.prepend(chunk)
+
+Prepend a chunk of generated JS to this source node.
+
+* `chunk`: A string snippet of generated JS code, another instance of
+   `SourceNode`, or an array where each member is one of those things.
+
+```js
+node.prepend("/** Build Id: f783haef86324gf **/\n\n");
+```
+
+#### SourceNode.prototype.setSourceContent(sourceFile, sourceContent)
+
+Set the source content for a source file. This will be added to the
+`SourceMap` in the `sourcesContent` field.
+
+* `sourceFile`: The filename of the source file
+
+* `sourceContent`: The content of the source file
+
+```js
+node.setSourceContent("module-one.scm",
+                      fs.readFileSync("path/to/module-one.scm"))
+```
+
+#### SourceNode.prototype.walk(fn)
+
+Walk over the tree of JS snippets in this node and its children. The walking
+function is called once for each snippet of JS and is passed that snippet and
+the its original associated source's line/column location.
+
+* `fn`: The traversal function.
+
+```js
+var node = new SourceNode(1, 2, "a.js", [
+  new SourceNode(3, 4, "b.js", "uno"),
+  "dos",
+  [
+    "tres",
+    new SourceNode(5, 6, "c.js", "quatro")
+  ]
+]);
+
+node.walk(function (code, loc) { console.log("WALK:", code, loc); })
+// WALK: uno { source: 'b.js', line: 3, column: 4, name: null }
+// WALK: dos { source: 'a.js', line: 1, column: 2, name: null }
+// WALK: tres { source: 'a.js', line: 1, column: 2, name: null }
+// WALK: quatro { source: 'c.js', line: 5, column: 6, name: null }
+```
+
+#### SourceNode.prototype.walkSourceContents(fn)
+
+Walk over the tree of SourceNodes. The walking function is called for each
+source file content and is passed the filename and source content.
+
+* `fn`: The traversal function.
+
+```js
+var a = new SourceNode(1, 2, "a.js", "generated from a");
+a.setSourceContent("a.js", "original a");
+var b = new SourceNode(1, 2, "b.js", "generated from b");
+b.setSourceContent("b.js", "original b");
+var c = new SourceNode(1, 2, "c.js", "generated from c");
+c.setSourceContent("c.js", "original c");
+
+var node = new SourceNode(null, null, null, [a, b, c]);
+node.walkSourceContents(function (source, contents) { console.log("WALK:", source, ":", contents); })
+// WALK: a.js : original a
+// WALK: b.js : original b
+// WALK: c.js : original c
+```
+
+#### SourceNode.prototype.join(sep)
+
+Like `Array.prototype.join` except for SourceNodes. Inserts the separator
+between each of this source node's children.
+
+* `sep`: The separator.
+
+```js
+var lhs = new SourceNode(1, 2, "a.rs", "my_copy");
+var operand = new SourceNode(3, 4, "a.rs", "=");
+var rhs = new SourceNode(5, 6, "a.rs", "orig.clone()");
+
+var node = new SourceNode(null, null, null, [ lhs, operand, rhs ]);
+var joinedNode = node.join(" ");
+```
+
+#### SourceNode.prototype.replaceRight(pattern, replacement)
+
+Call `String.prototype.replace` on the very right-most source snippet. Useful
+for trimming white space from the end of a source node, etc.
+
+* `pattern`: The pattern to replace.
+
+* `replacement`: The thing to replace the pattern with.
+
+```js
+// Trim trailing white space.
+node.replaceRight(/\s*$/, "");
+```
+
+#### SourceNode.prototype.toString()
+
+Return the string representation of this source node. Walks over the tree and
+concatenates all the various snippets together to one string.
+
+```js
+var node = new SourceNode(1, 2, "a.js", [
+  new SourceNode(3, 4, "b.js", "uno"),
+  "dos",
+  [
+    "tres",
+    new SourceNode(5, 6, "c.js", "quatro")
+  ]
+]);
+
+node.toString()
+// 'unodostresquatro'
+```
+
+#### SourceNode.prototype.toStringWithSourceMap([startOfSourceMap])
+
+Returns the string representation of this tree of source nodes, plus a
+SourceMapGenerator which contains all the mappings between the generated and
+original sources.
+
+The arguments are the same as those to `new SourceMapGenerator`.
+
+```js
+var node = new SourceNode(1, 2, "a.js", [
+  new SourceNode(3, 4, "b.js", "uno"),
+  "dos",
+  [
+    "tres",
+    new SourceNode(5, 6, "c.js", "quatro")
+  ]
+]);
+
+node.toStringWithSourceMap({ file: "my-output-file.js" })
+// { code: 'unodostresquatro',
+//   map: [object SourceMapGenerator] }
+```
diff --git a/node_modules/@babel/core/node_modules/source-map/dist/source-map.debug.js b/node_modules/@babel/core/node_modules/source-map/dist/source-map.debug.js
new file mode 100644
index 00000000..b5ab6382
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/source-map/dist/source-map.debug.js
@@ -0,0 +1,3091 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], 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) {
+	    // When aOriginal is truthy but has empty values for .line and .column,
+	    // it is most likely a programmer error. In this case we throw a very
+	    // specific error message to try to guide them the right way.
+	    // For example: https://github.com/Polymer/polymer-bundler/pull/519
+	    if (aOriginal && typeof aOriginal.line !== 'number' && typeof aOriginal.column !== 'number') {
+	        throw new Error(
+	            'original.line and original.column are not numbers -- you probably meant to omit ' +
+	            'the original mapping entirely and only map the generated position. If so, pass ' +
+	            'null for the original mapping instead of an object with empty or null values.'
+	        );
+	    }
+	
+	    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 consecutive 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;
+	var hasNativeMap = typeof Map !== "undefined";
+	
+	/**
+	 * 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 = hasNativeMap ? new Map() : 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 hasNativeMap ? this._set.size : 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 = hasNativeMap ? aStr : util.toSetString(aStr);
+	  var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
+	  var idx = this._array.length;
+	  if (!isDuplicate || aAllowDuplicates) {
+	    this._array.push(aStr);
+	  }
+	  if (!isDuplicate) {
+	    if (hasNativeMap) {
+	      this._set.set(aStr, idx);
+	    } else {
+	      this._set[sStr] = idx;
+	    }
+	  }
+	};
+	
+	/**
+	 * Is the given string a member of this set?
+	 *
+	 * @param String aStr
+	 */
+	ArraySet.prototype.has = function ArraySet_has(aStr) {
+	  if (hasNativeMap) {
+	    return this._set.has(aStr);
+	  } else {
+	    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) {
+	  if (hasNativeMap) {
+	    var idx = this._set.get(aStr);
+	    if (idx >= 0) {
+	        return idx;
+	    }
+	  } else {
+	    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 accessed by calling `shiftNextLine`.
+	    var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
+	    var remainingLinesIndex = 0;
+	    var shiftNextLine = function() {
+	      var lineContents = getNextLine();
+	      // The last line of a file might not have a newline.
+	      var newLine = getNextLine() || "";
+	      return lineContents + newLine;
+	
+	      function getNextLine() {
+	        return remainingLinesIndex < remainingLines.length ?
+	            remainingLines[remainingLinesIndex++] : undefined;
+	      }
+	    };
+	
+	    // 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[remainingLinesIndex];
+	          var code = nextLine.substr(0, mapping.generatedColumn -
+	                                        lastGeneratedColumn);
+	          remainingLines[remainingLinesIndex] = 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[remainingLinesIndex];
+	        node.add(nextLine.substr(0, mapping.generatedColumn));
+	        remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
+	        lastGeneratedColumn = mapping.generatedColumn;
+	      }
+	      lastMapping = mapping;
+	    }, this);
+	    // We have processed all mappings.
+	    if (remainingLinesIndex < remainingLines.length) {
+	      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.splice(remainingLinesIndex).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) {
+	        node.add(code);
+	      } else {
+	        var source = aRelativePath
+	          ? util.join(aRelativePath, mapping.source)
+	          : mapping.source;
+	        node.add(new SourceNode(mapping.originalLine,
+	                                mapping.originalColumn,
+	                                source,
+	                                code,
+	                                mapping.name));
+	      }
+	    }
+	  };
+	
+	/**
+	 * Add a chunk of generated JS to this source node.
+	 *
+	 * @param aChunk A string snippet of generated JS code, another instance of
+	 *        SourceNode, or an array where each member is one of those things.
+	 */
+	SourceNode.prototype.add = function SourceNode_add(aChunk) {
+	  if (Array.isArray(aChunk)) {
+	    aChunk.forEach(function (chunk) {
+	      this.add(chunk);
+	    }, this);
+	  }
+	  else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+	    if (aChunk) {
+	      this.children.push(aChunk);
+	    }
+	  }
+	  else {
+	    throw new TypeError(
+	      "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+	    );
+	  }
+	  return this;
+	};
+	
+	/**
+	 * Add a chunk of generated JS to the beginning of this source node.
+	 *
+	 * @param aChunk A string snippet of generated JS code, another instance of
+	 *        SourceNode, or an array where each member is one of those things.
+	 */
+	SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
+	  if (Array.isArray(aChunk)) {
+	    for (var i = aChunk.length-1; i >= 0; i--) {
+	      this.prepend(aChunk[i]);
+	    }
+	  }
+	  else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+	    this.children.unshift(aChunk);
+	  }
+	  else {
+	    throw new TypeError(
+	      "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+	    );
+	  }
+	  return this;
+	};
+	
+	/**
+	 * Walk over the tree of JS snippets in this node and its children. The
+	 * walking function is called once for each snippet of JS and is passed that
+	 * snippet and the its original associated source's line/column location.
+	 *
+	 * @param aFn The traversal function.
+	 */
+	SourceNode.prototype.walk = function SourceNode_walk(aFn) {
+	  var chunk;
+	  for (var i = 0, len = this.children.length; i < len; i++) {
+	    chunk = this.children[i];
+	    if (chunk[isSourceNode]) {
+	      chunk.walk(aFn);
+	    }
+	    else {
+	      if (chunk !== '') {
+	        aFn(chunk, { source: this.source,
+	                     line: this.line,
+	                     column: this.column,
+	                     name: this.name });
+	      }
+	    }
+	  }
+	};
+	
+	/**
+	 * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
+	 * each of `this.children`.
+	 *
+	 * @param aSep The separator.
+	 */
+	SourceNode.prototype.join = function SourceNode_join(aSep) {
+	  var newChildren;
+	  var i;
+	  var len = this.children.length;
+	  if (len > 0) {
+	    newChildren = [];
+	    for (i = 0; i < len-1; i++) {
+	      newChildren.push(this.children[i]);
+	      newChildren.push(aSep);
+	    }
+	    newChildren.push(this.children[i]);
+	    this.children = newChildren;
+	  }
+	  return this;
+	};
+	
+	/**
+	 * Call String.prototype.replace on the very right-most source snippet. Useful
+	 * for trimming whitespace from the end of a source node, etc.
+	 *
+	 * @param aPattern The pattern to replace.
+	 * @param aReplacement The thing to replace the pattern with.
+	 */
+	SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
+	  var lastChild = this.children[this.children.length - 1];
+	  if (lastChild[isSourceNode]) {
+	    lastChild.replaceRight(aPattern, aReplacement);
+	  }
+	  else if (typeof lastChild === 'string') {
+	    this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
+	  }
+	  else {
+	    this.children.push(''.replace(aPattern, aReplacement));
+	  }
+	  return this;
+	};
+	
+	/**
+	 * Set the source content for a source file. This will be added to the SourceMapGenerator
+	 * in the sourcesContent field.
+	 *
+	 * @param aSourceFile The filename of the source file
+	 * @param aSourceContent The content of the source file
+	 */
+	SourceNode.prototype.setSourceContent =
+	  function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
+	    this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
+	  };
+	
+	/**
+	 * Walk over the tree of SourceNodes. The walking function is called for each
+	 * source file content and is passed the filename and source content.
+	 *
+	 * @param aFn The traversal function.
+	 */
+	SourceNode.prototype.walkSourceContents =
+	  function SourceNode_walkSourceContents(aFn) {
+	    for (var i = 0, len = this.children.length; i < len; i++) {
+	      if (this.children[i][isSourceNode]) {
+	        this.children[i].walkSourceContents(aFn);
+	      }
+	    }
+	
+	    var sources = Object.keys(this.sourceContents);
+	    for (var i = 0, len = sources.length; i < len; i++) {
+	      aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
+	    }
+	  };
+	
+	/**
+	 * Return the string representation of this source node. Walks over the tree
+	 * and concatenates all the various snippets together to one string.
+	 */
+	SourceNode.prototype.toString = function SourceNode_toString() {
+	  var str = "";
+	  this.walk(function (chunk) {
+	    str += chunk;
+	  });
+	  return str;
+	};
+	
+	/**
+	 * Returns the string representation of this source node along with a source
+	 * map.
+	 */
+	SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
+	  var generated = {
+	    code: "",
+	    line: 1,
+	    column: 0
+	  };
+	  var map = new SourceMapGenerator(aArgs);
+	  var sourceMappingActive = false;
+	  var lastOriginalSource = null;
+	  var lastOriginalLine = null;
+	  var lastOriginalColumn = null;
+	  var lastOriginalName = null;
+	  this.walk(function (chunk, original) {
+	    generated.code += chunk;
+	    if (original.source !== null
+	        && original.line !== null
+	        && original.column !== null) {
+	      if(lastOriginalSource !== original.source
+	         || lastOriginalLine !== original.line
+	         || lastOriginalColumn !== original.column
+	         || lastOriginalName !== original.name) {
+	        map.addMapping({
+	          source: original.source,
+	          original: {
+	            line: original.line,
+	            column: original.column
+	          },
+	          generated: {
+	            line: generated.line,
+	            column: generated.column
+	          },
+	          name: original.name
+	        });
+	      }
+	      lastOriginalSource = original.source;
+	      lastOriginalLine = original.line;
+	      lastOriginalColumn = original.column;
+	      lastOriginalName = original.name;
+	      sourceMappingActive = true;
+	    } else if (sourceMappingActive) {
+	      map.addMapping({
+	        generated: {
+	          line: generated.line,
+	          column: generated.column
+	        }
+	      });
+	      lastOriginalSource = null;
+	      sourceMappingActive = false;
+	    }
+	    for (var idx = 0, length = chunk.length; idx < length; idx++) {
+	      if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
+	        generated.line++;
+	        generated.column = 0;
+	        // Mappings end at eol
+	        if (idx + 1 === length) {
+	          lastOriginalSource = null;
+	          sourceMappingActive = false;
+	        } else if (sourceMappingActive) {
+	          map.addMapping({
+	            source: original.source,
+	            original: {
+	              line: original.line,
+	              column: original.column
+	            },
+	            generated: {
+	              line: generated.line,
+	              column: generated.column
+	            },
+	            name: original.name
+	          });
+	        }
+	      } else {
+	        generated.column++;
+	      }
+	    }
+	  });
+	  this.walkSourceContents(function (sourceFile, sourceContent) {
+	    map.setSourceContent(sourceFile, sourceContent);
+	  });
+	
+	  return { code: generated.code, map: map };
+	};
+	
+	exports.SourceNode = SourceNode;
+
+
+/***/ })
+/******/ ])
+});
+;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack:///webpack/universalModuleDefinition","webpack:///webpack/bootstrap e4738fc72a7b23039889","webpack:///./source-map.js","webpack:///./lib/source-map-generator.js","webpack:///./lib/base64-vlq.js","webpack:///./lib/base64.js","webpack:///./lib/util.js","webpack:///./lib/array-set.js","webpack:///./lib/mapping-list.js","webpack:///./lib/source-map-consumer.js","webpack:///./lib/binary-search.js","webpack:///./lib/quick-sort.js","webpack:///./lib/source-node.js"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD,O;ACVA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,uBAAe;AACf;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;;;;;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACPA,iBAAgB,oBAAoB;AACpC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,MAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAO;AACP;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,2CAA0C,SAAS;AACnD;AACA;;AAEA;AACA;AACA;AACA,qBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC/ZA,iBAAgB,oBAAoB;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4DAA2D;AAC3D,qBAAoB;AACpB;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;;AAEH;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,IAAG;;AAEH;AACA;AACA;;;;;;;AC3IA,iBAAgB,oBAAoB;AACpC;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,iBAAgB;AAChB,iBAAgB;;AAEhB,oBAAmB;AACnB,qBAAoB;;AAEpB,iBAAgB;AAChB,iBAAgB;;AAEhB,iBAAgB;AAChB,kBAAiB;;AAEjB;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;;;;;;AClEA,iBAAgB,oBAAoB;AACpC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA,IAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,+CAA8C,QAAQ;AACtD;AACA;AACA;AACA,MAAK;AACL;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,QAAO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,EAAC;;AAED;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,4BAA2B,QAAQ;AACnC;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;;;;;;AChaA,iBAAgB,oBAAoB;AACpC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,uCAAsC,SAAS;AAC/C;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACxHA,iBAAgB,oBAAoB;AACpC;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAgB;AAChB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC9EA,iBAAgB,oBAAoB;AACpC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,uDAAsD;AACtD;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,EAAC;;AAED;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,EAAC;;AAED;AACA;AACA;AACA,oBAAmB;AACnB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAW;;AAEX;AACA;AACA,QAAO;AACP;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAW;;AAEX;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA2B,MAAM;AACjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uDAAsD;AACtD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,uDAAsD,YAAY;AAClE;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA,EAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,oCAAmC;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,0BAAyB,cAAc;AACvC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAuB,wCAAwC;AAC/D;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAA+C,mBAAmB,EAAE;AACpE;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAiB,oBAAoB;AACrC;AACA;AACA;AACA;AACA;AACA,8BAA6B,MAAM;AACnC;AACA,QAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uDAAsD;AACtD;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,QAAO;AACP;AACA;AACA,IAAG;AACH;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAmB,2BAA2B;AAC9C,sBAAqB,+CAA+C;AACpE;AACA;AACA;AACA;AACA;AACA,EAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,QAAO;AACP;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAmB,2BAA2B;AAC9C;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAmB,2BAA2B;AAC9C;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAmB,2BAA2B;AAC9C;AACA;AACA,sBAAqB,4BAA4B;AACjD;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;;;;;;ACzjCA,iBAAgB,oBAAoB;AACpC;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;;;;;AC9GA,iBAAgB,oBAAoB;AACpC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,YAAW,MAAM;AACjB;AACA,YAAW,OAAO;AAClB;AACA,YAAW,OAAO;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,YAAW,OAAO;AAClB;AACA,YAAW,OAAO;AAClB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,YAAW,MAAM;AACjB;AACA,YAAW,SAAS;AACpB;AACA,YAAW,OAAO;AAClB;AACA,YAAW,OAAO;AAClB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAmB,OAAO;AAC1B;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,YAAW,MAAM;AACjB;AACA,YAAW,SAAS;AACpB;AACA;AACA;AACA;AACA;;;;;;;ACjHA,iBAAgB,oBAAoB;AACpC;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;;AAEL;;AAEA;AACA;AACA;AACA,QAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAiC,QAAQ;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA6C,SAAS;AACtD;AACA;AACA;AACA;AACA;AACA;AACA,qBAAoB;AACpB;AACA;AACA,uCAAsC;AACtC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAe,WAAW;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAA+C,SAAS;AACxD;AACA;AACA;AACA;;AAEA;AACA,0CAAyC,SAAS;AAClD;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAW;AACX;AACA;AACA;AACA,YAAW;AACX;AACA,UAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA,QAAO;AACP;AACA;AACA;AACA,6CAA4C,cAAc;AAC1D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAS;AACT;AACA;AACA;AACA;AACA;AACA,cAAa;AACb;AACA;AACA;AACA,cAAa;AACb;AACA,YAAW;AACX;AACA,QAAO;AACP;AACA;AACA;AACA,IAAG;AACH;AACA;AACA,IAAG;;AAEH,WAAU;AACV;;AAEA","file":"source-map.debug.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"sourceMap\"] = factory();\n\telse\n\t\troot[\"sourceMap\"] = factory();\n})(this, function() {\nreturn \n\n\n// WEBPACK FOOTER //\n// webpack/universalModuleDefinition"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.loaded = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap e4738fc72a7b23039889","/*\n * Copyright 2009-2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE.txt or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\nexports.SourceMapGenerator = require('./lib/source-map-generator').SourceMapGenerator;\nexports.SourceMapConsumer = require('./lib/source-map-consumer').SourceMapConsumer;\nexports.SourceNode = require('./lib/source-node').SourceNode;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./source-map.js\n// module id = 0\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar base64VLQ = require('./base64-vlq');\nvar util = require('./util');\nvar ArraySet = require('./array-set').ArraySet;\nvar MappingList = require('./mapping-list').MappingList;\n\n/**\n * An instance of the SourceMapGenerator represents a source map which is\n * being built incrementally. You may pass an object with the following\n * properties:\n *\n *   - file: The filename of the generated source.\n *   - sourceRoot: A root for all relative URLs in this source map.\n */\nfunction SourceMapGenerator(aArgs) {\n  if (!aArgs) {\n    aArgs = {};\n  }\n  this._file = util.getArg(aArgs, 'file', null);\n  this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);\n  this._skipValidation = util.getArg(aArgs, 'skipValidation', false);\n  this._sources = new ArraySet();\n  this._names = new ArraySet();\n  this._mappings = new MappingList();\n  this._sourcesContents = null;\n}\n\nSourceMapGenerator.prototype._version = 3;\n\n/**\n * Creates a new SourceMapGenerator based on a SourceMapConsumer\n *\n * @param aSourceMapConsumer The SourceMap.\n */\nSourceMapGenerator.fromSourceMap =\n  function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {\n    var sourceRoot = aSourceMapConsumer.sourceRoot;\n    var generator = new SourceMapGenerator({\n      file: aSourceMapConsumer.file,\n      sourceRoot: sourceRoot\n    });\n    aSourceMapConsumer.eachMapping(function (mapping) {\n      var newMapping = {\n        generated: {\n          line: mapping.generatedLine,\n          column: mapping.generatedColumn\n        }\n      };\n\n      if (mapping.source != null) {\n        newMapping.source = mapping.source;\n        if (sourceRoot != null) {\n          newMapping.source = util.relative(sourceRoot, newMapping.source);\n        }\n\n        newMapping.original = {\n          line: mapping.originalLine,\n          column: mapping.originalColumn\n        };\n\n        if (mapping.name != null) {\n          newMapping.name = mapping.name;\n        }\n      }\n\n      generator.addMapping(newMapping);\n    });\n    aSourceMapConsumer.sources.forEach(function (sourceFile) {\n      var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n      if (content != null) {\n        generator.setSourceContent(sourceFile, content);\n      }\n    });\n    return generator;\n  };\n\n/**\n * Add a single mapping from original source line and column to the generated\n * source's line and column for this source map being created. The mapping\n * object should have the following properties:\n *\n *   - generated: An object with the generated line and column positions.\n *   - original: An object with the original line and column positions.\n *   - source: The original source file (relative to the sourceRoot).\n *   - name: An optional original token name for this mapping.\n */\nSourceMapGenerator.prototype.addMapping =\n  function SourceMapGenerator_addMapping(aArgs) {\n    var generated = util.getArg(aArgs, 'generated');\n    var original = util.getArg(aArgs, 'original', null);\n    var source = util.getArg(aArgs, 'source', null);\n    var name = util.getArg(aArgs, 'name', null);\n\n    if (!this._skipValidation) {\n      this._validateMapping(generated, original, source, name);\n    }\n\n    if (source != null) {\n      source = String(source);\n      if (!this._sources.has(source)) {\n        this._sources.add(source);\n      }\n    }\n\n    if (name != null) {\n      name = String(name);\n      if (!this._names.has(name)) {\n        this._names.add(name);\n      }\n    }\n\n    this._mappings.add({\n      generatedLine: generated.line,\n      generatedColumn: generated.column,\n      originalLine: original != null && original.line,\n      originalColumn: original != null && original.column,\n      source: source,\n      name: name\n    });\n  };\n\n/**\n * Set the source content for a source file.\n */\nSourceMapGenerator.prototype.setSourceContent =\n  function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {\n    var source = aSourceFile;\n    if (this._sourceRoot != null) {\n      source = util.relative(this._sourceRoot, source);\n    }\n\n    if (aSourceContent != null) {\n      // Add the source content to the _sourcesContents map.\n      // Create a new _sourcesContents map if the property is null.\n      if (!this._sourcesContents) {\n        this._sourcesContents = Object.create(null);\n      }\n      this._sourcesContents[util.toSetString(source)] = aSourceContent;\n    } else if (this._sourcesContents) {\n      // Remove the source file from the _sourcesContents map.\n      // If the _sourcesContents map is empty, set the property to null.\n      delete this._sourcesContents[util.toSetString(source)];\n      if (Object.keys(this._sourcesContents).length === 0) {\n        this._sourcesContents = null;\n      }\n    }\n  };\n\n/**\n * Applies the mappings of a sub-source-map for a specific source file to the\n * source map being generated. Each mapping to the supplied source file is\n * rewritten using the supplied source map. Note: The resolution for the\n * resulting mappings is the minimium of this map and the supplied map.\n *\n * @param aSourceMapConsumer The source map to be applied.\n * @param aSourceFile Optional. The filename of the source file.\n *        If omitted, SourceMapConsumer's file property will be used.\n * @param aSourceMapPath Optional. The dirname of the path to the source map\n *        to be applied. If relative, it is relative to the SourceMapConsumer.\n *        This parameter is needed when the two source maps aren't in the same\n *        directory, and the source map to be applied contains relative source\n *        paths. If so, those relative source paths need to be rewritten\n *        relative to the SourceMapGenerator.\n */\nSourceMapGenerator.prototype.applySourceMap =\n  function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {\n    var sourceFile = aSourceFile;\n    // If aSourceFile is omitted, we will use the file property of the SourceMap\n    if (aSourceFile == null) {\n      if (aSourceMapConsumer.file == null) {\n        throw new Error(\n          'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +\n          'or the source map\\'s \"file\" property. Both were omitted.'\n        );\n      }\n      sourceFile = aSourceMapConsumer.file;\n    }\n    var sourceRoot = this._sourceRoot;\n    // Make \"sourceFile\" relative if an absolute Url is passed.\n    if (sourceRoot != null) {\n      sourceFile = util.relative(sourceRoot, sourceFile);\n    }\n    // Applying the SourceMap can add and remove items from the sources and\n    // the names array.\n    var newSources = new ArraySet();\n    var newNames = new ArraySet();\n\n    // Find mappings for the \"sourceFile\"\n    this._mappings.unsortedForEach(function (mapping) {\n      if (mapping.source === sourceFile && mapping.originalLine != null) {\n        // Check if it can be mapped by the source map, then update the mapping.\n        var original = aSourceMapConsumer.originalPositionFor({\n          line: mapping.originalLine,\n          column: mapping.originalColumn\n        });\n        if (original.source != null) {\n          // Copy mapping\n          mapping.source = original.source;\n          if (aSourceMapPath != null) {\n            mapping.source = util.join(aSourceMapPath, mapping.source)\n          }\n          if (sourceRoot != null) {\n            mapping.source = util.relative(sourceRoot, mapping.source);\n          }\n          mapping.originalLine = original.line;\n          mapping.originalColumn = original.column;\n          if (original.name != null) {\n            mapping.name = original.name;\n          }\n        }\n      }\n\n      var source = mapping.source;\n      if (source != null && !newSources.has(source)) {\n        newSources.add(source);\n      }\n\n      var name = mapping.name;\n      if (name != null && !newNames.has(name)) {\n        newNames.add(name);\n      }\n\n    }, this);\n    this._sources = newSources;\n    this._names = newNames;\n\n    // Copy sourcesContents of applied map.\n    aSourceMapConsumer.sources.forEach(function (sourceFile) {\n      var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n      if (content != null) {\n        if (aSourceMapPath != null) {\n          sourceFile = util.join(aSourceMapPath, sourceFile);\n        }\n        if (sourceRoot != null) {\n          sourceFile = util.relative(sourceRoot, sourceFile);\n        }\n        this.setSourceContent(sourceFile, content);\n      }\n    }, this);\n  };\n\n/**\n * A mapping can have one of the three levels of data:\n *\n *   1. Just the generated position.\n *   2. The Generated position, original position, and original source.\n *   3. Generated and original position, original source, as well as a name\n *      token.\n *\n * To maintain consistency, we validate that any new mapping being added falls\n * in to one of these categories.\n */\nSourceMapGenerator.prototype._validateMapping =\n  function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,\n                                              aName) {\n    // When aOriginal is truthy but has empty values for .line and .column,\n    // it is most likely a programmer error. In this case we throw a very\n    // specific error message to try to guide them the right way.\n    // For example: https://github.com/Polymer/polymer-bundler/pull/519\n    if (aOriginal && typeof aOriginal.line !== 'number' && typeof aOriginal.column !== 'number') {\n        throw new Error(\n            'original.line and original.column are not numbers -- you probably meant to omit ' +\n            'the original mapping entirely and only map the generated position. If so, pass ' +\n            'null for the original mapping instead of an object with empty or null values.'\n        );\n    }\n\n    if (aGenerated && 'line' in aGenerated && 'column' in aGenerated\n        && aGenerated.line > 0 && aGenerated.column >= 0\n        && !aOriginal && !aSource && !aName) {\n      // Case 1.\n      return;\n    }\n    else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated\n             && aOriginal && 'line' in aOriginal && 'column' in aOriginal\n             && aGenerated.line > 0 && aGenerated.column >= 0\n             && aOriginal.line > 0 && aOriginal.column >= 0\n             && aSource) {\n      // Cases 2 and 3.\n      return;\n    }\n    else {\n      throw new Error('Invalid mapping: ' + JSON.stringify({\n        generated: aGenerated,\n        source: aSource,\n        original: aOriginal,\n        name: aName\n      }));\n    }\n  };\n\n/**\n * Serialize the accumulated mappings in to the stream of base 64 VLQs\n * specified by the source map format.\n */\nSourceMapGenerator.prototype._serializeMappings =\n  function SourceMapGenerator_serializeMappings() {\n    var previousGeneratedColumn = 0;\n    var previousGeneratedLine = 1;\n    var previousOriginalColumn = 0;\n    var previousOriginalLine = 0;\n    var previousName = 0;\n    var previousSource = 0;\n    var result = '';\n    var next;\n    var mapping;\n    var nameIdx;\n    var sourceIdx;\n\n    var mappings = this._mappings.toArray();\n    for (var i = 0, len = mappings.length; i < len; i++) {\n      mapping = mappings[i];\n      next = ''\n\n      if (mapping.generatedLine !== previousGeneratedLine) {\n        previousGeneratedColumn = 0;\n        while (mapping.generatedLine !== previousGeneratedLine) {\n          next += ';';\n          previousGeneratedLine++;\n        }\n      }\n      else {\n        if (i > 0) {\n          if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {\n            continue;\n          }\n          next += ',';\n        }\n      }\n\n      next += base64VLQ.encode(mapping.generatedColumn\n                                 - previousGeneratedColumn);\n      previousGeneratedColumn = mapping.generatedColumn;\n\n      if (mapping.source != null) {\n        sourceIdx = this._sources.indexOf(mapping.source);\n        next += base64VLQ.encode(sourceIdx - previousSource);\n        previousSource = sourceIdx;\n\n        // lines are stored 0-based in SourceMap spec version 3\n        next += base64VLQ.encode(mapping.originalLine - 1\n                                   - previousOriginalLine);\n        previousOriginalLine = mapping.originalLine - 1;\n\n        next += base64VLQ.encode(mapping.originalColumn\n                                   - previousOriginalColumn);\n        previousOriginalColumn = mapping.originalColumn;\n\n        if (mapping.name != null) {\n          nameIdx = this._names.indexOf(mapping.name);\n          next += base64VLQ.encode(nameIdx - previousName);\n          previousName = nameIdx;\n        }\n      }\n\n      result += next;\n    }\n\n    return result;\n  };\n\nSourceMapGenerator.prototype._generateSourcesContent =\n  function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {\n    return aSources.map(function (source) {\n      if (!this._sourcesContents) {\n        return null;\n      }\n      if (aSourceRoot != null) {\n        source = util.relative(aSourceRoot, source);\n      }\n      var key = util.toSetString(source);\n      return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)\n        ? this._sourcesContents[key]\n        : null;\n    }, this);\n  };\n\n/**\n * Externalize the source map.\n */\nSourceMapGenerator.prototype.toJSON =\n  function SourceMapGenerator_toJSON() {\n    var map = {\n      version: this._version,\n      sources: this._sources.toArray(),\n      names: this._names.toArray(),\n      mappings: this._serializeMappings()\n    };\n    if (this._file != null) {\n      map.file = this._file;\n    }\n    if (this._sourceRoot != null) {\n      map.sourceRoot = this._sourceRoot;\n    }\n    if (this._sourcesContents) {\n      map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);\n    }\n\n    return map;\n  };\n\n/**\n * Render the source map being generated to a string.\n */\nSourceMapGenerator.prototype.toString =\n  function SourceMapGenerator_toString() {\n    return JSON.stringify(this.toJSON());\n  };\n\nexports.SourceMapGenerator = SourceMapGenerator;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/source-map-generator.js\n// module id = 1\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n *\n * Based on the Base 64 VLQ implementation in Closure Compiler:\n * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java\n *\n * Copyright 2011 The Closure Compiler Authors. All rights reserved.\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n *  * Redistributions of source code must retain the above copyright\n *    notice, this list of conditions and the following disclaimer.\n *  * Redistributions in binary form must reproduce the above\n *    copyright notice, this list of conditions and the following\n *    disclaimer in the documentation and/or other materials provided\n *    with the distribution.\n *  * Neither the name of Google Inc. nor the names of its\n *    contributors may be used to endorse or promote products derived\n *    from this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\nvar base64 = require('./base64');\n\n// A single base 64 digit can contain 6 bits of data. For the base 64 variable\n// length quantities we use in the source map spec, the first bit is the sign,\n// the next four bits are the actual value, and the 6th bit is the\n// continuation bit. The continuation bit tells us whether there are more\n// digits in this value following this digit.\n//\n//   Continuation\n//   |    Sign\n//   |    |\n//   V    V\n//   101011\n\nvar VLQ_BASE_SHIFT = 5;\n\n// binary: 100000\nvar VLQ_BASE = 1 << VLQ_BASE_SHIFT;\n\n// binary: 011111\nvar VLQ_BASE_MASK = VLQ_BASE - 1;\n\n// binary: 100000\nvar VLQ_CONTINUATION_BIT = VLQ_BASE;\n\n/**\n * Converts from a two-complement value to a value where the sign bit is\n * placed in the least significant bit.  For example, as decimals:\n *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)\n *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)\n */\nfunction toVLQSigned(aValue) {\n  return aValue < 0\n    ? ((-aValue) << 1) + 1\n    : (aValue << 1) + 0;\n}\n\n/**\n * Converts to a two-complement value from a value where the sign bit is\n * placed in the least significant bit.  For example, as decimals:\n *   2 (10 binary) becomes 1, 3 (11 binary) becomes -1\n *   4 (100 binary) becomes 2, 5 (101 binary) becomes -2\n */\nfunction fromVLQSigned(aValue) {\n  var isNegative = (aValue & 1) === 1;\n  var shifted = aValue >> 1;\n  return isNegative\n    ? -shifted\n    : shifted;\n}\n\n/**\n * Returns the base 64 VLQ encoded value.\n */\nexports.encode = function base64VLQ_encode(aValue) {\n  var encoded = \"\";\n  var digit;\n\n  var vlq = toVLQSigned(aValue);\n\n  do {\n    digit = vlq & VLQ_BASE_MASK;\n    vlq >>>= VLQ_BASE_SHIFT;\n    if (vlq > 0) {\n      // There are still more digits in this value, so we must make sure the\n      // continuation bit is marked.\n      digit |= VLQ_CONTINUATION_BIT;\n    }\n    encoded += base64.encode(digit);\n  } while (vlq > 0);\n\n  return encoded;\n};\n\n/**\n * Decodes the next base 64 VLQ value from the given string and returns the\n * value and the rest of the string via the out parameter.\n */\nexports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {\n  var strLen = aStr.length;\n  var result = 0;\n  var shift = 0;\n  var continuation, digit;\n\n  do {\n    if (aIndex >= strLen) {\n      throw new Error(\"Expected more digits in base 64 VLQ value.\");\n    }\n\n    digit = base64.decode(aStr.charCodeAt(aIndex++));\n    if (digit === -1) {\n      throw new Error(\"Invalid base64 digit: \" + aStr.charAt(aIndex - 1));\n    }\n\n    continuation = !!(digit & VLQ_CONTINUATION_BIT);\n    digit &= VLQ_BASE_MASK;\n    result = result + (digit << shift);\n    shift += VLQ_BASE_SHIFT;\n  } while (continuation);\n\n  aOutParam.value = fromVLQSigned(result);\n  aOutParam.rest = aIndex;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/base64-vlq.js\n// module id = 2\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar intToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');\n\n/**\n * Encode an integer in the range of 0 to 63 to a single base 64 digit.\n */\nexports.encode = function (number) {\n  if (0 <= number && number < intToCharMap.length) {\n    return intToCharMap[number];\n  }\n  throw new TypeError(\"Must be between 0 and 63: \" + number);\n};\n\n/**\n * Decode a single base 64 character code digit to an integer. Returns -1 on\n * failure.\n */\nexports.decode = function (charCode) {\n  var bigA = 65;     // 'A'\n  var bigZ = 90;     // 'Z'\n\n  var littleA = 97;  // 'a'\n  var littleZ = 122; // 'z'\n\n  var zero = 48;     // '0'\n  var nine = 57;     // '9'\n\n  var plus = 43;     // '+'\n  var slash = 47;    // '/'\n\n  var littleOffset = 26;\n  var numberOffset = 52;\n\n  // 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ\n  if (bigA <= charCode && charCode <= bigZ) {\n    return (charCode - bigA);\n  }\n\n  // 26 - 51: abcdefghijklmnopqrstuvwxyz\n  if (littleA <= charCode && charCode <= littleZ) {\n    return (charCode - littleA + littleOffset);\n  }\n\n  // 52 - 61: 0123456789\n  if (zero <= charCode && charCode <= nine) {\n    return (charCode - zero + numberOffset);\n  }\n\n  // 62: +\n  if (charCode == plus) {\n    return 62;\n  }\n\n  // 63: /\n  if (charCode == slash) {\n    return 63;\n  }\n\n  // Invalid base64 digit.\n  return -1;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/base64.js\n// module id = 3\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\n/**\n * This is a helper function for getting values from parameter/options\n * objects.\n *\n * @param args The object we are extracting values from\n * @param name The name of the property we are getting.\n * @param defaultValue An optional value to return if the property is missing\n * from the object. If this is not specified and the property is missing, an\n * error will be thrown.\n */\nfunction getArg(aArgs, aName, aDefaultValue) {\n  if (aName in aArgs) {\n    return aArgs[aName];\n  } else if (arguments.length === 3) {\n    return aDefaultValue;\n  } else {\n    throw new Error('\"' + aName + '\" is a required argument.');\n  }\n}\nexports.getArg = getArg;\n\nvar urlRegexp = /^(?:([\\w+\\-.]+):)?\\/\\/(?:(\\w+:\\w+)@)?([\\w.]*)(?::(\\d+))?(\\S*)$/;\nvar dataUrlRegexp = /^data:.+\\,.+$/;\n\nfunction urlParse(aUrl) {\n  var match = aUrl.match(urlRegexp);\n  if (!match) {\n    return null;\n  }\n  return {\n    scheme: match[1],\n    auth: match[2],\n    host: match[3],\n    port: match[4],\n    path: match[5]\n  };\n}\nexports.urlParse = urlParse;\n\nfunction urlGenerate(aParsedUrl) {\n  var url = '';\n  if (aParsedUrl.scheme) {\n    url += aParsedUrl.scheme + ':';\n  }\n  url += '//';\n  if (aParsedUrl.auth) {\n    url += aParsedUrl.auth + '@';\n  }\n  if (aParsedUrl.host) {\n    url += aParsedUrl.host;\n  }\n  if (aParsedUrl.port) {\n    url += \":\" + aParsedUrl.port\n  }\n  if (aParsedUrl.path) {\n    url += aParsedUrl.path;\n  }\n  return url;\n}\nexports.urlGenerate = urlGenerate;\n\n/**\n * Normalizes a path, or the path portion of a URL:\n *\n * - Replaces consecutive slashes with one slash.\n * - Removes unnecessary '.' parts.\n * - Removes unnecessary '<dir>/..' parts.\n *\n * Based on code in the Node.js 'path' core module.\n *\n * @param aPath The path or url to normalize.\n */\nfunction normalize(aPath) {\n  var path = aPath;\n  var url = urlParse(aPath);\n  if (url) {\n    if (!url.path) {\n      return aPath;\n    }\n    path = url.path;\n  }\n  var isAbsolute = exports.isAbsolute(path);\n\n  var parts = path.split(/\\/+/);\n  for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {\n    part = parts[i];\n    if (part === '.') {\n      parts.splice(i, 1);\n    } else if (part === '..') {\n      up++;\n    } else if (up > 0) {\n      if (part === '') {\n        // The first part is blank if the path is absolute. Trying to go\n        // above the root is a no-op. Therefore we can remove all '..' parts\n        // directly after the root.\n        parts.splice(i + 1, up);\n        up = 0;\n      } else {\n        parts.splice(i, 2);\n        up--;\n      }\n    }\n  }\n  path = parts.join('/');\n\n  if (path === '') {\n    path = isAbsolute ? '/' : '.';\n  }\n\n  if (url) {\n    url.path = path;\n    return urlGenerate(url);\n  }\n  return path;\n}\nexports.normalize = normalize;\n\n/**\n * Joins two paths/URLs.\n *\n * @param aRoot The root path or URL.\n * @param aPath The path or URL to be joined with the root.\n *\n * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a\n *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended\n *   first.\n * - Otherwise aPath is a path. If aRoot is a URL, then its path portion\n *   is updated with the result and aRoot is returned. Otherwise the result\n *   is returned.\n *   - If aPath is absolute, the result is aPath.\n *   - Otherwise the two paths are joined with a slash.\n * - Joining for example 'http://' and 'www.example.com' is also supported.\n */\nfunction join(aRoot, aPath) {\n  if (aRoot === \"\") {\n    aRoot = \".\";\n  }\n  if (aPath === \"\") {\n    aPath = \".\";\n  }\n  var aPathUrl = urlParse(aPath);\n  var aRootUrl = urlParse(aRoot);\n  if (aRootUrl) {\n    aRoot = aRootUrl.path || '/';\n  }\n\n  // `join(foo, '//www.example.org')`\n  if (aPathUrl && !aPathUrl.scheme) {\n    if (aRootUrl) {\n      aPathUrl.scheme = aRootUrl.scheme;\n    }\n    return urlGenerate(aPathUrl);\n  }\n\n  if (aPathUrl || aPath.match(dataUrlRegexp)) {\n    return aPath;\n  }\n\n  // `join('http://', 'www.example.com')`\n  if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {\n    aRootUrl.host = aPath;\n    return urlGenerate(aRootUrl);\n  }\n\n  var joined = aPath.charAt(0) === '/'\n    ? aPath\n    : normalize(aRoot.replace(/\\/+$/, '') + '/' + aPath);\n\n  if (aRootUrl) {\n    aRootUrl.path = joined;\n    return urlGenerate(aRootUrl);\n  }\n  return joined;\n}\nexports.join = join;\n\nexports.isAbsolute = function (aPath) {\n  return aPath.charAt(0) === '/' || !!aPath.match(urlRegexp);\n};\n\n/**\n * Make a path relative to a URL or another path.\n *\n * @param aRoot The root path or URL.\n * @param aPath The path or URL to be made relative to aRoot.\n */\nfunction relative(aRoot, aPath) {\n  if (aRoot === \"\") {\n    aRoot = \".\";\n  }\n\n  aRoot = aRoot.replace(/\\/$/, '');\n\n  // It is possible for the path to be above the root. In this case, simply\n  // checking whether the root is a prefix of the path won't work. Instead, we\n  // need to remove components from the root one by one, until either we find\n  // a prefix that fits, or we run out of components to remove.\n  var level = 0;\n  while (aPath.indexOf(aRoot + '/') !== 0) {\n    var index = aRoot.lastIndexOf(\"/\");\n    if (index < 0) {\n      return aPath;\n    }\n\n    // If the only part of the root that is left is the scheme (i.e. http://,\n    // file:///, etc.), one or more slashes (/), or simply nothing at all, we\n    // have exhausted all components, so the path is not relative to the root.\n    aRoot = aRoot.slice(0, index);\n    if (aRoot.match(/^([^\\/]+:\\/)?\\/*$/)) {\n      return aPath;\n    }\n\n    ++level;\n  }\n\n  // Make sure we add a \"../\" for each component we removed from the root.\n  return Array(level + 1).join(\"../\") + aPath.substr(aRoot.length + 1);\n}\nexports.relative = relative;\n\nvar supportsNullProto = (function () {\n  var obj = Object.create(null);\n  return !('__proto__' in obj);\n}());\n\nfunction identity (s) {\n  return s;\n}\n\n/**\n * Because behavior goes wacky when you set `__proto__` on objects, we\n * have to prefix all the strings in our set with an arbitrary character.\n *\n * See https://github.com/mozilla/source-map/pull/31 and\n * https://github.com/mozilla/source-map/issues/30\n *\n * @param String aStr\n */\nfunction toSetString(aStr) {\n  if (isProtoString(aStr)) {\n    return '$' + aStr;\n  }\n\n  return aStr;\n}\nexports.toSetString = supportsNullProto ? identity : toSetString;\n\nfunction fromSetString(aStr) {\n  if (isProtoString(aStr)) {\n    return aStr.slice(1);\n  }\n\n  return aStr;\n}\nexports.fromSetString = supportsNullProto ? identity : fromSetString;\n\nfunction isProtoString(s) {\n  if (!s) {\n    return false;\n  }\n\n  var length = s.length;\n\n  if (length < 9 /* \"__proto__\".length */) {\n    return false;\n  }\n\n  if (s.charCodeAt(length - 1) !== 95  /* '_' */ ||\n      s.charCodeAt(length - 2) !== 95  /* '_' */ ||\n      s.charCodeAt(length - 3) !== 111 /* 'o' */ ||\n      s.charCodeAt(length - 4) !== 116 /* 't' */ ||\n      s.charCodeAt(length - 5) !== 111 /* 'o' */ ||\n      s.charCodeAt(length - 6) !== 114 /* 'r' */ ||\n      s.charCodeAt(length - 7) !== 112 /* 'p' */ ||\n      s.charCodeAt(length - 8) !== 95  /* '_' */ ||\n      s.charCodeAt(length - 9) !== 95  /* '_' */) {\n    return false;\n  }\n\n  for (var i = length - 10; i >= 0; i--) {\n    if (s.charCodeAt(i) !== 36 /* '$' */) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Comparator between two mappings where the original positions are compared.\n *\n * Optionally pass in `true` as `onlyCompareGenerated` to consider two\n * mappings with the same original source/line/column, but different generated\n * line and column the same. Useful when searching for a mapping with a\n * stubbed out mapping.\n */\nfunction compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {\n  var cmp = mappingA.source - mappingB.source;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalLine - mappingB.originalLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalColumn - mappingB.originalColumn;\n  if (cmp !== 0 || onlyCompareOriginal) {\n    return cmp;\n  }\n\n  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.generatedLine - mappingB.generatedLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  return mappingA.name - mappingB.name;\n}\nexports.compareByOriginalPositions = compareByOriginalPositions;\n\n/**\n * Comparator between two mappings with deflated source and name indices where\n * the generated positions are compared.\n *\n * Optionally pass in `true` as `onlyCompareGenerated` to consider two\n * mappings with the same generated line and column, but different\n * source/name/original line and column the same. Useful when searching for a\n * mapping with a stubbed out mapping.\n */\nfunction compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {\n  var cmp = mappingA.generatedLine - mappingB.generatedLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n  if (cmp !== 0 || onlyCompareGenerated) {\n    return cmp;\n  }\n\n  cmp = mappingA.source - mappingB.source;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalLine - mappingB.originalLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalColumn - mappingB.originalColumn;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  return mappingA.name - mappingB.name;\n}\nexports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;\n\nfunction strcmp(aStr1, aStr2) {\n  if (aStr1 === aStr2) {\n    return 0;\n  }\n\n  if (aStr1 > aStr2) {\n    return 1;\n  }\n\n  return -1;\n}\n\n/**\n * Comparator between two mappings with inflated source and name strings where\n * the generated positions are compared.\n */\nfunction compareByGeneratedPositionsInflated(mappingA, mappingB) {\n  var cmp = mappingA.generatedLine - mappingB.generatedLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = strcmp(mappingA.source, mappingB.source);\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalLine - mappingB.originalLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalColumn - mappingB.originalColumn;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  return strcmp(mappingA.name, mappingB.name);\n}\nexports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/util.js\n// module id = 4\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar util = require('./util');\nvar has = Object.prototype.hasOwnProperty;\nvar hasNativeMap = typeof Map !== \"undefined\";\n\n/**\n * A data structure which is a combination of an array and a set. Adding a new\n * member is O(1), testing for membership is O(1), and finding the index of an\n * element is O(1). Removing elements from the set is not supported. Only\n * strings are supported for membership.\n */\nfunction ArraySet() {\n  this._array = [];\n  this._set = hasNativeMap ? new Map() : Object.create(null);\n}\n\n/**\n * Static method for creating ArraySet instances from an existing array.\n */\nArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {\n  var set = new ArraySet();\n  for (var i = 0, len = aArray.length; i < len; i++) {\n    set.add(aArray[i], aAllowDuplicates);\n  }\n  return set;\n};\n\n/**\n * Return how many unique items are in this ArraySet. If duplicates have been\n * added, than those do not count towards the size.\n *\n * @returns Number\n */\nArraySet.prototype.size = function ArraySet_size() {\n  return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;\n};\n\n/**\n * Add the given string to this set.\n *\n * @param String aStr\n */\nArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {\n  var sStr = hasNativeMap ? aStr : util.toSetString(aStr);\n  var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);\n  var idx = this._array.length;\n  if (!isDuplicate || aAllowDuplicates) {\n    this._array.push(aStr);\n  }\n  if (!isDuplicate) {\n    if (hasNativeMap) {\n      this._set.set(aStr, idx);\n    } else {\n      this._set[sStr] = idx;\n    }\n  }\n};\n\n/**\n * Is the given string a member of this set?\n *\n * @param String aStr\n */\nArraySet.prototype.has = function ArraySet_has(aStr) {\n  if (hasNativeMap) {\n    return this._set.has(aStr);\n  } else {\n    var sStr = util.toSetString(aStr);\n    return has.call(this._set, sStr);\n  }\n};\n\n/**\n * What is the index of the given string in the array?\n *\n * @param String aStr\n */\nArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {\n  if (hasNativeMap) {\n    var idx = this._set.get(aStr);\n    if (idx >= 0) {\n        return idx;\n    }\n  } else {\n    var sStr = util.toSetString(aStr);\n    if (has.call(this._set, sStr)) {\n      return this._set[sStr];\n    }\n  }\n\n  throw new Error('\"' + aStr + '\" is not in the set.');\n};\n\n/**\n * What is the element at the given index?\n *\n * @param Number aIdx\n */\nArraySet.prototype.at = function ArraySet_at(aIdx) {\n  if (aIdx >= 0 && aIdx < this._array.length) {\n    return this._array[aIdx];\n  }\n  throw new Error('No element indexed by ' + aIdx);\n};\n\n/**\n * Returns the array representation of this set (which has the proper indices\n * indicated by indexOf). Note that this is a copy of the internal array used\n * for storing the members so that no one can mess with internal state.\n */\nArraySet.prototype.toArray = function ArraySet_toArray() {\n  return this._array.slice();\n};\n\nexports.ArraySet = ArraySet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/array-set.js\n// module id = 5\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2014 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar util = require('./util');\n\n/**\n * Determine whether mappingB is after mappingA with respect to generated\n * position.\n */\nfunction generatedPositionAfter(mappingA, mappingB) {\n  // Optimized for most common case\n  var lineA = mappingA.generatedLine;\n  var lineB = mappingB.generatedLine;\n  var columnA = mappingA.generatedColumn;\n  var columnB = mappingB.generatedColumn;\n  return lineB > lineA || lineB == lineA && columnB >= columnA ||\n         util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;\n}\n\n/**\n * A data structure to provide a sorted view of accumulated mappings in a\n * performance conscious manner. It trades a neglibable overhead in general\n * case for a large speedup in case of mappings being added in order.\n */\nfunction MappingList() {\n  this._array = [];\n  this._sorted = true;\n  // Serves as infimum\n  this._last = {generatedLine: -1, generatedColumn: 0};\n}\n\n/**\n * Iterate through internal items. This method takes the same arguments that\n * `Array.prototype.forEach` takes.\n *\n * NOTE: The order of the mappings is NOT guaranteed.\n */\nMappingList.prototype.unsortedForEach =\n  function MappingList_forEach(aCallback, aThisArg) {\n    this._array.forEach(aCallback, aThisArg);\n  };\n\n/**\n * Add the given source mapping.\n *\n * @param Object aMapping\n */\nMappingList.prototype.add = function MappingList_add(aMapping) {\n  if (generatedPositionAfter(this._last, aMapping)) {\n    this._last = aMapping;\n    this._array.push(aMapping);\n  } else {\n    this._sorted = false;\n    this._array.push(aMapping);\n  }\n};\n\n/**\n * Returns the flat, sorted array of mappings. The mappings are sorted by\n * generated position.\n *\n * WARNING: This method returns internal data without copying, for\n * performance. The return value must NOT be mutated, and should be treated as\n * an immutable borrow. If you want to take ownership, you must make your own\n * copy.\n */\nMappingList.prototype.toArray = function MappingList_toArray() {\n  if (!this._sorted) {\n    this._array.sort(util.compareByGeneratedPositionsInflated);\n    this._sorted = true;\n  }\n  return this._array;\n};\n\nexports.MappingList = MappingList;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/mapping-list.js\n// module id = 6\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar util = require('./util');\nvar binarySearch = require('./binary-search');\nvar ArraySet = require('./array-set').ArraySet;\nvar base64VLQ = require('./base64-vlq');\nvar quickSort = require('./quick-sort').quickSort;\n\nfunction SourceMapConsumer(aSourceMap) {\n  var sourceMap = aSourceMap;\n  if (typeof aSourceMap === 'string') {\n    sourceMap = JSON.parse(aSourceMap.replace(/^\\)\\]\\}'/, ''));\n  }\n\n  return sourceMap.sections != null\n    ? new IndexedSourceMapConsumer(sourceMap)\n    : new BasicSourceMapConsumer(sourceMap);\n}\n\nSourceMapConsumer.fromSourceMap = function(aSourceMap) {\n  return BasicSourceMapConsumer.fromSourceMap(aSourceMap);\n}\n\n/**\n * The version of the source mapping spec that we are consuming.\n */\nSourceMapConsumer.prototype._version = 3;\n\n// `__generatedMappings` and `__originalMappings` are arrays that hold the\n// parsed mapping coordinates from the source map's \"mappings\" attribute. They\n// are lazily instantiated, accessed via the `_generatedMappings` and\n// `_originalMappings` getters respectively, and we only parse the mappings\n// and create these arrays once queried for a source location. We jump through\n// these hoops because there can be many thousands of mappings, and parsing\n// them is expensive, so we only want to do it if we must.\n//\n// Each object in the arrays is of the form:\n//\n//     {\n//       generatedLine: The line number in the generated code,\n//       generatedColumn: The column number in the generated code,\n//       source: The path to the original source file that generated this\n//               chunk of code,\n//       originalLine: The line number in the original source that\n//                     corresponds to this chunk of generated code,\n//       originalColumn: The column number in the original source that\n//                       corresponds to this chunk of generated code,\n//       name: The name of the original symbol which generated this chunk of\n//             code.\n//     }\n//\n// All properties except for `generatedLine` and `generatedColumn` can be\n// `null`.\n//\n// `_generatedMappings` is ordered by the generated positions.\n//\n// `_originalMappings` is ordered by the original positions.\n\nSourceMapConsumer.prototype.__generatedMappings = null;\nObject.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {\n  get: function () {\n    if (!this.__generatedMappings) {\n      this._parseMappings(this._mappings, this.sourceRoot);\n    }\n\n    return this.__generatedMappings;\n  }\n});\n\nSourceMapConsumer.prototype.__originalMappings = null;\nObject.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {\n  get: function () {\n    if (!this.__originalMappings) {\n      this._parseMappings(this._mappings, this.sourceRoot);\n    }\n\n    return this.__originalMappings;\n  }\n});\n\nSourceMapConsumer.prototype._charIsMappingSeparator =\n  function SourceMapConsumer_charIsMappingSeparator(aStr, index) {\n    var c = aStr.charAt(index);\n    return c === \";\" || c === \",\";\n  };\n\n/**\n * Parse the mappings in a string in to a data structure which we can easily\n * query (the ordered arrays in the `this.__generatedMappings` and\n * `this.__originalMappings` properties).\n */\nSourceMapConsumer.prototype._parseMappings =\n  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n    throw new Error(\"Subclasses must implement _parseMappings\");\n  };\n\nSourceMapConsumer.GENERATED_ORDER = 1;\nSourceMapConsumer.ORIGINAL_ORDER = 2;\n\nSourceMapConsumer.GREATEST_LOWER_BOUND = 1;\nSourceMapConsumer.LEAST_UPPER_BOUND = 2;\n\n/**\n * Iterate over each mapping between an original source/line/column and a\n * generated line/column in this source map.\n *\n * @param Function aCallback\n *        The function that is called with each mapping.\n * @param Object aContext\n *        Optional. If specified, this object will be the value of `this` every\n *        time that `aCallback` is called.\n * @param aOrder\n *        Either `SourceMapConsumer.GENERATED_ORDER` or\n *        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to\n *        iterate over the mappings sorted by the generated file's line/column\n *        order or the original's source/line/column order, respectively. Defaults to\n *        `SourceMapConsumer.GENERATED_ORDER`.\n */\nSourceMapConsumer.prototype.eachMapping =\n  function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {\n    var context = aContext || null;\n    var order = aOrder || SourceMapConsumer.GENERATED_ORDER;\n\n    var mappings;\n    switch (order) {\n    case SourceMapConsumer.GENERATED_ORDER:\n      mappings = this._generatedMappings;\n      break;\n    case SourceMapConsumer.ORIGINAL_ORDER:\n      mappings = this._originalMappings;\n      break;\n    default:\n      throw new Error(\"Unknown order of iteration.\");\n    }\n\n    var sourceRoot = this.sourceRoot;\n    mappings.map(function (mapping) {\n      var source = mapping.source === null ? null : this._sources.at(mapping.source);\n      if (source != null && sourceRoot != null) {\n        source = util.join(sourceRoot, source);\n      }\n      return {\n        source: source,\n        generatedLine: mapping.generatedLine,\n        generatedColumn: mapping.generatedColumn,\n        originalLine: mapping.originalLine,\n        originalColumn: mapping.originalColumn,\n        name: mapping.name === null ? null : this._names.at(mapping.name)\n      };\n    }, this).forEach(aCallback, context);\n  };\n\n/**\n * Returns all generated line and column information for the original source,\n * line, and column provided. If no column is provided, returns all mappings\n * corresponding to a either the line we are searching for or the next\n * closest line that has any mappings. Otherwise, returns all mappings\n * corresponding to the given line and either the column we are searching for\n * or the next closest column that has any offsets.\n *\n * The only argument is an object with the following properties:\n *\n *   - source: The filename of the original source.\n *   - line: The line number in the original source.\n *   - column: Optional. the column number in the original source.\n *\n * and an array of objects is returned, each with the following properties:\n *\n *   - line: The line number in the generated source, or null.\n *   - column: The column number in the generated source, or null.\n */\nSourceMapConsumer.prototype.allGeneratedPositionsFor =\n  function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {\n    var line = util.getArg(aArgs, 'line');\n\n    // When there is no exact match, BasicSourceMapConsumer.prototype._findMapping\n    // returns the index of the closest mapping less than the needle. By\n    // setting needle.originalColumn to 0, we thus find the last mapping for\n    // the given line, provided such a mapping exists.\n    var needle = {\n      source: util.getArg(aArgs, 'source'),\n      originalLine: line,\n      originalColumn: util.getArg(aArgs, 'column', 0)\n    };\n\n    if (this.sourceRoot != null) {\n      needle.source = util.relative(this.sourceRoot, needle.source);\n    }\n    if (!this._sources.has(needle.source)) {\n      return [];\n    }\n    needle.source = this._sources.indexOf(needle.source);\n\n    var mappings = [];\n\n    var index = this._findMapping(needle,\n                                  this._originalMappings,\n                                  \"originalLine\",\n                                  \"originalColumn\",\n                                  util.compareByOriginalPositions,\n                                  binarySearch.LEAST_UPPER_BOUND);\n    if (index >= 0) {\n      var mapping = this._originalMappings[index];\n\n      if (aArgs.column === undefined) {\n        var originalLine = mapping.originalLine;\n\n        // Iterate until either we run out of mappings, or we run into\n        // a mapping for a different line than the one we found. Since\n        // mappings are sorted, this is guaranteed to find all mappings for\n        // the line we found.\n        while (mapping && mapping.originalLine === originalLine) {\n          mappings.push({\n            line: util.getArg(mapping, 'generatedLine', null),\n            column: util.getArg(mapping, 'generatedColumn', null),\n            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n          });\n\n          mapping = this._originalMappings[++index];\n        }\n      } else {\n        var originalColumn = mapping.originalColumn;\n\n        // Iterate until either we run out of mappings, or we run into\n        // a mapping for a different line than the one we were searching for.\n        // Since mappings are sorted, this is guaranteed to find all mappings for\n        // the line we are searching for.\n        while (mapping &&\n               mapping.originalLine === line &&\n               mapping.originalColumn == originalColumn) {\n          mappings.push({\n            line: util.getArg(mapping, 'generatedLine', null),\n            column: util.getArg(mapping, 'generatedColumn', null),\n            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n          });\n\n          mapping = this._originalMappings[++index];\n        }\n      }\n    }\n\n    return mappings;\n  };\n\nexports.SourceMapConsumer = SourceMapConsumer;\n\n/**\n * A BasicSourceMapConsumer instance represents a parsed source map which we can\n * query for information about the original file positions by giving it a file\n * position in the generated source.\n *\n * The only parameter is the raw source map (either as a JSON string, or\n * already parsed to an object). According to the spec, source maps have the\n * following attributes:\n *\n *   - version: Which version of the source map spec this map is following.\n *   - sources: An array of URLs to the original source files.\n *   - names: An array of identifiers which can be referrenced by individual mappings.\n *   - sourceRoot: Optional. The URL root from which all sources are relative.\n *   - sourcesContent: Optional. An array of contents of the original source files.\n *   - mappings: A string of base64 VLQs which contain the actual mappings.\n *   - file: Optional. The generated file this source map is associated with.\n *\n * Here is an example source map, taken from the source map spec[0]:\n *\n *     {\n *       version : 3,\n *       file: \"out.js\",\n *       sourceRoot : \"\",\n *       sources: [\"foo.js\", \"bar.js\"],\n *       names: [\"src\", \"maps\", \"are\", \"fun\"],\n *       mappings: \"AA,AB;;ABCDE;\"\n *     }\n *\n * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#\n */\nfunction BasicSourceMapConsumer(aSourceMap) {\n  var sourceMap = aSourceMap;\n  if (typeof aSourceMap === 'string') {\n    sourceMap = JSON.parse(aSourceMap.replace(/^\\)\\]\\}'/, ''));\n  }\n\n  var version = util.getArg(sourceMap, 'version');\n  var sources = util.getArg(sourceMap, 'sources');\n  // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which\n  // requires the array) to play nice here.\n  var names = util.getArg(sourceMap, 'names', []);\n  var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);\n  var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);\n  var mappings = util.getArg(sourceMap, 'mappings');\n  var file = util.getArg(sourceMap, 'file', null);\n\n  // Once again, Sass deviates from the spec and supplies the version as a\n  // string rather than a number, so we use loose equality checking here.\n  if (version != this._version) {\n    throw new Error('Unsupported version: ' + version);\n  }\n\n  sources = sources\n    .map(String)\n    // Some source maps produce relative source paths like \"./foo.js\" instead of\n    // \"foo.js\".  Normalize these first so that future comparisons will succeed.\n    // See bugzil.la/1090768.\n    .map(util.normalize)\n    // Always ensure that absolute sources are internally stored relative to\n    // the source root, if the source root is absolute. Not doing this would\n    // be particularly problematic when the source root is a prefix of the\n    // source (valid, but why??). See github issue #199 and bugzil.la/1188982.\n    .map(function (source) {\n      return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source)\n        ? util.relative(sourceRoot, source)\n        : source;\n    });\n\n  // Pass `true` below to allow duplicate names and sources. While source maps\n  // are intended to be compressed and deduplicated, the TypeScript compiler\n  // sometimes generates source maps with duplicates in them. See Github issue\n  // #72 and bugzil.la/889492.\n  this._names = ArraySet.fromArray(names.map(String), true);\n  this._sources = ArraySet.fromArray(sources, true);\n\n  this.sourceRoot = sourceRoot;\n  this.sourcesContent = sourcesContent;\n  this._mappings = mappings;\n  this.file = file;\n}\n\nBasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);\nBasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;\n\n/**\n * Create a BasicSourceMapConsumer from a SourceMapGenerator.\n *\n * @param SourceMapGenerator aSourceMap\n *        The source map that will be consumed.\n * @returns BasicSourceMapConsumer\n */\nBasicSourceMapConsumer.fromSourceMap =\n  function SourceMapConsumer_fromSourceMap(aSourceMap) {\n    var smc = Object.create(BasicSourceMapConsumer.prototype);\n\n    var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);\n    var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);\n    smc.sourceRoot = aSourceMap._sourceRoot;\n    smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),\n                                                            smc.sourceRoot);\n    smc.file = aSourceMap._file;\n\n    // Because we are modifying the entries (by converting string sources and\n    // names to indices into the sources and names ArraySets), we have to make\n    // a copy of the entry or else bad things happen. Shared mutable state\n    // strikes again! See github issue #191.\n\n    var generatedMappings = aSourceMap._mappings.toArray().slice();\n    var destGeneratedMappings = smc.__generatedMappings = [];\n    var destOriginalMappings = smc.__originalMappings = [];\n\n    for (var i = 0, length = generatedMappings.length; i < length; i++) {\n      var srcMapping = generatedMappings[i];\n      var destMapping = new Mapping;\n      destMapping.generatedLine = srcMapping.generatedLine;\n      destMapping.generatedColumn = srcMapping.generatedColumn;\n\n      if (srcMapping.source) {\n        destMapping.source = sources.indexOf(srcMapping.source);\n        destMapping.originalLine = srcMapping.originalLine;\n        destMapping.originalColumn = srcMapping.originalColumn;\n\n        if (srcMapping.name) {\n          destMapping.name = names.indexOf(srcMapping.name);\n        }\n\n        destOriginalMappings.push(destMapping);\n      }\n\n      destGeneratedMappings.push(destMapping);\n    }\n\n    quickSort(smc.__originalMappings, util.compareByOriginalPositions);\n\n    return smc;\n  };\n\n/**\n * The version of the source mapping spec that we are consuming.\n */\nBasicSourceMapConsumer.prototype._version = 3;\n\n/**\n * The list of original sources.\n */\nObject.defineProperty(BasicSourceMapConsumer.prototype, 'sources', {\n  get: function () {\n    return this._sources.toArray().map(function (s) {\n      return this.sourceRoot != null ? util.join(this.sourceRoot, s) : s;\n    }, this);\n  }\n});\n\n/**\n * Provide the JIT with a nice shape / hidden class.\n */\nfunction Mapping() {\n  this.generatedLine = 0;\n  this.generatedColumn = 0;\n  this.source = null;\n  this.originalLine = null;\n  this.originalColumn = null;\n  this.name = null;\n}\n\n/**\n * Parse the mappings in a string in to a data structure which we can easily\n * query (the ordered arrays in the `this.__generatedMappings` and\n * `this.__originalMappings` properties).\n */\nBasicSourceMapConsumer.prototype._parseMappings =\n  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n    var generatedLine = 1;\n    var previousGeneratedColumn = 0;\n    var previousOriginalLine = 0;\n    var previousOriginalColumn = 0;\n    var previousSource = 0;\n    var previousName = 0;\n    var length = aStr.length;\n    var index = 0;\n    var cachedSegments = {};\n    var temp = {};\n    var originalMappings = [];\n    var generatedMappings = [];\n    var mapping, str, segment, end, value;\n\n    while (index < length) {\n      if (aStr.charAt(index) === ';') {\n        generatedLine++;\n        index++;\n        previousGeneratedColumn = 0;\n      }\n      else if (aStr.charAt(index) === ',') {\n        index++;\n      }\n      else {\n        mapping = new Mapping();\n        mapping.generatedLine = generatedLine;\n\n        // Because each offset is encoded relative to the previous one,\n        // many segments often have the same encoding. We can exploit this\n        // fact by caching the parsed variable length fields of each segment,\n        // allowing us to avoid a second parse if we encounter the same\n        // segment again.\n        for (end = index; end < length; end++) {\n          if (this._charIsMappingSeparator(aStr, end)) {\n            break;\n          }\n        }\n        str = aStr.slice(index, end);\n\n        segment = cachedSegments[str];\n        if (segment) {\n          index += str.length;\n        } else {\n          segment = [];\n          while (index < end) {\n            base64VLQ.decode(aStr, index, temp);\n            value = temp.value;\n            index = temp.rest;\n            segment.push(value);\n          }\n\n          if (segment.length === 2) {\n            throw new Error('Found a source, but no line and column');\n          }\n\n          if (segment.length === 3) {\n            throw new Error('Found a source and line, but no column');\n          }\n\n          cachedSegments[str] = segment;\n        }\n\n        // Generated column.\n        mapping.generatedColumn = previousGeneratedColumn + segment[0];\n        previousGeneratedColumn = mapping.generatedColumn;\n\n        if (segment.length > 1) {\n          // Original source.\n          mapping.source = previousSource + segment[1];\n          previousSource += segment[1];\n\n          // Original line.\n          mapping.originalLine = previousOriginalLine + segment[2];\n          previousOriginalLine = mapping.originalLine;\n          // Lines are stored 0-based\n          mapping.originalLine += 1;\n\n          // Original column.\n          mapping.originalColumn = previousOriginalColumn + segment[3];\n          previousOriginalColumn = mapping.originalColumn;\n\n          if (segment.length > 4) {\n            // Original name.\n            mapping.name = previousName + segment[4];\n            previousName += segment[4];\n          }\n        }\n\n        generatedMappings.push(mapping);\n        if (typeof mapping.originalLine === 'number') {\n          originalMappings.push(mapping);\n        }\n      }\n    }\n\n    quickSort(generatedMappings, util.compareByGeneratedPositionsDeflated);\n    this.__generatedMappings = generatedMappings;\n\n    quickSort(originalMappings, util.compareByOriginalPositions);\n    this.__originalMappings = originalMappings;\n  };\n\n/**\n * Find the mapping that best matches the hypothetical \"needle\" mapping that\n * we are searching for in the given \"haystack\" of mappings.\n */\nBasicSourceMapConsumer.prototype._findMapping =\n  function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,\n                                         aColumnName, aComparator, aBias) {\n    // To return the position we are searching for, we must first find the\n    // mapping for the given position and then return the opposite position it\n    // points to. Because the mappings are sorted, we can use binary search to\n    // find the best mapping.\n\n    if (aNeedle[aLineName] <= 0) {\n      throw new TypeError('Line must be greater than or equal to 1, got '\n                          + aNeedle[aLineName]);\n    }\n    if (aNeedle[aColumnName] < 0) {\n      throw new TypeError('Column must be greater than or equal to 0, got '\n                          + aNeedle[aColumnName]);\n    }\n\n    return binarySearch.search(aNeedle, aMappings, aComparator, aBias);\n  };\n\n/**\n * Compute the last column for each generated mapping. The last column is\n * inclusive.\n */\nBasicSourceMapConsumer.prototype.computeColumnSpans =\n  function SourceMapConsumer_computeColumnSpans() {\n    for (var index = 0; index < this._generatedMappings.length; ++index) {\n      var mapping = this._generatedMappings[index];\n\n      // Mappings do not contain a field for the last generated columnt. We\n      // can come up with an optimistic estimate, however, by assuming that\n      // mappings are contiguous (i.e. given two consecutive mappings, the\n      // first mapping ends where the second one starts).\n      if (index + 1 < this._generatedMappings.length) {\n        var nextMapping = this._generatedMappings[index + 1];\n\n        if (mapping.generatedLine === nextMapping.generatedLine) {\n          mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;\n          continue;\n        }\n      }\n\n      // The last mapping for each line spans the entire line.\n      mapping.lastGeneratedColumn = Infinity;\n    }\n  };\n\n/**\n * Returns the original source, line, and column information for the generated\n * source's line and column positions provided. The only argument is an object\n * with the following properties:\n *\n *   - line: The line number in the generated source.\n *   - column: The column number in the generated source.\n *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or\n *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the\n *     closest element that is smaller than or greater than the one we are\n *     searching for, respectively, if the exact element cannot be found.\n *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.\n *\n * and an object is returned with the following properties:\n *\n *   - source: The original source file, or null.\n *   - line: The line number in the original source, or null.\n *   - column: The column number in the original source, or null.\n *   - name: The original identifier, or null.\n */\nBasicSourceMapConsumer.prototype.originalPositionFor =\n  function SourceMapConsumer_originalPositionFor(aArgs) {\n    var needle = {\n      generatedLine: util.getArg(aArgs, 'line'),\n      generatedColumn: util.getArg(aArgs, 'column')\n    };\n\n    var index = this._findMapping(\n      needle,\n      this._generatedMappings,\n      \"generatedLine\",\n      \"generatedColumn\",\n      util.compareByGeneratedPositionsDeflated,\n      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)\n    );\n\n    if (index >= 0) {\n      var mapping = this._generatedMappings[index];\n\n      if (mapping.generatedLine === needle.generatedLine) {\n        var source = util.getArg(mapping, 'source', null);\n        if (source !== null) {\n          source = this._sources.at(source);\n          if (this.sourceRoot != null) {\n            source = util.join(this.sourceRoot, source);\n          }\n        }\n        var name = util.getArg(mapping, 'name', null);\n        if (name !== null) {\n          name = this._names.at(name);\n        }\n        return {\n          source: source,\n          line: util.getArg(mapping, 'originalLine', null),\n          column: util.getArg(mapping, 'originalColumn', null),\n          name: name\n        };\n      }\n    }\n\n    return {\n      source: null,\n      line: null,\n      column: null,\n      name: null\n    };\n  };\n\n/**\n * Return true if we have the source content for every source in the source\n * map, false otherwise.\n */\nBasicSourceMapConsumer.prototype.hasContentsOfAllSources =\n  function BasicSourceMapConsumer_hasContentsOfAllSources() {\n    if (!this.sourcesContent) {\n      return false;\n    }\n    return this.sourcesContent.length >= this._sources.size() &&\n      !this.sourcesContent.some(function (sc) { return sc == null; });\n  };\n\n/**\n * Returns the original source content. The only argument is the url of the\n * original source file. Returns null if no original source content is\n * available.\n */\nBasicSourceMapConsumer.prototype.sourceContentFor =\n  function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {\n    if (!this.sourcesContent) {\n      return null;\n    }\n\n    if (this.sourceRoot != null) {\n      aSource = util.relative(this.sourceRoot, aSource);\n    }\n\n    if (this._sources.has(aSource)) {\n      return this.sourcesContent[this._sources.indexOf(aSource)];\n    }\n\n    var url;\n    if (this.sourceRoot != null\n        && (url = util.urlParse(this.sourceRoot))) {\n      // XXX: file:// URIs and absolute paths lead to unexpected behavior for\n      // many users. We can help them out when they expect file:// URIs to\n      // behave like it would if they were running a local HTTP server. See\n      // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.\n      var fileUriAbsPath = aSource.replace(/^file:\\/\\//, \"\");\n      if (url.scheme == \"file\"\n          && this._sources.has(fileUriAbsPath)) {\n        return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]\n      }\n\n      if ((!url.path || url.path == \"/\")\n          && this._sources.has(\"/\" + aSource)) {\n        return this.sourcesContent[this._sources.indexOf(\"/\" + aSource)];\n      }\n    }\n\n    // This function is used recursively from\n    // IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we\n    // don't want to throw if we can't find the source - we just want to\n    // return null, so we provide a flag to exit gracefully.\n    if (nullOnMissing) {\n      return null;\n    }\n    else {\n      throw new Error('\"' + aSource + '\" is not in the SourceMap.');\n    }\n  };\n\n/**\n * Returns the generated line and column information for the original source,\n * line, and column positions provided. The only argument is an object with\n * the following properties:\n *\n *   - source: The filename of the original source.\n *   - line: The line number in the original source.\n *   - column: The column number in the original source.\n *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or\n *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the\n *     closest element that is smaller than or greater than the one we are\n *     searching for, respectively, if the exact element cannot be found.\n *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.\n *\n * and an object is returned with the following properties:\n *\n *   - line: The line number in the generated source, or null.\n *   - column: The column number in the generated source, or null.\n */\nBasicSourceMapConsumer.prototype.generatedPositionFor =\n  function SourceMapConsumer_generatedPositionFor(aArgs) {\n    var source = util.getArg(aArgs, 'source');\n    if (this.sourceRoot != null) {\n      source = util.relative(this.sourceRoot, source);\n    }\n    if (!this._sources.has(source)) {\n      return {\n        line: null,\n        column: null,\n        lastColumn: null\n      };\n    }\n    source = this._sources.indexOf(source);\n\n    var needle = {\n      source: source,\n      originalLine: util.getArg(aArgs, 'line'),\n      originalColumn: util.getArg(aArgs, 'column')\n    };\n\n    var index = this._findMapping(\n      needle,\n      this._originalMappings,\n      \"originalLine\",\n      \"originalColumn\",\n      util.compareByOriginalPositions,\n      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)\n    );\n\n    if (index >= 0) {\n      var mapping = this._originalMappings[index];\n\n      if (mapping.source === needle.source) {\n        return {\n          line: util.getArg(mapping, 'generatedLine', null),\n          column: util.getArg(mapping, 'generatedColumn', null),\n          lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n        };\n      }\n    }\n\n    return {\n      line: null,\n      column: null,\n      lastColumn: null\n    };\n  };\n\nexports.BasicSourceMapConsumer = BasicSourceMapConsumer;\n\n/**\n * An IndexedSourceMapConsumer instance represents a parsed source map which\n * we can query for information. It differs from BasicSourceMapConsumer in\n * that it takes \"indexed\" source maps (i.e. ones with a \"sections\" field) as\n * input.\n *\n * The only parameter is a raw source map (either as a JSON string, or already\n * parsed to an object). According to the spec for indexed source maps, they\n * have the following attributes:\n *\n *   - version: Which version of the source map spec this map is following.\n *   - file: Optional. The generated file this source map is associated with.\n *   - sections: A list of section definitions.\n *\n * Each value under the \"sections\" field has two fields:\n *   - offset: The offset into the original specified at which this section\n *       begins to apply, defined as an object with a \"line\" and \"column\"\n *       field.\n *   - map: A source map definition. This source map could also be indexed,\n *       but doesn't have to be.\n *\n * Instead of the \"map\" field, it's also possible to have a \"url\" field\n * specifying a URL to retrieve a source map from, but that's currently\n * unsupported.\n *\n * Here's an example source map, taken from the source map spec[0], but\n * modified to omit a section which uses the \"url\" field.\n *\n *  {\n *    version : 3,\n *    file: \"app.js\",\n *    sections: [{\n *      offset: {line:100, column:10},\n *      map: {\n *        version : 3,\n *        file: \"section.js\",\n *        sources: [\"foo.js\", \"bar.js\"],\n *        names: [\"src\", \"maps\", \"are\", \"fun\"],\n *        mappings: \"AAAA,E;;ABCDE;\"\n *      }\n *    }],\n *  }\n *\n * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt\n */\nfunction IndexedSourceMapConsumer(aSourceMap) {\n  var sourceMap = aSourceMap;\n  if (typeof aSourceMap === 'string') {\n    sourceMap = JSON.parse(aSourceMap.replace(/^\\)\\]\\}'/, ''));\n  }\n\n  var version = util.getArg(sourceMap, 'version');\n  var sections = util.getArg(sourceMap, 'sections');\n\n  if (version != this._version) {\n    throw new Error('Unsupported version: ' + version);\n  }\n\n  this._sources = new ArraySet();\n  this._names = new ArraySet();\n\n  var lastOffset = {\n    line: -1,\n    column: 0\n  };\n  this._sections = sections.map(function (s) {\n    if (s.url) {\n      // The url field will require support for asynchronicity.\n      // See https://github.com/mozilla/source-map/issues/16\n      throw new Error('Support for url field in sections not implemented.');\n    }\n    var offset = util.getArg(s, 'offset');\n    var offsetLine = util.getArg(offset, 'line');\n    var offsetColumn = util.getArg(offset, 'column');\n\n    if (offsetLine < lastOffset.line ||\n        (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {\n      throw new Error('Section offsets must be ordered and non-overlapping.');\n    }\n    lastOffset = offset;\n\n    return {\n      generatedOffset: {\n        // The offset fields are 0-based, but we use 1-based indices when\n        // encoding/decoding from VLQ.\n        generatedLine: offsetLine + 1,\n        generatedColumn: offsetColumn + 1\n      },\n      consumer: new SourceMapConsumer(util.getArg(s, 'map'))\n    }\n  });\n}\n\nIndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);\nIndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;\n\n/**\n * The version of the source mapping spec that we are consuming.\n */\nIndexedSourceMapConsumer.prototype._version = 3;\n\n/**\n * The list of original sources.\n */\nObject.defineProperty(IndexedSourceMapConsumer.prototype, 'sources', {\n  get: function () {\n    var sources = [];\n    for (var i = 0; i < this._sections.length; i++) {\n      for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {\n        sources.push(this._sections[i].consumer.sources[j]);\n      }\n    }\n    return sources;\n  }\n});\n\n/**\n * Returns the original source, line, and column information for the generated\n * source's line and column positions provided. The only argument is an object\n * with the following properties:\n *\n *   - line: The line number in the generated source.\n *   - column: The column number in the generated source.\n *\n * and an object is returned with the following properties:\n *\n *   - source: The original source file, or null.\n *   - line: The line number in the original source, or null.\n *   - column: The column number in the original source, or null.\n *   - name: The original identifier, or null.\n */\nIndexedSourceMapConsumer.prototype.originalPositionFor =\n  function IndexedSourceMapConsumer_originalPositionFor(aArgs) {\n    var needle = {\n      generatedLine: util.getArg(aArgs, 'line'),\n      generatedColumn: util.getArg(aArgs, 'column')\n    };\n\n    // Find the section containing the generated position we're trying to map\n    // to an original position.\n    var sectionIndex = binarySearch.search(needle, this._sections,\n      function(needle, section) {\n        var cmp = needle.generatedLine - section.generatedOffset.generatedLine;\n        if (cmp) {\n          return cmp;\n        }\n\n        return (needle.generatedColumn -\n                section.generatedOffset.generatedColumn);\n      });\n    var section = this._sections[sectionIndex];\n\n    if (!section) {\n      return {\n        source: null,\n        line: null,\n        column: null,\n        name: null\n      };\n    }\n\n    return section.consumer.originalPositionFor({\n      line: needle.generatedLine -\n        (section.generatedOffset.generatedLine - 1),\n      column: needle.generatedColumn -\n        (section.generatedOffset.generatedLine === needle.generatedLine\n         ? section.generatedOffset.generatedColumn - 1\n         : 0),\n      bias: aArgs.bias\n    });\n  };\n\n/**\n * Return true if we have the source content for every source in the source\n * map, false otherwise.\n */\nIndexedSourceMapConsumer.prototype.hasContentsOfAllSources =\n  function IndexedSourceMapConsumer_hasContentsOfAllSources() {\n    return this._sections.every(function (s) {\n      return s.consumer.hasContentsOfAllSources();\n    });\n  };\n\n/**\n * Returns the original source content. The only argument is the url of the\n * original source file. Returns null if no original source content is\n * available.\n */\nIndexedSourceMapConsumer.prototype.sourceContentFor =\n  function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {\n    for (var i = 0; i < this._sections.length; i++) {\n      var section = this._sections[i];\n\n      var content = section.consumer.sourceContentFor(aSource, true);\n      if (content) {\n        return content;\n      }\n    }\n    if (nullOnMissing) {\n      return null;\n    }\n    else {\n      throw new Error('\"' + aSource + '\" is not in the SourceMap.');\n    }\n  };\n\n/**\n * Returns the generated line and column information for the original source,\n * line, and column positions provided. The only argument is an object with\n * the following properties:\n *\n *   - source: The filename of the original source.\n *   - line: The line number in the original source.\n *   - column: The column number in the original source.\n *\n * and an object is returned with the following properties:\n *\n *   - line: The line number in the generated source, or null.\n *   - column: The column number in the generated source, or null.\n */\nIndexedSourceMapConsumer.prototype.generatedPositionFor =\n  function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {\n    for (var i = 0; i < this._sections.length; i++) {\n      var section = this._sections[i];\n\n      // Only consider this section if the requested source is in the list of\n      // sources of the consumer.\n      if (section.consumer.sources.indexOf(util.getArg(aArgs, 'source')) === -1) {\n        continue;\n      }\n      var generatedPosition = section.consumer.generatedPositionFor(aArgs);\n      if (generatedPosition) {\n        var ret = {\n          line: generatedPosition.line +\n            (section.generatedOffset.generatedLine - 1),\n          column: generatedPosition.column +\n            (section.generatedOffset.generatedLine === generatedPosition.line\n             ? section.generatedOffset.generatedColumn - 1\n             : 0)\n        };\n        return ret;\n      }\n    }\n\n    return {\n      line: null,\n      column: null\n    };\n  };\n\n/**\n * Parse the mappings in a string in to a data structure which we can easily\n * query (the ordered arrays in the `this.__generatedMappings` and\n * `this.__originalMappings` properties).\n */\nIndexedSourceMapConsumer.prototype._parseMappings =\n  function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n    this.__generatedMappings = [];\n    this.__originalMappings = [];\n    for (var i = 0; i < this._sections.length; i++) {\n      var section = this._sections[i];\n      var sectionMappings = section.consumer._generatedMappings;\n      for (var j = 0; j < sectionMappings.length; j++) {\n        var mapping = sectionMappings[j];\n\n        var source = section.consumer._sources.at(mapping.source);\n        if (section.consumer.sourceRoot !== null) {\n          source = util.join(section.consumer.sourceRoot, source);\n        }\n        this._sources.add(source);\n        source = this._sources.indexOf(source);\n\n        var name = section.consumer._names.at(mapping.name);\n        this._names.add(name);\n        name = this._names.indexOf(name);\n\n        // The mappings coming from the consumer for the section have\n        // generated positions relative to the start of the section, so we\n        // need to offset them to be relative to the start of the concatenated\n        // generated file.\n        var adjustedMapping = {\n          source: source,\n          generatedLine: mapping.generatedLine +\n            (section.generatedOffset.generatedLine - 1),\n          generatedColumn: mapping.generatedColumn +\n            (section.generatedOffset.generatedLine === mapping.generatedLine\n            ? section.generatedOffset.generatedColumn - 1\n            : 0),\n          originalLine: mapping.originalLine,\n          originalColumn: mapping.originalColumn,\n          name: name\n        };\n\n        this.__generatedMappings.push(adjustedMapping);\n        if (typeof adjustedMapping.originalLine === 'number') {\n          this.__originalMappings.push(adjustedMapping);\n        }\n      }\n    }\n\n    quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);\n    quickSort(this.__originalMappings, util.compareByOriginalPositions);\n  };\n\nexports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/source-map-consumer.js\n// module id = 7\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nexports.GREATEST_LOWER_BOUND = 1;\nexports.LEAST_UPPER_BOUND = 2;\n\n/**\n * Recursive implementation of binary search.\n *\n * @param aLow Indices here and lower do not contain the needle.\n * @param aHigh Indices here and higher do not contain the needle.\n * @param aNeedle The element being searched for.\n * @param aHaystack The non-empty array being searched.\n * @param aCompare Function which takes two elements and returns -1, 0, or 1.\n * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or\n *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the\n *     closest element that is smaller than or greater than the one we are\n *     searching for, respectively, if the exact element cannot be found.\n */\nfunction recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {\n  // This function terminates when one of the following is true:\n  //\n  //   1. We find the exact element we are looking for.\n  //\n  //   2. We did not find the exact element, but we can return the index of\n  //      the next-closest element.\n  //\n  //   3. We did not find the exact element, and there is no next-closest\n  //      element than the one we are searching for, so we return -1.\n  var mid = Math.floor((aHigh - aLow) / 2) + aLow;\n  var cmp = aCompare(aNeedle, aHaystack[mid], true);\n  if (cmp === 0) {\n    // Found the element we are looking for.\n    return mid;\n  }\n  else if (cmp > 0) {\n    // Our needle is greater than aHaystack[mid].\n    if (aHigh - mid > 1) {\n      // The element is in the upper half.\n      return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);\n    }\n\n    // The exact needle element was not found in this haystack. Determine if\n    // we are in termination case (3) or (2) and return the appropriate thing.\n    if (aBias == exports.LEAST_UPPER_BOUND) {\n      return aHigh < aHaystack.length ? aHigh : -1;\n    } else {\n      return mid;\n    }\n  }\n  else {\n    // Our needle is less than aHaystack[mid].\n    if (mid - aLow > 1) {\n      // The element is in the lower half.\n      return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);\n    }\n\n    // we are in termination case (3) or (2) and return the appropriate thing.\n    if (aBias == exports.LEAST_UPPER_BOUND) {\n      return mid;\n    } else {\n      return aLow < 0 ? -1 : aLow;\n    }\n  }\n}\n\n/**\n * This is an implementation of binary search which will always try and return\n * the index of the closest element if there is no exact hit. This is because\n * mappings between original and generated line/col pairs are single points,\n * and there is an implicit region between each of them, so a miss just means\n * that you aren't on the very start of a region.\n *\n * @param aNeedle The element you are looking for.\n * @param aHaystack The array that is being searched.\n * @param aCompare A function which takes the needle and an element in the\n *     array and returns -1, 0, or 1 depending on whether the needle is less\n *     than, equal to, or greater than the element, respectively.\n * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or\n *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the\n *     closest element that is smaller than or greater than the one we are\n *     searching for, respectively, if the exact element cannot be found.\n *     Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.\n */\nexports.search = function search(aNeedle, aHaystack, aCompare, aBias) {\n  if (aHaystack.length === 0) {\n    return -1;\n  }\n\n  var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack,\n                              aCompare, aBias || exports.GREATEST_LOWER_BOUND);\n  if (index < 0) {\n    return -1;\n  }\n\n  // We have found either the exact element, or the next-closest element than\n  // the one we are searching for. However, there may be more than one such\n  // element. Make sure we always return the smallest of these.\n  while (index - 1 >= 0) {\n    if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {\n      break;\n    }\n    --index;\n  }\n\n  return index;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/binary-search.js\n// module id = 8\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\n// It turns out that some (most?) JavaScript engines don't self-host\n// `Array.prototype.sort`. This makes sense because C++ will likely remain\n// faster than JS when doing raw CPU-intensive sorting. However, when using a\n// custom comparator function, calling back and forth between the VM's C++ and\n// JIT'd JS is rather slow *and* loses JIT type information, resulting in\n// worse generated code for the comparator function than would be optimal. In\n// fact, when sorting with a comparator, these costs outweigh the benefits of\n// sorting in C++. By using our own JS-implemented Quick Sort (below), we get\n// a ~3500ms mean speed-up in `bench/bench.html`.\n\n/**\n * Swap the elements indexed by `x` and `y` in the array `ary`.\n *\n * @param {Array} ary\n *        The array.\n * @param {Number} x\n *        The index of the first item.\n * @param {Number} y\n *        The index of the second item.\n */\nfunction swap(ary, x, y) {\n  var temp = ary[x];\n  ary[x] = ary[y];\n  ary[y] = temp;\n}\n\n/**\n * Returns a random integer within the range `low .. high` inclusive.\n *\n * @param {Number} low\n *        The lower bound on the range.\n * @param {Number} high\n *        The upper bound on the range.\n */\nfunction randomIntInRange(low, high) {\n  return Math.round(low + (Math.random() * (high - low)));\n}\n\n/**\n * The Quick Sort algorithm.\n *\n * @param {Array} ary\n *        An array to sort.\n * @param {function} comparator\n *        Function to use to compare two items.\n * @param {Number} p\n *        Start index of the array\n * @param {Number} r\n *        End index of the array\n */\nfunction doQuickSort(ary, comparator, p, r) {\n  // If our lower bound is less than our upper bound, we (1) partition the\n  // array into two pieces and (2) recurse on each half. If it is not, this is\n  // the empty array and our base case.\n\n  if (p < r) {\n    // (1) Partitioning.\n    //\n    // The partitioning chooses a pivot between `p` and `r` and moves all\n    // elements that are less than or equal to the pivot to the before it, and\n    // all the elements that are greater than it after it. The effect is that\n    // once partition is done, the pivot is in the exact place it will be when\n    // the array is put in sorted order, and it will not need to be moved\n    // again. This runs in O(n) time.\n\n    // Always choose a random pivot so that an input array which is reverse\n    // sorted does not cause O(n^2) running time.\n    var pivotIndex = randomIntInRange(p, r);\n    var i = p - 1;\n\n    swap(ary, pivotIndex, r);\n    var pivot = ary[r];\n\n    // Immediately after `j` is incremented in this loop, the following hold\n    // true:\n    //\n    //   * Every element in `ary[p .. i]` is less than or equal to the pivot.\n    //\n    //   * Every element in `ary[i+1 .. j-1]` is greater than the pivot.\n    for (var j = p; j < r; j++) {\n      if (comparator(ary[j], pivot) <= 0) {\n        i += 1;\n        swap(ary, i, j);\n      }\n    }\n\n    swap(ary, i + 1, j);\n    var q = i + 1;\n\n    // (2) Recurse on each half.\n\n    doQuickSort(ary, comparator, p, q - 1);\n    doQuickSort(ary, comparator, q + 1, r);\n  }\n}\n\n/**\n * Sort the given array in-place with the given comparator function.\n *\n * @param {Array} ary\n *        An array to sort.\n * @param {function} comparator\n *        Function to use to compare two items.\n */\nexports.quickSort = function (ary, comparator) {\n  doQuickSort(ary, comparator, 0, ary.length - 1);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/quick-sort.js\n// module id = 9\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar SourceMapGenerator = require('./source-map-generator').SourceMapGenerator;\nvar util = require('./util');\n\n// Matches a Windows-style `\\r\\n` newline or a `\\n` newline used by all other\n// operating systems these days (capturing the result).\nvar REGEX_NEWLINE = /(\\r?\\n)/;\n\n// Newline character code for charCodeAt() comparisons\nvar NEWLINE_CODE = 10;\n\n// Private symbol for identifying `SourceNode`s when multiple versions of\n// the source-map library are loaded. This MUST NOT CHANGE across\n// versions!\nvar isSourceNode = \"$$$isSourceNode$$$\";\n\n/**\n * SourceNodes provide a way to abstract over interpolating/concatenating\n * snippets of generated JavaScript source code while maintaining the line and\n * column information associated with the original source code.\n *\n * @param aLine The original line number.\n * @param aColumn The original column number.\n * @param aSource The original source's filename.\n * @param aChunks Optional. An array of strings which are snippets of\n *        generated JS, or other SourceNodes.\n * @param aName The original identifier.\n */\nfunction SourceNode(aLine, aColumn, aSource, aChunks, aName) {\n  this.children = [];\n  this.sourceContents = {};\n  this.line = aLine == null ? null : aLine;\n  this.column = aColumn == null ? null : aColumn;\n  this.source = aSource == null ? null : aSource;\n  this.name = aName == null ? null : aName;\n  this[isSourceNode] = true;\n  if (aChunks != null) this.add(aChunks);\n}\n\n/**\n * Creates a SourceNode from generated code and a SourceMapConsumer.\n *\n * @param aGeneratedCode The generated code\n * @param aSourceMapConsumer The SourceMap for the generated code\n * @param aRelativePath Optional. The path that relative sources in the\n *        SourceMapConsumer should be relative to.\n */\nSourceNode.fromStringWithSourceMap =\n  function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {\n    // The SourceNode we want to fill with the generated code\n    // and the SourceMap\n    var node = new SourceNode();\n\n    // All even indices of this array are one line of the generated code,\n    // while all odd indices are the newlines between two adjacent lines\n    // (since `REGEX_NEWLINE` captures its match).\n    // Processed fragments are accessed by calling `shiftNextLine`.\n    var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);\n    var remainingLinesIndex = 0;\n    var shiftNextLine = function() {\n      var lineContents = getNextLine();\n      // The last line of a file might not have a newline.\n      var newLine = getNextLine() || \"\";\n      return lineContents + newLine;\n\n      function getNextLine() {\n        return remainingLinesIndex < remainingLines.length ?\n            remainingLines[remainingLinesIndex++] : undefined;\n      }\n    };\n\n    // We need to remember the position of \"remainingLines\"\n    var lastGeneratedLine = 1, lastGeneratedColumn = 0;\n\n    // The generate SourceNodes we need a code range.\n    // To extract it current and last mapping is used.\n    // Here we store the last mapping.\n    var lastMapping = null;\n\n    aSourceMapConsumer.eachMapping(function (mapping) {\n      if (lastMapping !== null) {\n        // We add the code from \"lastMapping\" to \"mapping\":\n        // First check if there is a new line in between.\n        if (lastGeneratedLine < mapping.generatedLine) {\n          // Associate first line with \"lastMapping\"\n          addMappingWithCode(lastMapping, shiftNextLine());\n          lastGeneratedLine++;\n          lastGeneratedColumn = 0;\n          // The remaining code is added without mapping\n        } else {\n          // There is no new line in between.\n          // Associate the code between \"lastGeneratedColumn\" and\n          // \"mapping.generatedColumn\" with \"lastMapping\"\n          var nextLine = remainingLines[remainingLinesIndex];\n          var code = nextLine.substr(0, mapping.generatedColumn -\n                                        lastGeneratedColumn);\n          remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn -\n                                              lastGeneratedColumn);\n          lastGeneratedColumn = mapping.generatedColumn;\n          addMappingWithCode(lastMapping, code);\n          // No more remaining code, continue\n          lastMapping = mapping;\n          return;\n        }\n      }\n      // We add the generated code until the first mapping\n      // to the SourceNode without any mapping.\n      // Each line is added as separate string.\n      while (lastGeneratedLine < mapping.generatedLine) {\n        node.add(shiftNextLine());\n        lastGeneratedLine++;\n      }\n      if (lastGeneratedColumn < mapping.generatedColumn) {\n        var nextLine = remainingLines[remainingLinesIndex];\n        node.add(nextLine.substr(0, mapping.generatedColumn));\n        remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);\n        lastGeneratedColumn = mapping.generatedColumn;\n      }\n      lastMapping = mapping;\n    }, this);\n    // We have processed all mappings.\n    if (remainingLinesIndex < remainingLines.length) {\n      if (lastMapping) {\n        // Associate the remaining code in the current line with \"lastMapping\"\n        addMappingWithCode(lastMapping, shiftNextLine());\n      }\n      // and add the remaining lines without any mapping\n      node.add(remainingLines.splice(remainingLinesIndex).join(\"\"));\n    }\n\n    // Copy sourcesContent into SourceNode\n    aSourceMapConsumer.sources.forEach(function (sourceFile) {\n      var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n      if (content != null) {\n        if (aRelativePath != null) {\n          sourceFile = util.join(aRelativePath, sourceFile);\n        }\n        node.setSourceContent(sourceFile, content);\n      }\n    });\n\n    return node;\n\n    function addMappingWithCode(mapping, code) {\n      if (mapping === null || mapping.source === undefined) {\n        node.add(code);\n      } else {\n        var source = aRelativePath\n          ? util.join(aRelativePath, mapping.source)\n          : mapping.source;\n        node.add(new SourceNode(mapping.originalLine,\n                                mapping.originalColumn,\n                                source,\n                                code,\n                                mapping.name));\n      }\n    }\n  };\n\n/**\n * Add a chunk of generated JS to this source node.\n *\n * @param aChunk A string snippet of generated JS code, another instance of\n *        SourceNode, or an array where each member is one of those things.\n */\nSourceNode.prototype.add = function SourceNode_add(aChunk) {\n  if (Array.isArray(aChunk)) {\n    aChunk.forEach(function (chunk) {\n      this.add(chunk);\n    }, this);\n  }\n  else if (aChunk[isSourceNode] || typeof aChunk === \"string\") {\n    if (aChunk) {\n      this.children.push(aChunk);\n    }\n  }\n  else {\n    throw new TypeError(\n      \"Expected a SourceNode, string, or an array of SourceNodes and strings. Got \" + aChunk\n    );\n  }\n  return this;\n};\n\n/**\n * Add a chunk of generated JS to the beginning of this source node.\n *\n * @param aChunk A string snippet of generated JS code, another instance of\n *        SourceNode, or an array where each member is one of those things.\n */\nSourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {\n  if (Array.isArray(aChunk)) {\n    for (var i = aChunk.length-1; i >= 0; i--) {\n      this.prepend(aChunk[i]);\n    }\n  }\n  else if (aChunk[isSourceNode] || typeof aChunk === \"string\") {\n    this.children.unshift(aChunk);\n  }\n  else {\n    throw new TypeError(\n      \"Expected a SourceNode, string, or an array of SourceNodes and strings. Got \" + aChunk\n    );\n  }\n  return this;\n};\n\n/**\n * Walk over the tree of JS snippets in this node and its children. The\n * walking function is called once for each snippet of JS and is passed that\n * snippet and the its original associated source's line/column location.\n *\n * @param aFn The traversal function.\n */\nSourceNode.prototype.walk = function SourceNode_walk(aFn) {\n  var chunk;\n  for (var i = 0, len = this.children.length; i < len; i++) {\n    chunk = this.children[i];\n    if (chunk[isSourceNode]) {\n      chunk.walk(aFn);\n    }\n    else {\n      if (chunk !== '') {\n        aFn(chunk, { source: this.source,\n                     line: this.line,\n                     column: this.column,\n                     name: this.name });\n      }\n    }\n  }\n};\n\n/**\n * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between\n * each of `this.children`.\n *\n * @param aSep The separator.\n */\nSourceNode.prototype.join = function SourceNode_join(aSep) {\n  var newChildren;\n  var i;\n  var len = this.children.length;\n  if (len > 0) {\n    newChildren = [];\n    for (i = 0; i < len-1; i++) {\n      newChildren.push(this.children[i]);\n      newChildren.push(aSep);\n    }\n    newChildren.push(this.children[i]);\n    this.children = newChildren;\n  }\n  return this;\n};\n\n/**\n * Call String.prototype.replace on the very right-most source snippet. Useful\n * for trimming whitespace from the end of a source node, etc.\n *\n * @param aPattern The pattern to replace.\n * @param aReplacement The thing to replace the pattern with.\n */\nSourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {\n  var lastChild = this.children[this.children.length - 1];\n  if (lastChild[isSourceNode]) {\n    lastChild.replaceRight(aPattern, aReplacement);\n  }\n  else if (typeof lastChild === 'string') {\n    this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);\n  }\n  else {\n    this.children.push(''.replace(aPattern, aReplacement));\n  }\n  return this;\n};\n\n/**\n * Set the source content for a source file. This will be added to the SourceMapGenerator\n * in the sourcesContent field.\n *\n * @param aSourceFile The filename of the source file\n * @param aSourceContent The content of the source file\n */\nSourceNode.prototype.setSourceContent =\n  function SourceNode_setSourceContent(aSourceFile, aSourceContent) {\n    this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;\n  };\n\n/**\n * Walk over the tree of SourceNodes. The walking function is called for each\n * source file content and is passed the filename and source content.\n *\n * @param aFn The traversal function.\n */\nSourceNode.prototype.walkSourceContents =\n  function SourceNode_walkSourceContents(aFn) {\n    for (var i = 0, len = this.children.length; i < len; i++) {\n      if (this.children[i][isSourceNode]) {\n        this.children[i].walkSourceContents(aFn);\n      }\n    }\n\n    var sources = Object.keys(this.sourceContents);\n    for (var i = 0, len = sources.length; i < len; i++) {\n      aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);\n    }\n  };\n\n/**\n * Return the string representation of this source node. Walks over the tree\n * and concatenates all the various snippets together to one string.\n */\nSourceNode.prototype.toString = function SourceNode_toString() {\n  var str = \"\";\n  this.walk(function (chunk) {\n    str += chunk;\n  });\n  return str;\n};\n\n/**\n * Returns the string representation of this source node along with a source\n * map.\n */\nSourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {\n  var generated = {\n    code: \"\",\n    line: 1,\n    column: 0\n  };\n  var map = new SourceMapGenerator(aArgs);\n  var sourceMappingActive = false;\n  var lastOriginalSource = null;\n  var lastOriginalLine = null;\n  var lastOriginalColumn = null;\n  var lastOriginalName = null;\n  this.walk(function (chunk, original) {\n    generated.code += chunk;\n    if (original.source !== null\n        && original.line !== null\n        && original.column !== null) {\n      if(lastOriginalSource !== original.source\n         || lastOriginalLine !== original.line\n         || lastOriginalColumn !== original.column\n         || lastOriginalName !== original.name) {\n        map.addMapping({\n          source: original.source,\n          original: {\n            line: original.line,\n            column: original.column\n          },\n          generated: {\n            line: generated.line,\n            column: generated.column\n          },\n          name: original.name\n        });\n      }\n      lastOriginalSource = original.source;\n      lastOriginalLine = original.line;\n      lastOriginalColumn = original.column;\n      lastOriginalName = original.name;\n      sourceMappingActive = true;\n    } else if (sourceMappingActive) {\n      map.addMapping({\n        generated: {\n          line: generated.line,\n          column: generated.column\n        }\n      });\n      lastOriginalSource = null;\n      sourceMappingActive = false;\n    }\n    for (var idx = 0, length = chunk.length; idx < length; idx++) {\n      if (chunk.charCodeAt(idx) === NEWLINE_CODE) {\n        generated.line++;\n        generated.column = 0;\n        // Mappings end at eol\n        if (idx + 1 === length) {\n          lastOriginalSource = null;\n          sourceMappingActive = false;\n        } else if (sourceMappingActive) {\n          map.addMapping({\n            source: original.source,\n            original: {\n              line: original.line,\n              column: original.column\n            },\n            generated: {\n              line: generated.line,\n              column: generated.column\n            },\n            name: original.name\n          });\n        }\n      } else {\n        generated.column++;\n      }\n    }\n  });\n  this.walkSourceContents(function (sourceFile, sourceContent) {\n    map.setSourceContent(sourceFile, sourceContent);\n  });\n\n  return { code: generated.code, map: map };\n};\n\nexports.SourceNode = SourceNode;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/source-node.js\n// module id = 10\n// module chunks = 0"],"sourceRoot":""}
\ No newline at end of file
diff --git a/node_modules/@babel/core/node_modules/source-map/dist/source-map.js b/node_modules/@babel/core/node_modules/source-map/dist/source-map.js
new file mode 100644
index 00000000..4e630e29
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/source-map/dist/source-map.js
@@ -0,0 +1,3090 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], 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) {
+	    // When aOriginal is truthy but has empty values for .line and .column,
+	    // it is most likely a programmer error. In this case we throw a very
+	    // specific error message to try to guide them the right way.
+	    // For example: https://github.com/Polymer/polymer-bundler/pull/519
+	    if (aOriginal && typeof aOriginal.line !== 'number' && typeof aOriginal.column !== 'number') {
+	        throw new Error(
+	            'original.line and original.column are not numbers -- you probably meant to omit ' +
+	            'the original mapping entirely and only map the generated position. If so, pass ' +
+	            'null for the original mapping instead of an object with empty or null values.'
+	        );
+	    }
+
+	    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 consecutive 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;
+	var hasNativeMap = typeof Map !== "undefined";
+
+	/**
+	 * 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 = hasNativeMap ? new Map() : 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 hasNativeMap ? this._set.size : 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 = hasNativeMap ? aStr : util.toSetString(aStr);
+	  var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
+	  var idx = this._array.length;
+	  if (!isDuplicate || aAllowDuplicates) {
+	    this._array.push(aStr);
+	  }
+	  if (!isDuplicate) {
+	    if (hasNativeMap) {
+	      this._set.set(aStr, idx);
+	    } else {
+	      this._set[sStr] = idx;
+	    }
+	  }
+	};
+
+	/**
+	 * Is the given string a member of this set?
+	 *
+	 * @param String aStr
+	 */
+	ArraySet.prototype.has = function ArraySet_has(aStr) {
+	  if (hasNativeMap) {
+	    return this._set.has(aStr);
+	  } else {
+	    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) {
+	  if (hasNativeMap) {
+	    var idx = this._set.get(aStr);
+	    if (idx >= 0) {
+	        return idx;
+	    }
+	  } else {
+	    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 accessed by calling `shiftNextLine`.
+	    var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
+	    var remainingLinesIndex = 0;
+	    var shiftNextLine = function() {
+	      var lineContents = getNextLine();
+	      // The last line of a file might not have a newline.
+	      var newLine = getNextLine() || "";
+	      return lineContents + newLine;
+
+	      function getNextLine() {
+	        return remainingLinesIndex < remainingLines.length ?
+	            remainingLines[remainingLinesIndex++] : undefined;
+	      }
+	    };
+
+	    // 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[remainingLinesIndex];
+	          var code = nextLine.substr(0, mapping.generatedColumn -
+	                                        lastGeneratedColumn);
+	          remainingLines[remainingLinesIndex] = 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[remainingLinesIndex];
+	        node.add(nextLine.substr(0, mapping.generatedColumn));
+	        remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
+	        lastGeneratedColumn = mapping.generatedColumn;
+	      }
+	      lastMapping = mapping;
+	    }, this);
+	    // We have processed all mappings.
+	    if (remainingLinesIndex < remainingLines.length) {
+	      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.splice(remainingLinesIndex).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) {
+	        node.add(code);
+	      } else {
+	        var source = aRelativePath
+	          ? util.join(aRelativePath, mapping.source)
+	          : mapping.source;
+	        node.add(new SourceNode(mapping.originalLine,
+	                                mapping.originalColumn,
+	                                source,
+	                                code,
+	                                mapping.name));
+	      }
+	    }
+	  };
+
+	/**
+	 * Add a chunk of generated JS to this source node.
+	 *
+	 * @param aChunk A string snippet of generated JS code, another instance of
+	 *        SourceNode, or an array where each member is one of those things.
+	 */
+	SourceNode.prototype.add = function SourceNode_add(aChunk) {
+	  if (Array.isArray(aChunk)) {
+	    aChunk.forEach(function (chunk) {
+	      this.add(chunk);
+	    }, this);
+	  }
+	  else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+	    if (aChunk) {
+	      this.children.push(aChunk);
+	    }
+	  }
+	  else {
+	    throw new TypeError(
+	      "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+	    );
+	  }
+	  return this;
+	};
+
+	/**
+	 * Add a chunk of generated JS to the beginning of this source node.
+	 *
+	 * @param aChunk A string snippet of generated JS code, another instance of
+	 *        SourceNode, or an array where each member is one of those things.
+	 */
+	SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
+	  if (Array.isArray(aChunk)) {
+	    for (var i = aChunk.length-1; i >= 0; i--) {
+	      this.prepend(aChunk[i]);
+	    }
+	  }
+	  else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+	    this.children.unshift(aChunk);
+	  }
+	  else {
+	    throw new TypeError(
+	      "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+	    );
+	  }
+	  return this;
+	};
+
+	/**
+	 * Walk over the tree of JS snippets in this node and its children. The
+	 * walking function is called once for each snippet of JS and is passed that
+	 * snippet and the its original associated source's line/column location.
+	 *
+	 * @param aFn The traversal function.
+	 */
+	SourceNode.prototype.walk = function SourceNode_walk(aFn) {
+	  var chunk;
+	  for (var i = 0, len = this.children.length; i < len; i++) {
+	    chunk = this.children[i];
+	    if (chunk[isSourceNode]) {
+	      chunk.walk(aFn);
+	    }
+	    else {
+	      if (chunk !== '') {
+	        aFn(chunk, { source: this.source,
+	                     line: this.line,
+	                     column: this.column,
+	                     name: this.name });
+	      }
+	    }
+	  }
+	};
+
+	/**
+	 * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
+	 * each of `this.children`.
+	 *
+	 * @param aSep The separator.
+	 */
+	SourceNode.prototype.join = function SourceNode_join(aSep) {
+	  var newChildren;
+	  var i;
+	  var len = this.children.length;
+	  if (len > 0) {
+	    newChildren = [];
+	    for (i = 0; i < len-1; i++) {
+	      newChildren.push(this.children[i]);
+	      newChildren.push(aSep);
+	    }
+	    newChildren.push(this.children[i]);
+	    this.children = newChildren;
+	  }
+	  return this;
+	};
+
+	/**
+	 * Call String.prototype.replace on the very right-most source snippet. Useful
+	 * for trimming whitespace from the end of a source node, etc.
+	 *
+	 * @param aPattern The pattern to replace.
+	 * @param aReplacement The thing to replace the pattern with.
+	 */
+	SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
+	  var lastChild = this.children[this.children.length - 1];
+	  if (lastChild[isSourceNode]) {
+	    lastChild.replaceRight(aPattern, aReplacement);
+	  }
+	  else if (typeof lastChild === 'string') {
+	    this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
+	  }
+	  else {
+	    this.children.push(''.replace(aPattern, aReplacement));
+	  }
+	  return this;
+	};
+
+	/**
+	 * Set the source content for a source file. This will be added to the SourceMapGenerator
+	 * in the sourcesContent field.
+	 *
+	 * @param aSourceFile The filename of the source file
+	 * @param aSourceContent The content of the source file
+	 */
+	SourceNode.prototype.setSourceContent =
+	  function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
+	    this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
+	  };
+
+	/**
+	 * Walk over the tree of SourceNodes. The walking function is called for each
+	 * source file content and is passed the filename and source content.
+	 *
+	 * @param aFn The traversal function.
+	 */
+	SourceNode.prototype.walkSourceContents =
+	  function SourceNode_walkSourceContents(aFn) {
+	    for (var i = 0, len = this.children.length; i < len; i++) {
+	      if (this.children[i][isSourceNode]) {
+	        this.children[i].walkSourceContents(aFn);
+	      }
+	    }
+
+	    var sources = Object.keys(this.sourceContents);
+	    for (var i = 0, len = sources.length; i < len; i++) {
+	      aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
+	    }
+	  };
+
+	/**
+	 * Return the string representation of this source node. Walks over the tree
+	 * and concatenates all the various snippets together to one string.
+	 */
+	SourceNode.prototype.toString = function SourceNode_toString() {
+	  var str = "";
+	  this.walk(function (chunk) {
+	    str += chunk;
+	  });
+	  return str;
+	};
+
+	/**
+	 * Returns the string representation of this source node along with a source
+	 * map.
+	 */
+	SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
+	  var generated = {
+	    code: "",
+	    line: 1,
+	    column: 0
+	  };
+	  var map = new SourceMapGenerator(aArgs);
+	  var sourceMappingActive = false;
+	  var lastOriginalSource = null;
+	  var lastOriginalLine = null;
+	  var lastOriginalColumn = null;
+	  var lastOriginalName = null;
+	  this.walk(function (chunk, original) {
+	    generated.code += chunk;
+	    if (original.source !== null
+	        && original.line !== null
+	        && original.column !== null) {
+	      if(lastOriginalSource !== original.source
+	         || lastOriginalLine !== original.line
+	         || lastOriginalColumn !== original.column
+	         || lastOriginalName !== original.name) {
+	        map.addMapping({
+	          source: original.source,
+	          original: {
+	            line: original.line,
+	            column: original.column
+	          },
+	          generated: {
+	            line: generated.line,
+	            column: generated.column
+	          },
+	          name: original.name
+	        });
+	      }
+	      lastOriginalSource = original.source;
+	      lastOriginalLine = original.line;
+	      lastOriginalColumn = original.column;
+	      lastOriginalName = original.name;
+	      sourceMappingActive = true;
+	    } else if (sourceMappingActive) {
+	      map.addMapping({
+	        generated: {
+	          line: generated.line,
+	          column: generated.column
+	        }
+	      });
+	      lastOriginalSource = null;
+	      sourceMappingActive = false;
+	    }
+	    for (var idx = 0, length = chunk.length; idx < length; idx++) {
+	      if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
+	        generated.line++;
+	        generated.column = 0;
+	        // Mappings end at eol
+	        if (idx + 1 === length) {
+	          lastOriginalSource = null;
+	          sourceMappingActive = false;
+	        } else if (sourceMappingActive) {
+	          map.addMapping({
+	            source: original.source,
+	            original: {
+	              line: original.line,
+	              column: original.column
+	            },
+	            generated: {
+	              line: generated.line,
+	              column: generated.column
+	            },
+	            name: original.name
+	          });
+	        }
+	      } else {
+	        generated.column++;
+	      }
+	    }
+	  });
+	  this.walkSourceContents(function (sourceFile, sourceContent) {
+	    map.setSourceContent(sourceFile, sourceContent);
+	  });
+
+	  return { code: generated.code, map: map };
+	};
+
+	exports.SourceNode = SourceNode;
+
+
+/***/ })
+/******/ ])
+});
+;
\ No newline at end of file
diff --git a/node_modules/@babel/core/node_modules/source-map/dist/source-map.min.js b/node_modules/@babel/core/node_modules/source-map/dist/source-map.min.js
new file mode 100644
index 00000000..f2a46bd0
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/source-map/dist/source-map.min.js
@@ -0,0 +1,2 @@
+!function(e,n){"object"==typeof exports&&"object"==typeof module?module.exports=n():"function"==typeof define&&define.amd?define([],n):"object"==typeof exports?exports.sourceMap=n():e.sourceMap=n()}(this,function(){return function(e){function n(t){if(r[t])return r[t].exports;var o=r[t]={exports:{},id:t,loaded:!1};return e[t].call(o.exports,o,o.exports,n),o.loaded=!0,o.exports}var r={};return n.m=e,n.c=r,n.p="",n(0)}([function(e,n,r){n.SourceMapGenerator=r(1).SourceMapGenerator,n.SourceMapConsumer=r(7).SourceMapConsumer,n.SourceNode=r(10).SourceNode},function(e,n,r){function t(e){e||(e={}),this._file=i.getArg(e,"file",null),this._sourceRoot=i.getArg(e,"sourceRoot",null),this._skipValidation=i.getArg(e,"skipValidation",!1),this._sources=new s,this._names=new s,this._mappings=new a,this._sourcesContents=null}var o=r(2),i=r(4),s=r(5).ArraySet,a=r(6).MappingList;t.prototype._version=3,t.fromSourceMap=function(e){var n=e.sourceRoot,r=new t({file:e.file,sourceRoot:n});return e.eachMapping(function(e){var t={generated:{line:e.generatedLine,column:e.generatedColumn}};null!=e.source&&(t.source=e.source,null!=n&&(t.source=i.relative(n,t.source)),t.original={line:e.originalLine,column:e.originalColumn},null!=e.name&&(t.name=e.name)),r.addMapping(t)}),e.sources.forEach(function(n){var t=e.sourceContentFor(n);null!=t&&r.setSourceContent(n,t)}),r},t.prototype.addMapping=function(e){var n=i.getArg(e,"generated"),r=i.getArg(e,"original",null),t=i.getArg(e,"source",null),o=i.getArg(e,"name",null);this._skipValidation||this._validateMapping(n,r,t,o),null!=t&&(t=String(t),this._sources.has(t)||this._sources.add(t)),null!=o&&(o=String(o),this._names.has(o)||this._names.add(o)),this._mappings.add({generatedLine:n.line,generatedColumn:n.column,originalLine:null!=r&&r.line,originalColumn:null!=r&&r.column,source:t,name:o})},t.prototype.setSourceContent=function(e,n){var r=e;null!=this._sourceRoot&&(r=i.relative(this._sourceRoot,r)),null!=n?(this._sourcesContents||(this._sourcesContents=Object.create(null)),this._sourcesContents[i.toSetString(r)]=n):this._sourcesContents&&(delete this._sourcesContents[i.toSetString(r)],0===Object.keys(this._sourcesContents).length&&(this._sourcesContents=null))},t.prototype.applySourceMap=function(e,n,r){var t=n;if(null==n){if(null==e.file)throw new Error('SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, or the source map\'s "file" property. Both were omitted.');t=e.file}var o=this._sourceRoot;null!=o&&(t=i.relative(o,t));var a=new s,u=new s;this._mappings.unsortedForEach(function(n){if(n.source===t&&null!=n.originalLine){var s=e.originalPositionFor({line:n.originalLine,column:n.originalColumn});null!=s.source&&(n.source=s.source,null!=r&&(n.source=i.join(r,n.source)),null!=o&&(n.source=i.relative(o,n.source)),n.originalLine=s.line,n.originalColumn=s.column,null!=s.name&&(n.name=s.name))}var l=n.source;null==l||a.has(l)||a.add(l);var c=n.name;null==c||u.has(c)||u.add(c)},this),this._sources=a,this._names=u,e.sources.forEach(function(n){var t=e.sourceContentFor(n);null!=t&&(null!=r&&(n=i.join(r,n)),null!=o&&(n=i.relative(o,n)),this.setSourceContent(n,t))},this)},t.prototype._validateMapping=function(e,n,r,t){if(n&&"number"!=typeof n.line&&"number"!=typeof n.column)throw new Error("original.line and original.column are not numbers -- you probably meant to omit the original mapping entirely and only map the generated position. If so, pass null for the original mapping instead of an object with empty or null values.");if((!(e&&"line"in e&&"column"in e&&e.line>0&&e.column>=0)||n||r||t)&&!(e&&"line"in e&&"column"in e&&n&&"line"in n&&"column"in n&&e.line>0&&e.column>=0&&n.line>0&&n.column>=0&&r))throw new Error("Invalid mapping: "+JSON.stringify({generated:e,source:r,original:n,name:t}))},t.prototype._serializeMappings=function(){for(var e,n,r,t,s=0,a=1,u=0,l=0,c=0,g=0,p="",h=this._mappings.toArray(),f=0,d=h.length;f<d;f++){if(n=h[f],e="",n.generatedLine!==a)for(s=0;n.generatedLine!==a;)e+=";",a++;else if(f>0){if(!i.compareByGeneratedPositionsInflated(n,h[f-1]))continue;e+=","}e+=o.encode(n.generatedColumn-s),s=n.generatedColumn,null!=n.source&&(t=this._sources.indexOf(n.source),e+=o.encode(t-g),g=t,e+=o.encode(n.originalLine-1-l),l=n.originalLine-1,e+=o.encode(n.originalColumn-u),u=n.originalColumn,null!=n.name&&(r=this._names.indexOf(n.name),e+=o.encode(r-c),c=r)),p+=e}return p},t.prototype._generateSourcesContent=function(e,n){return e.map(function(e){if(!this._sourcesContents)return null;null!=n&&(e=i.relative(n,e));var r=i.toSetString(e);return Object.prototype.hasOwnProperty.call(this._sourcesContents,r)?this._sourcesContents[r]:null},this)},t.prototype.toJSON=function(){var e={version:this._version,sources:this._sources.toArray(),names:this._names.toArray(),mappings:this._serializeMappings()};return null!=this._file&&(e.file=this._file),null!=this._sourceRoot&&(e.sourceRoot=this._sourceRoot),this._sourcesContents&&(e.sourcesContent=this._generateSourcesContent(e.sources,e.sourceRoot)),e},t.prototype.toString=function(){return JSON.stringify(this.toJSON())},n.SourceMapGenerator=t},function(e,n,r){function t(e){return e<0?(-e<<1)+1:(e<<1)+0}function o(e){var n=1===(1&e),r=e>>1;return n?-r:r}var i=r(3),s=5,a=1<<s,u=a-1,l=a;n.encode=function(e){var n,r="",o=t(e);do n=o&u,o>>>=s,o>0&&(n|=l),r+=i.encode(n);while(o>0);return r},n.decode=function(e,n,r){var t,a,c=e.length,g=0,p=0;do{if(n>=c)throw new Error("Expected more digits in base 64 VLQ value.");if(a=i.decode(e.charCodeAt(n++)),a===-1)throw new Error("Invalid base64 digit: "+e.charAt(n-1));t=!!(a&l),a&=u,g+=a<<p,p+=s}while(t);r.value=o(g),r.rest=n}},function(e,n){var r="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");n.encode=function(e){if(0<=e&&e<r.length)return r[e];throw new TypeError("Must be between 0 and 63: "+e)},n.decode=function(e){var n=65,r=90,t=97,o=122,i=48,s=57,a=43,u=47,l=26,c=52;return n<=e&&e<=r?e-n:t<=e&&e<=o?e-t+l:i<=e&&e<=s?e-i+c:e==a?62:e==u?63:-1}},function(e,n){function r(e,n,r){if(n in e)return e[n];if(3===arguments.length)return r;throw new Error('"'+n+'" is a required argument.')}function t(e){var n=e.match(m);return n?{scheme:n[1],auth:n[2],host:n[3],port:n[4],path:n[5]}:null}function o(e){var n="";return e.scheme&&(n+=e.scheme+":"),n+="//",e.auth&&(n+=e.auth+"@"),e.host&&(n+=e.host),e.port&&(n+=":"+e.port),e.path&&(n+=e.path),n}function i(e){var r=e,i=t(e);if(i){if(!i.path)return e;r=i.path}for(var s,a=n.isAbsolute(r),u=r.split(/\/+/),l=0,c=u.length-1;c>=0;c--)s=u[c],"."===s?u.splice(c,1):".."===s?l++:l>0&&(""===s?(u.splice(c+1,l),l=0):(u.splice(c,2),l--));return r=u.join("/"),""===r&&(r=a?"/":"."),i?(i.path=r,o(i)):r}function s(e,n){""===e&&(e="."),""===n&&(n=".");var r=t(n),s=t(e);if(s&&(e=s.path||"/"),r&&!r.scheme)return s&&(r.scheme=s.scheme),o(r);if(r||n.match(_))return n;if(s&&!s.host&&!s.path)return s.host=n,o(s);var a="/"===n.charAt(0)?n:i(e.replace(/\/+$/,"")+"/"+n);return s?(s.path=a,o(s)):a}function a(e,n){""===e&&(e="."),e=e.replace(/\/$/,"");for(var r=0;0!==n.indexOf(e+"/");){var t=e.lastIndexOf("/");if(t<0)return n;if(e=e.slice(0,t),e.match(/^([^\/]+:\/)?\/*$/))return n;++r}return Array(r+1).join("../")+n.substr(e.length+1)}function u(e){return e}function l(e){return g(e)?"$"+e:e}function c(e){return g(e)?e.slice(1):e}function g(e){if(!e)return!1;var n=e.length;if(n<9)return!1;if(95!==e.charCodeAt(n-1)||95!==e.charCodeAt(n-2)||111!==e.charCodeAt(n-3)||116!==e.charCodeAt(n-4)||111!==e.charCodeAt(n-5)||114!==e.charCodeAt(n-6)||112!==e.charCodeAt(n-7)||95!==e.charCodeAt(n-8)||95!==e.charCodeAt(n-9))return!1;for(var r=n-10;r>=0;r--)if(36!==e.charCodeAt(r))return!1;return!0}function p(e,n,r){var t=e.source-n.source;return 0!==t?t:(t=e.originalLine-n.originalLine,0!==t?t:(t=e.originalColumn-n.originalColumn,0!==t||r?t:(t=e.generatedColumn-n.generatedColumn,0!==t?t:(t=e.generatedLine-n.generatedLine,0!==t?t:e.name-n.name))))}function h(e,n,r){var t=e.generatedLine-n.generatedLine;return 0!==t?t:(t=e.generatedColumn-n.generatedColumn,0!==t||r?t:(t=e.source-n.source,0!==t?t:(t=e.originalLine-n.originalLine,0!==t?t:(t=e.originalColumn-n.originalColumn,0!==t?t:e.name-n.name))))}function f(e,n){return e===n?0:e>n?1:-1}function d(e,n){var r=e.generatedLine-n.generatedLine;return 0!==r?r:(r=e.generatedColumn-n.generatedColumn,0!==r?r:(r=f(e.source,n.source),0!==r?r:(r=e.originalLine-n.originalLine,0!==r?r:(r=e.originalColumn-n.originalColumn,0!==r?r:f(e.name,n.name)))))}n.getArg=r;var m=/^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.]*)(?::(\d+))?(\S*)$/,_=/^data:.+\,.+$/;n.urlParse=t,n.urlGenerate=o,n.normalize=i,n.join=s,n.isAbsolute=function(e){return"/"===e.charAt(0)||!!e.match(m)},n.relative=a;var v=function(){var e=Object.create(null);return!("__proto__"in e)}();n.toSetString=v?u:l,n.fromSetString=v?u:c,n.compareByOriginalPositions=p,n.compareByGeneratedPositionsDeflated=h,n.compareByGeneratedPositionsInflated=d},function(e,n,r){function t(){this._array=[],this._set=s?new Map:Object.create(null)}var o=r(4),i=Object.prototype.hasOwnProperty,s="undefined"!=typeof Map;t.fromArray=function(e,n){for(var r=new t,o=0,i=e.length;o<i;o++)r.add(e[o],n);return r},t.prototype.size=function(){return s?this._set.size:Object.getOwnPropertyNames(this._set).length},t.prototype.add=function(e,n){var r=s?e:o.toSetString(e),t=s?this.has(e):i.call(this._set,r),a=this._array.length;t&&!n||this._array.push(e),t||(s?this._set.set(e,a):this._set[r]=a)},t.prototype.has=function(e){if(s)return this._set.has(e);var n=o.toSetString(e);return i.call(this._set,n)},t.prototype.indexOf=function(e){if(s){var n=this._set.get(e);if(n>=0)return n}else{var r=o.toSetString(e);if(i.call(this._set,r))return this._set[r]}throw new Error('"'+e+'" is not in the set.')},t.prototype.at=function(e){if(e>=0&&e<this._array.length)return this._array[e];throw new Error("No element indexed by "+e)},t.prototype.toArray=function(){return this._array.slice()},n.ArraySet=t},function(e,n,r){function t(e,n){var r=e.generatedLine,t=n.generatedLine,o=e.generatedColumn,s=n.generatedColumn;return t>r||t==r&&s>=o||i.compareByGeneratedPositionsInflated(e,n)<=0}function o(){this._array=[],this._sorted=!0,this._last={generatedLine:-1,generatedColumn:0}}var i=r(4);o.prototype.unsortedForEach=function(e,n){this._array.forEach(e,n)},o.prototype.add=function(e){t(this._last,e)?(this._last=e,this._array.push(e)):(this._sorted=!1,this._array.push(e))},o.prototype.toArray=function(){return this._sorted||(this._array.sort(i.compareByGeneratedPositionsInflated),this._sorted=!0),this._array},n.MappingList=o},function(e,n,r){function t(e){var n=e;return"string"==typeof e&&(n=JSON.parse(e.replace(/^\)\]\}'/,""))),null!=n.sections?new s(n):new o(n)}function o(e){var n=e;"string"==typeof e&&(n=JSON.parse(e.replace(/^\)\]\}'/,"")));var r=a.getArg(n,"version"),t=a.getArg(n,"sources"),o=a.getArg(n,"names",[]),i=a.getArg(n,"sourceRoot",null),s=a.getArg(n,"sourcesContent",null),u=a.getArg(n,"mappings"),c=a.getArg(n,"file",null);if(r!=this._version)throw new Error("Unsupported version: "+r);t=t.map(String).map(a.normalize).map(function(e){return i&&a.isAbsolute(i)&&a.isAbsolute(e)?a.relative(i,e):e}),this._names=l.fromArray(o.map(String),!0),this._sources=l.fromArray(t,!0),this.sourceRoot=i,this.sourcesContent=s,this._mappings=u,this.file=c}function i(){this.generatedLine=0,this.generatedColumn=0,this.source=null,this.originalLine=null,this.originalColumn=null,this.name=null}function s(e){var n=e;"string"==typeof e&&(n=JSON.parse(e.replace(/^\)\]\}'/,"")));var r=a.getArg(n,"version"),o=a.getArg(n,"sections");if(r!=this._version)throw new Error("Unsupported version: "+r);this._sources=new l,this._names=new l;var i={line:-1,column:0};this._sections=o.map(function(e){if(e.url)throw new Error("Support for url field in sections not implemented.");var n=a.getArg(e,"offset"),r=a.getArg(n,"line"),o=a.getArg(n,"column");if(r<i.line||r===i.line&&o<i.column)throw new Error("Section offsets must be ordered and non-overlapping.");return i=n,{generatedOffset:{generatedLine:r+1,generatedColumn:o+1},consumer:new t(a.getArg(e,"map"))}})}var a=r(4),u=r(8),l=r(5).ArraySet,c=r(2),g=r(9).quickSort;t.fromSourceMap=function(e){return o.fromSourceMap(e)},t.prototype._version=3,t.prototype.__generatedMappings=null,Object.defineProperty(t.prototype,"_generatedMappings",{get:function(){return this.__generatedMappings||this._parseMappings(this._mappings,this.sourceRoot),this.__generatedMappings}}),t.prototype.__originalMappings=null,Object.defineProperty(t.prototype,"_originalMappings",{get:function(){return this.__originalMappings||this._parseMappings(this._mappings,this.sourceRoot),this.__originalMappings}}),t.prototype._charIsMappingSeparator=function(e,n){var r=e.charAt(n);return";"===r||","===r},t.prototype._parseMappings=function(e,n){throw new Error("Subclasses must implement _parseMappings")},t.GENERATED_ORDER=1,t.ORIGINAL_ORDER=2,t.GREATEST_LOWER_BOUND=1,t.LEAST_UPPER_BOUND=2,t.prototype.eachMapping=function(e,n,r){var o,i=n||null,s=r||t.GENERATED_ORDER;switch(s){case t.GENERATED_ORDER:o=this._generatedMappings;break;case t.ORIGINAL_ORDER:o=this._originalMappings;break;default:throw new Error("Unknown order of iteration.")}var u=this.sourceRoot;o.map(function(e){var n=null===e.source?null:this._sources.at(e.source);return null!=n&&null!=u&&(n=a.join(u,n)),{source:n,generatedLine:e.generatedLine,generatedColumn:e.generatedColumn,originalLine:e.originalLine,originalColumn:e.originalColumn,name:null===e.name?null:this._names.at(e.name)}},this).forEach(e,i)},t.prototype.allGeneratedPositionsFor=function(e){var n=a.getArg(e,"line"),r={source:a.getArg(e,"source"),originalLine:n,originalColumn:a.getArg(e,"column",0)};if(null!=this.sourceRoot&&(r.source=a.relative(this.sourceRoot,r.source)),!this._sources.has(r.source))return[];r.source=this._sources.indexOf(r.source);var t=[],o=this._findMapping(r,this._originalMappings,"originalLine","originalColumn",a.compareByOriginalPositions,u.LEAST_UPPER_BOUND);if(o>=0){var i=this._originalMappings[o];if(void 0===e.column)for(var s=i.originalLine;i&&i.originalLine===s;)t.push({line:a.getArg(i,"generatedLine",null),column:a.getArg(i,"generatedColumn",null),lastColumn:a.getArg(i,"lastGeneratedColumn",null)}),i=this._originalMappings[++o];else for(var l=i.originalColumn;i&&i.originalLine===n&&i.originalColumn==l;)t.push({line:a.getArg(i,"generatedLine",null),column:a.getArg(i,"generatedColumn",null),lastColumn:a.getArg(i,"lastGeneratedColumn",null)}),i=this._originalMappings[++o]}return t},n.SourceMapConsumer=t,o.prototype=Object.create(t.prototype),o.prototype.consumer=t,o.fromSourceMap=function(e){var n=Object.create(o.prototype),r=n._names=l.fromArray(e._names.toArray(),!0),t=n._sources=l.fromArray(e._sources.toArray(),!0);n.sourceRoot=e._sourceRoot,n.sourcesContent=e._generateSourcesContent(n._sources.toArray(),n.sourceRoot),n.file=e._file;for(var s=e._mappings.toArray().slice(),u=n.__generatedMappings=[],c=n.__originalMappings=[],p=0,h=s.length;p<h;p++){var f=s[p],d=new i;d.generatedLine=f.generatedLine,d.generatedColumn=f.generatedColumn,f.source&&(d.source=t.indexOf(f.source),d.originalLine=f.originalLine,d.originalColumn=f.originalColumn,f.name&&(d.name=r.indexOf(f.name)),c.push(d)),u.push(d)}return g(n.__originalMappings,a.compareByOriginalPositions),n},o.prototype._version=3,Object.defineProperty(o.prototype,"sources",{get:function(){return this._sources.toArray().map(function(e){return null!=this.sourceRoot?a.join(this.sourceRoot,e):e},this)}}),o.prototype._parseMappings=function(e,n){for(var r,t,o,s,u,l=1,p=0,h=0,f=0,d=0,m=0,_=e.length,v=0,y={},C={},A=[],S=[];v<_;)if(";"===e.charAt(v))l++,v++,p=0;else if(","===e.charAt(v))v++;else{for(r=new i,r.generatedLine=l,s=v;s<_&&!this._charIsMappingSeparator(e,s);s++);if(t=e.slice(v,s),o=y[t])v+=t.length;else{for(o=[];v<s;)c.decode(e,v,C),u=C.value,v=C.rest,o.push(u);if(2===o.length)throw new Error("Found a source, but no line and column");if(3===o.length)throw new Error("Found a source and line, but no column");y[t]=o}r.generatedColumn=p+o[0],p=r.generatedColumn,o.length>1&&(r.source=d+o[1],d+=o[1],r.originalLine=h+o[2],h=r.originalLine,r.originalLine+=1,r.originalColumn=f+o[3],f=r.originalColumn,o.length>4&&(r.name=m+o[4],m+=o[4])),S.push(r),"number"==typeof r.originalLine&&A.push(r)}g(S,a.compareByGeneratedPositionsDeflated),this.__generatedMappings=S,g(A,a.compareByOriginalPositions),this.__originalMappings=A},o.prototype._findMapping=function(e,n,r,t,o,i){if(e[r]<=0)throw new TypeError("Line must be greater than or equal to 1, got "+e[r]);if(e[t]<0)throw new TypeError("Column must be greater than or equal to 0, got "+e[t]);return u.search(e,n,o,i)},o.prototype.computeColumnSpans=function(){for(var e=0;e<this._generatedMappings.length;++e){var n=this._generatedMappings[e];if(e+1<this._generatedMappings.length){var r=this._generatedMappings[e+1];if(n.generatedLine===r.generatedLine){n.lastGeneratedColumn=r.generatedColumn-1;continue}}n.lastGeneratedColumn=1/0}},o.prototype.originalPositionFor=function(e){var n={generatedLine:a.getArg(e,"line"),generatedColumn:a.getArg(e,"column")},r=this._findMapping(n,this._generatedMappings,"generatedLine","generatedColumn",a.compareByGeneratedPositionsDeflated,a.getArg(e,"bias",t.GREATEST_LOWER_BOUND));if(r>=0){var o=this._generatedMappings[r];if(o.generatedLine===n.generatedLine){var i=a.getArg(o,"source",null);null!==i&&(i=this._sources.at(i),null!=this.sourceRoot&&(i=a.join(this.sourceRoot,i)));var s=a.getArg(o,"name",null);return null!==s&&(s=this._names.at(s)),{source:i,line:a.getArg(o,"originalLine",null),column:a.getArg(o,"originalColumn",null),name:s}}}return{source:null,line:null,column:null,name:null}},o.prototype.hasContentsOfAllSources=function(){return!!this.sourcesContent&&(this.sourcesContent.length>=this._sources.size()&&!this.sourcesContent.some(function(e){return null==e}))},o.prototype.sourceContentFor=function(e,n){if(!this.sourcesContent)return null;if(null!=this.sourceRoot&&(e=a.relative(this.sourceRoot,e)),this._sources.has(e))return this.sourcesContent[this._sources.indexOf(e)];var r;if(null!=this.sourceRoot&&(r=a.urlParse(this.sourceRoot))){var t=e.replace(/^file:\/\//,"");if("file"==r.scheme&&this._sources.has(t))return this.sourcesContent[this._sources.indexOf(t)];if((!r.path||"/"==r.path)&&this._sources.has("/"+e))return this.sourcesContent[this._sources.indexOf("/"+e)]}if(n)return null;throw new Error('"'+e+'" is not in the SourceMap.')},o.prototype.generatedPositionFor=function(e){var n=a.getArg(e,"source");if(null!=this.sourceRoot&&(n=a.relative(this.sourceRoot,n)),!this._sources.has(n))return{line:null,column:null,lastColumn:null};n=this._sources.indexOf(n);var r={source:n,originalLine:a.getArg(e,"line"),originalColumn:a.getArg(e,"column")},o=this._findMapping(r,this._originalMappings,"originalLine","originalColumn",a.compareByOriginalPositions,a.getArg(e,"bias",t.GREATEST_LOWER_BOUND));if(o>=0){var i=this._originalMappings[o];if(i.source===r.source)return{line:a.getArg(i,"generatedLine",null),column:a.getArg(i,"generatedColumn",null),lastColumn:a.getArg(i,"lastGeneratedColumn",null)}}return{line:null,column:null,lastColumn:null}},n.BasicSourceMapConsumer=o,s.prototype=Object.create(t.prototype),s.prototype.constructor=t,s.prototype._version=3,Object.defineProperty(s.prototype,"sources",{get:function(){for(var e=[],n=0;n<this._sections.length;n++)for(var r=0;r<this._sections[n].consumer.sources.length;r++)e.push(this._sections[n].consumer.sources[r]);return e}}),s.prototype.originalPositionFor=function(e){var n={generatedLine:a.getArg(e,"line"),generatedColumn:a.getArg(e,"column")},r=u.search(n,this._sections,function(e,n){var r=e.generatedLine-n.generatedOffset.generatedLine;return r?r:e.generatedColumn-n.generatedOffset.generatedColumn}),t=this._sections[r];return t?t.consumer.originalPositionFor({line:n.generatedLine-(t.generatedOffset.generatedLine-1),column:n.generatedColumn-(t.generatedOffset.generatedLine===n.generatedLine?t.generatedOffset.generatedColumn-1:0),bias:e.bias}):{source:null,line:null,column:null,name:null}},s.prototype.hasContentsOfAllSources=function(){return this._sections.every(function(e){return e.consumer.hasContentsOfAllSources()})},s.prototype.sourceContentFor=function(e,n){for(var r=0;r<this._sections.length;r++){var t=this._sections[r],o=t.consumer.sourceContentFor(e,!0);if(o)return o}if(n)return null;throw new Error('"'+e+'" is not in the SourceMap.')},s.prototype.generatedPositionFor=function(e){for(var n=0;n<this._sections.length;n++){var r=this._sections[n];if(r.consumer.sources.indexOf(a.getArg(e,"source"))!==-1){var t=r.consumer.generatedPositionFor(e);if(t){var o={line:t.line+(r.generatedOffset.generatedLine-1),column:t.column+(r.generatedOffset.generatedLine===t.line?r.generatedOffset.generatedColumn-1:0)};return o}}}return{line:null,column:null}},s.prototype._parseMappings=function(e,n){this.__generatedMappings=[],this.__originalMappings=[];for(var r=0;r<this._sections.length;r++)for(var t=this._sections[r],o=t.consumer._generatedMappings,i=0;i<o.length;i++){var s=o[i],u=t.consumer._sources.at(s.source);null!==t.consumer.sourceRoot&&(u=a.join(t.consumer.sourceRoot,u)),this._sources.add(u),u=this._sources.indexOf(u);var l=t.consumer._names.at(s.name);this._names.add(l),l=this._names.indexOf(l);var c={source:u,generatedLine:s.generatedLine+(t.generatedOffset.generatedLine-1),generatedColumn:s.generatedColumn+(t.generatedOffset.generatedLine===s.generatedLine?t.generatedOffset.generatedColumn-1:0),originalLine:s.originalLine,originalColumn:s.originalColumn,name:l};this.__generatedMappings.push(c),"number"==typeof c.originalLine&&this.__originalMappings.push(c)}g(this.__generatedMappings,a.compareByGeneratedPositionsDeflated),g(this.__originalMappings,a.compareByOriginalPositions)},n.IndexedSourceMapConsumer=s},function(e,n){function r(e,t,o,i,s,a){var u=Math.floor((t-e)/2)+e,l=s(o,i[u],!0);return 0===l?u:l>0?t-u>1?r(u,t,o,i,s,a):a==n.LEAST_UPPER_BOUND?t<i.length?t:-1:u:u-e>1?r(e,u,o,i,s,a):a==n.LEAST_UPPER_BOUND?u:e<0?-1:e}n.GREATEST_LOWER_BOUND=1,n.LEAST_UPPER_BOUND=2,n.search=function(e,t,o,i){if(0===t.length)return-1;var s=r(-1,t.length,e,t,o,i||n.GREATEST_LOWER_BOUND);if(s<0)return-1;for(;s-1>=0&&0===o(t[s],t[s-1],!0);)--s;return s}},function(e,n){function r(e,n,r){var t=e[n];e[n]=e[r],e[r]=t}function t(e,n){return Math.round(e+Math.random()*(n-e))}function o(e,n,i,s){if(i<s){var a=t(i,s),u=i-1;r(e,a,s);for(var l=e[s],c=i;c<s;c++)n(e[c],l)<=0&&(u+=1,r(e,u,c));r(e,u+1,c);var g=u+1;o(e,n,i,g-1),o(e,n,g+1,s)}}n.quickSort=function(e,n){o(e,n,0,e.length-1)}},function(e,n,r){function t(e,n,r,t,o){this.children=[],this.sourceContents={},this.line=null==e?null:e,this.column=null==n?null:n,this.source=null==r?null:r,this.name=null==o?null:o,this[u]=!0,null!=t&&this.add(t)}var o=r(1).SourceMapGenerator,i=r(4),s=/(\r?\n)/,a=10,u="$$$isSourceNode$$$";t.fromStringWithSourceMap=function(e,n,r){function o(e,n){if(null===e||void 0===e.source)a.add(n);else{var o=r?i.join(r,e.source):e.source;a.add(new t(e.originalLine,e.originalColumn,o,n,e.name))}}var a=new t,u=e.split(s),l=0,c=function(){function e(){return l<u.length?u[l++]:void 0}var n=e(),r=e()||"";return n+r},g=1,p=0,h=null;return n.eachMapping(function(e){if(null!==h){if(!(g<e.generatedLine)){var n=u[l],r=n.substr(0,e.generatedColumn-p);return u[l]=n.substr(e.generatedColumn-p),p=e.generatedColumn,o(h,r),void(h=e)}o(h,c()),g++,p=0}for(;g<e.generatedLine;)a.add(c()),g++;if(p<e.generatedColumn){var n=u[l];a.add(n.substr(0,e.generatedColumn)),u[l]=n.substr(e.generatedColumn),p=e.generatedColumn}h=e},this),l<u.length&&(h&&o(h,c()),a.add(u.splice(l).join(""))),n.sources.forEach(function(e){var t=n.sourceContentFor(e);null!=t&&(null!=r&&(e=i.join(r,e)),a.setSourceContent(e,t))}),a},t.prototype.add=function(e){if(Array.isArray(e))e.forEach(function(e){this.add(e)},this);else{if(!e[u]&&"string"!=typeof e)throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got "+e);e&&this.children.push(e)}return this},t.prototype.prepend=function(e){if(Array.isArray(e))for(var n=e.length-1;n>=0;n--)this.prepend(e[n]);else{if(!e[u]&&"string"!=typeof e)throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got "+e);this.children.unshift(e)}return this},t.prototype.walk=function(e){for(var n,r=0,t=this.children.length;r<t;r++)n=this.children[r],n[u]?n.walk(e):""!==n&&e(n,{source:this.source,line:this.line,column:this.column,name:this.name})},t.prototype.join=function(e){var n,r,t=this.children.length;if(t>0){for(n=[],r=0;r<t-1;r++)n.push(this.children[r]),n.push(e);n.push(this.children[r]),this.children=n}return this},t.prototype.replaceRight=function(e,n){var r=this.children[this.children.length-1];return r[u]?r.replaceRight(e,n):"string"==typeof r?this.children[this.children.length-1]=r.replace(e,n):this.children.push("".replace(e,n)),this},t.prototype.setSourceContent=function(e,n){this.sourceContents[i.toSetString(e)]=n},t.prototype.walkSourceContents=function(e){for(var n=0,r=this.children.length;n<r;n++)this.children[n][u]&&this.children[n].walkSourceContents(e);for(var t=Object.keys(this.sourceContents),n=0,r=t.length;n<r;n++)e(i.fromSetString(t[n]),this.sourceContents[t[n]])},t.prototype.toString=function(){var e="";return this.walk(function(n){e+=n}),e},t.prototype.toStringWithSourceMap=function(e){var n={code:"",line:1,column:0},r=new o(e),t=!1,i=null,s=null,u=null,l=null;return this.walk(function(e,o){n.code+=e,null!==o.source&&null!==o.line&&null!==o.column?(i===o.source&&s===o.line&&u===o.column&&l===o.name||r.addMapping({source:o.source,original:{line:o.line,column:o.column},generated:{line:n.line,column:n.column},name:o.name}),i=o.source,s=o.line,u=o.column,l=o.name,t=!0):t&&(r.addMapping({generated:{line:n.line,column:n.column}}),i=null,t=!1);for(var c=0,g=e.length;c<g;c++)e.charCodeAt(c)===a?(n.line++,n.column=0,c+1===g?(i=null,t=!1):t&&r.addMapping({source:o.source,original:{line:o.line,column:o.column},generated:{line:n.line,column:n.column},name:o.name})):n.column++}),this.walkSourceContents(function(e,n){r.setSourceContent(e,n)}),{code:n.code,map:r}},n.SourceNode=t}])});
+//# sourceMappingURL=source-map.min.js.map
\ No newline at end of file
diff --git a/node_modules/@babel/core/node_modules/source-map/dist/source-map.min.js.map b/node_modules/@babel/core/node_modules/source-map/dist/source-map.min.js.map
new file mode 100644
index 00000000..588b70cb
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/source-map/dist/source-map.min.js.map
@@ -0,0 +1 @@
+{"version":3,"sources":["webpack:///webpack/universalModuleDefinition","webpack:///source-map.min.js","webpack:///webpack/bootstrap 42c329f865e32e011afb","webpack:///./source-map.js","webpack:///./lib/source-map-generator.js","webpack:///./lib/base64-vlq.js","webpack:///./lib/base64.js","webpack:///./lib/util.js","webpack:///./lib/array-set.js","webpack:///./lib/mapping-list.js","webpack:///./lib/source-map-consumer.js","webpack:///./lib/binary-search.js","webpack:///./lib/quick-sort.js","webpack:///./lib/source-node.js"],"names":["root","factory","exports","module","define","amd","this","modules","__webpack_require__","moduleId","installedModules","id","loaded","call","m","c","p","SourceMapGenerator","SourceMapConsumer","SourceNode","aArgs","_file","util","getArg","_sourceRoot","_skipValidation","_sources","ArraySet","_names","_mappings","MappingList","_sourcesContents","base64VLQ","prototype","_version","fromSourceMap","aSourceMapConsumer","sourceRoot","generator","file","eachMapping","mapping","newMapping","generated","line","generatedLine","column","generatedColumn","source","relative","original","originalLine","originalColumn","name","addMapping","sources","forEach","sourceFile","content","sourceContentFor","setSourceContent","_validateMapping","String","has","add","aSourceFile","aSourceContent","Object","create","toSetString","keys","length","applySourceMap","aSourceMapPath","Error","newSources","newNames","unsortedForEach","originalPositionFor","join","aGenerated","aOriginal","aSource","aName","JSON","stringify","_serializeMappings","next","nameIdx","sourceIdx","previousGeneratedColumn","previousGeneratedLine","previousOriginalColumn","previousOriginalLine","previousName","previousSource","result","mappings","toArray","i","len","compareByGeneratedPositionsInflated","encode","indexOf","_generateSourcesContent","aSources","aSourceRoot","map","key","hasOwnProperty","toJSON","version","names","sourcesContent","toString","toVLQSigned","aValue","fromVLQSigned","isNegative","shifted","base64","VLQ_BASE_SHIFT","VLQ_BASE","VLQ_BASE_MASK","VLQ_CONTINUATION_BIT","digit","encoded","vlq","decode","aStr","aIndex","aOutParam","continuation","strLen","shift","charCodeAt","charAt","value","rest","intToCharMap","split","number","TypeError","charCode","bigA","bigZ","littleA","littleZ","zero","nine","plus","slash","littleOffset","numberOffset","aDefaultValue","arguments","urlParse","aUrl","match","urlRegexp","scheme","auth","host","port","path","urlGenerate","aParsedUrl","url","normalize","aPath","part","isAbsolute","parts","up","splice","aRoot","aPathUrl","aRootUrl","dataUrlRegexp","joined","replace","level","index","lastIndexOf","slice","Array","substr","identity","s","isProtoString","fromSetString","compareByOriginalPositions","mappingA","mappingB","onlyCompareOriginal","cmp","compareByGeneratedPositionsDeflated","onlyCompareGenerated","strcmp","aStr1","aStr2","supportsNullProto","obj","_array","_set","hasNativeMap","Map","fromArray","aArray","aAllowDuplicates","set","size","getOwnPropertyNames","sStr","isDuplicate","idx","push","get","at","aIdx","generatedPositionAfter","lineA","lineB","columnA","columnB","_sorted","_last","aCallback","aThisArg","aMapping","sort","aSourceMap","sourceMap","parse","sections","IndexedSourceMapConsumer","BasicSourceMapConsumer","Mapping","lastOffset","_sections","offset","offsetLine","offsetColumn","generatedOffset","consumer","binarySearch","quickSort","__generatedMappings","defineProperty","_parseMappings","__originalMappings","_charIsMappingSeparator","GENERATED_ORDER","ORIGINAL_ORDER","GREATEST_LOWER_BOUND","LEAST_UPPER_BOUND","aContext","aOrder","context","order","_generatedMappings","_originalMappings","allGeneratedPositionsFor","needle","_findMapping","undefined","lastColumn","smc","generatedMappings","destGeneratedMappings","destOriginalMappings","srcMapping","destMapping","str","segment","end","cachedSegments","temp","originalMappings","aNeedle","aMappings","aLineName","aColumnName","aComparator","aBias","search","computeColumnSpans","nextMapping","lastGeneratedColumn","Infinity","hasContentsOfAllSources","some","sc","nullOnMissing","fileUriAbsPath","generatedPositionFor","constructor","j","sectionIndex","section","bias","every","generatedPosition","ret","sectionMappings","adjustedMapping","recursiveSearch","aLow","aHigh","aHaystack","aCompare","mid","Math","floor","swap","ary","x","y","randomIntInRange","low","high","round","random","doQuickSort","comparator","r","pivotIndex","pivot","q","aLine","aColumn","aChunks","children","sourceContents","isSourceNode","REGEX_NEWLINE","NEWLINE_CODE","fromStringWithSourceMap","aGeneratedCode","aRelativePath","addMappingWithCode","code","node","remainingLines","remainingLinesIndex","shiftNextLine","getNextLine","lineContents","newLine","lastGeneratedLine","lastMapping","nextLine","aChunk","isArray","chunk","prepend","unshift","walk","aFn","aSep","newChildren","replaceRight","aPattern","aReplacement","lastChild","walkSourceContents","toStringWithSourceMap","sourceMappingActive","lastOriginalSource","lastOriginalLine","lastOriginalColumn","lastOriginalName","sourceContent"],"mappings":"CAAA,SAAAA,EAAAC,GACA,gBAAAC,UAAA,gBAAAC,QACAA,OAAAD,QAAAD,IACA,kBAAAG,gBAAAC,IACAD,UAAAH,GACA,gBAAAC,SACAA,QAAA,UAAAD,IAEAD,EAAA,UAAAC,KACCK,KAAA,WACD,MCAgB,UAAUC,GCN1B,QAAAC,GAAAC,GAGA,GAAAC,EAAAD,GACA,MAAAC,GAAAD,GAAAP,OAGA,IAAAC,GAAAO,EAAAD,IACAP,WACAS,GAAAF,EACAG,QAAA,EAUA,OANAL,GAAAE,GAAAI,KAAAV,EAAAD,QAAAC,IAAAD,QAAAM,GAGAL,EAAAS,QAAA,EAGAT,EAAAD,QAvBA,GAAAQ,KAqCA,OATAF,GAAAM,EAAAP,EAGAC,EAAAO,EAAAL,EAGAF,EAAAQ,EAAA,GAGAR,EAAA,KDgBM,SAAUL,EAAQD,EAASM,GEjDjCN,EAAAe,mBAAAT,EAAA,GAAAS,mBACAf,EAAAgB,kBAAAV,EAAA,GAAAU,kBACAhB,EAAAiB,WAAAX,EAAA,IAAAW,YF6DM,SAAUhB,EAAQD,EAASM,GGhDjC,QAAAS,GAAAG,GACAA,IACAA,MAEAd,KAAAe,MAAAC,EAAAC,OAAAH,EAAA,aACAd,KAAAkB,YAAAF,EAAAC,OAAAH,EAAA,mBACAd,KAAAmB,gBAAAH,EAAAC,OAAAH,EAAA,qBACAd,KAAAoB,SAAA,GAAAC,GACArB,KAAAsB,OAAA,GAAAD,GACArB,KAAAuB,UAAA,GAAAC,GACAxB,KAAAyB,iBAAA,KAvBA,GAAAC,GAAAxB,EAAA,GACAc,EAAAd,EAAA,GACAmB,EAAAnB,EAAA,GAAAmB,SACAG,EAAAtB,EAAA,GAAAsB,WAuBAb,GAAAgB,UAAAC,SAAA,EAOAjB,EAAAkB,cACA,SAAAC,GACA,GAAAC,GAAAD,EAAAC,WACAC,EAAA,GAAArB,IACAsB,KAAAH,EAAAG,KACAF,cAkCA,OAhCAD,GAAAI,YAAA,SAAAC,GACA,GAAAC,IACAC,WACAC,KAAAH,EAAAI,cACAC,OAAAL,EAAAM,iBAIA,OAAAN,EAAAO,SACAN,EAAAM,OAAAP,EAAAO,OACA,MAAAX,IACAK,EAAAM,OAAA1B,EAAA2B,SAAAZ,EAAAK,EAAAM,SAGAN,EAAAQ,UACAN,KAAAH,EAAAU,aACAL,OAAAL,EAAAW,gBAGA,MAAAX,EAAAY,OACAX,EAAAW,KAAAZ,EAAAY,OAIAf,EAAAgB,WAAAZ,KAEAN,EAAAmB,QAAAC,QAAA,SAAAC,GACA,GAAAC,GAAAtB,EAAAuB,iBAAAF,EACA,OAAAC,GACApB,EAAAsB,iBAAAH,EAAAC,KAGApB,GAaArB,EAAAgB,UAAAqB,WACA,SAAAlC,GACA,GAAAuB,GAAArB,EAAAC,OAAAH,EAAA,aACA8B,EAAA5B,EAAAC,OAAAH,EAAA,iBACA4B,EAAA1B,EAAAC,OAAAH,EAAA,eACAiC,EAAA/B,EAAAC,OAAAH,EAAA,YAEAd,MAAAmB,iBACAnB,KAAAuD,iBAAAlB,EAAAO,EAAAF,EAAAK,GAGA,MAAAL,IACAA,EAAAc,OAAAd,GACA1C,KAAAoB,SAAAqC,IAAAf,IACA1C,KAAAoB,SAAAsC,IAAAhB,IAIA,MAAAK,IACAA,EAAAS,OAAAT,GACA/C,KAAAsB,OAAAmC,IAAAV,IACA/C,KAAAsB,OAAAoC,IAAAX,IAIA/C,KAAAuB,UAAAmC,KACAnB,cAAAF,EAAAC,KACAG,gBAAAJ,EAAAG,OACAK,aAAA,MAAAD,KAAAN,KACAQ,eAAA,MAAAF,KAAAJ,OACAE,SACAK,UAOApC,EAAAgB,UAAA2B,iBACA,SAAAK,EAAAC,GACA,GAAAlB,GAAAiB,CACA,OAAA3D,KAAAkB,cACAwB,EAAA1B,EAAA2B,SAAA3C,KAAAkB,YAAAwB,IAGA,MAAAkB,GAGA5D,KAAAyB,mBACAzB,KAAAyB,iBAAAoC,OAAAC,OAAA,OAEA9D,KAAAyB,iBAAAT,EAAA+C,YAAArB,IAAAkB,GACK5D,KAAAyB,yBAGLzB,MAAAyB,iBAAAT,EAAA+C,YAAArB,IACA,IAAAmB,OAAAG,KAAAhE,KAAAyB,kBAAAwC,SACAjE,KAAAyB,iBAAA,QAqBAd,EAAAgB,UAAAuC,eACA,SAAApC,EAAA6B,EAAAQ,GACA,GAAAhB,GAAAQ,CAEA,UAAAA,EAAA,CACA,SAAA7B,EAAAG,KACA,SAAAmC,OACA,gJAIAjB,GAAArB,EAAAG,KAEA,GAAAF,GAAA/B,KAAAkB,WAEA,OAAAa,IACAoB,EAAAnC,EAAA2B,SAAAZ,EAAAoB,GAIA,IAAAkB,GAAA,GAAAhD,GACAiD,EAAA,GAAAjD,EAGArB,MAAAuB,UAAAgD,gBAAA,SAAApC,GACA,GAAAA,EAAAO,SAAAS,GAAA,MAAAhB,EAAAU,aAAA,CAEA,GAAAD,GAAAd,EAAA0C,qBACAlC,KAAAH,EAAAU,aACAL,OAAAL,EAAAW,gBAEA,OAAAF,EAAAF,SAEAP,EAAAO,OAAAE,EAAAF,OACA,MAAAyB,IACAhC,EAAAO,OAAA1B,EAAAyD,KAAAN,EAAAhC,EAAAO,SAEA,MAAAX,IACAI,EAAAO,OAAA1B,EAAA2B,SAAAZ,EAAAI,EAAAO,SAEAP,EAAAU,aAAAD,EAAAN,KACAH,EAAAW,eAAAF,EAAAJ,OACA,MAAAI,EAAAG,OACAZ,EAAAY,KAAAH,EAAAG,OAKA,GAAAL,GAAAP,EAAAO,MACA,OAAAA,GAAA2B,EAAAZ,IAAAf,IACA2B,EAAAX,IAAAhB,EAGA,IAAAK,GAAAZ,EAAAY,IACA,OAAAA,GAAAuB,EAAAb,IAAAV,IACAuB,EAAAZ,IAAAX,IAGK/C,MACLA,KAAAoB,SAAAiD,EACArE,KAAAsB,OAAAgD,EAGAxC,EAAAmB,QAAAC,QAAA,SAAAC,GACA,GAAAC,GAAAtB,EAAAuB,iBAAAF,EACA,OAAAC,IACA,MAAAe,IACAhB,EAAAnC,EAAAyD,KAAAN,EAAAhB,IAEA,MAAApB,IACAoB,EAAAnC,EAAA2B,SAAAZ,EAAAoB,IAEAnD,KAAAsD,iBAAAH,EAAAC,KAEKpD,OAcLW,EAAAgB,UAAA4B,iBACA,SAAAmB,EAAAC,EAAAC,EACAC,GAKA,GAAAF,GAAA,gBAAAA,GAAArC,MAAA,gBAAAqC,GAAAnC,OACA,SAAA4B,OACA,+OAMA,OAAAM,GAAA,QAAAA,IAAA,UAAAA,IACAA,EAAApC,KAAA,GAAAoC,EAAAlC,QAAA,IACAmC,GAAAC,GAAAC,MAIAH,GAAA,QAAAA,IAAA,UAAAA,IACAC,GAAA,QAAAA,IAAA,UAAAA,IACAD,EAAApC,KAAA,GAAAoC,EAAAlC,QAAA,GACAmC,EAAArC,KAAA,GAAAqC,EAAAnC,QAAA,GACAoC,GAKA,SAAAR,OAAA,oBAAAU,KAAAC,WACA1C,UAAAqC,EACAhC,OAAAkC,EACAhC,SAAA+B,EACA5B,KAAA8B,MASAlE,EAAAgB,UAAAqD,mBACA,WAcA,OANAC,GACA9C,EACA+C,EACAC,EAVAC,EAAA,EACAC,EAAA,EACAC,EAAA,EACAC,EAAA,EACAC,EAAA,EACAC,EAAA,EACAC,EAAA,GAMAC,EAAA3F,KAAAuB,UAAAqE,UACAC,EAAA,EAAAC,EAAAH,EAAA1B,OAA0C4B,EAAAC,EAASD,IAAA,CAInD,GAHA1D,EAAAwD,EAAAE,GACAZ,EAAA,GAEA9C,EAAAI,gBAAA8C,EAEA,IADAD,EAAA,EACAjD,EAAAI,gBAAA8C,GACAJ,GAAA,IACAI,QAIA,IAAAQ,EAAA,GACA,IAAA7E,EAAA+E,oCAAA5D,EAAAwD,EAAAE,EAAA,IACA,QAEAZ,IAAA,IAIAA,GAAAvD,EAAAsE,OAAA7D,EAAAM,gBACA2C,GACAA,EAAAjD,EAAAM,gBAEA,MAAAN,EAAAO,SACAyC,EAAAnF,KAAAoB,SAAA6E,QAAA9D,EAAAO,QACAuC,GAAAvD,EAAAsE,OAAAb,EAAAM,GACAA,EAAAN,EAGAF,GAAAvD,EAAAsE,OAAA7D,EAAAU,aAAA,EACA0C,GACAA,EAAApD,EAAAU,aAAA,EAEAoC,GAAAvD,EAAAsE,OAAA7D,EAAAW,eACAwC,GACAA,EAAAnD,EAAAW,eAEA,MAAAX,EAAAY,OACAmC,EAAAlF,KAAAsB,OAAA2E,QAAA9D,EAAAY,MACAkC,GAAAvD,EAAAsE,OAAAd,EAAAM,GACAA,EAAAN,IAIAQ,GAAAT,EAGA,MAAAS,IAGA/E,EAAAgB,UAAAuE,wBACA,SAAAC,EAAAC,GACA,MAAAD,GAAAE,IAAA,SAAA3D,GACA,IAAA1C,KAAAyB,iBACA,WAEA,OAAA2E,IACA1D,EAAA1B,EAAA2B,SAAAyD,EAAA1D,GAEA,IAAA4D,GAAAtF,EAAA+C,YAAArB,EACA,OAAAmB,QAAAlC,UAAA4E,eAAAhG,KAAAP,KAAAyB,iBAAA6E,GACAtG,KAAAyB,iBAAA6E,GACA,MACKtG,OAMLW,EAAAgB,UAAA6E,OACA,WACA,GAAAH,IACAI,QAAAzG,KAAA4B,SACAqB,QAAAjD,KAAAoB,SAAAwE,UACAc,MAAA1G,KAAAsB,OAAAsE,UACAD,SAAA3F,KAAAgF,qBAYA,OAVA,OAAAhF,KAAAe,QACAsF,EAAApE,KAAAjC,KAAAe,OAEA,MAAAf,KAAAkB,cACAmF,EAAAtE,WAAA/B,KAAAkB,aAEAlB,KAAAyB,mBACA4E,EAAAM,eAAA3G,KAAAkG,wBAAAG,EAAApD,QAAAoD,EAAAtE,aAGAsE,GAMA1F,EAAAgB,UAAAiF,SACA,WACA,MAAA9B,MAAAC,UAAA/E,KAAAwG,WAGA5G,EAAAe,sBH2EM,SAAUd,EAAQD,EAASM,GItajC,QAAA2G,GAAAC,GACA,MAAAA,GAAA,IACAA,GAAA,MACAA,GAAA,KASA,QAAAC,GAAAD,GACA,GAAAE,GAAA,OAAAF,GACAG,EAAAH,GAAA,CACA,OAAAE,IACAC,EACAA,EAhDA,GAAAC,GAAAhH,EAAA,GAcAiH,EAAA,EAGAC,EAAA,GAAAD,EAGAE,EAAAD,EAAA,EAGAE,EAAAF,CA+BAxH,GAAAoG,OAAA,SAAAc,GACA,GACAS,GADAC,EAAA,GAGAC,EAAAZ,EAAAC,EAEA,GACAS,GAAAE,EAAAJ,EACAI,KAAAN,EACAM,EAAA,IAGAF,GAAAD,GAEAE,GAAAN,EAAAlB,OAAAuB,SACGE,EAAA,EAEH,OAAAD,IAOA5H,EAAA8H,OAAA,SAAAC,EAAAC,EAAAC,GACA,GAGAC,GAAAP,EAHAQ,EAAAJ,EAAA1D,OACAyB,EAAA,EACAsC,EAAA,CAGA,IACA,GAAAJ,GAAAG,EACA,SAAA3D,OAAA,6CAIA,IADAmD,EAAAL,EAAAQ,OAAAC,EAAAM,WAAAL,MACAL,KAAA,EACA,SAAAnD,OAAA,yBAAAuD,EAAAO,OAAAN,EAAA,GAGAE,MAAAP,EAAAD,GACAC,GAAAF,EACA3B,GAAA6B,GAAAS,EACAA,GAAAb,QACGW,EAEHD,GAAAM,MAAApB,EAAArB,GACAmC,EAAAO,KAAAR,IJkfM,SAAU/H,EAAQD,GKrnBxB,GAAAyI,GAAA,mEAAAC,MAAA,GAKA1I,GAAAoG,OAAA,SAAAuC,GACA,MAAAA,KAAAF,EAAApE,OACA,MAAAoE,GAAAE,EAEA,UAAAC,WAAA,6BAAAD,IAOA3I,EAAA8H,OAAA,SAAAe,GACA,GAAAC,GAAA,GACAC,EAAA,GAEAC,EAAA,GACAC,EAAA,IAEAC,EAAA,GACAC,EAAA,GAEAC,EAAA,GACAC,EAAA,GAEAC,EAAA,GACAC,EAAA,EAGA,OAAAT,IAAAD,MAAAE,EACAF,EAAAC,EAIAE,GAAAH,MAAAI,EACAJ,EAAAG,EAAAM,EAIAJ,GAAAL,MAAAM,EACAN,EAAAK,EAAAK,EAIAV,GAAAO,EACA,GAIAP,GAAAQ,EACA,IAIA,ILooBM,SAAUpJ,EAAQD,GMprBxB,QAAAqB,GAAAH,EAAA+D,EAAAuE,GACA,GAAAvE,IAAA/D,GACA,MAAAA,GAAA+D,EACG,QAAAwE,UAAApF,OACH,MAAAmF,EAEA,UAAAhF,OAAA,IAAAS,EAAA,6BAQA,QAAAyE,GAAAC,GACA,GAAAC,GAAAD,EAAAC,MAAAC,EACA,OAAAD,IAIAE,OAAAF,EAAA,GACAG,KAAAH,EAAA,GACAI,KAAAJ,EAAA,GACAK,KAAAL,EAAA,GACAM,KAAAN,EAAA,IAPA,KAYA,QAAAO,GAAAC,GACA,GAAAC,GAAA,EAiBA,OAhBAD,GAAAN,SACAO,GAAAD,EAAAN,OAAA,KAEAO,GAAA,KACAD,EAAAL,OACAM,GAAAD,EAAAL,KAAA,KAEAK,EAAAJ,OACAK,GAAAD,EAAAJ,MAEAI,EAAAH,OACAI,GAAA,IAAAD,EAAAH,MAEAG,EAAAF,OACAG,GAAAD,EAAAF,MAEAG,EAeA,QAAAC,GAAAC,GACA,GAAAL,GAAAK,EACAF,EAAAX,EAAAa,EACA,IAAAF,EAAA,CACA,IAAAA,EAAAH,KACA,MAAAK,EAEAL,GAAAG,EAAAH,KAKA,OAAAM,GAHAC,EAAAzK,EAAAyK,WAAAP,GAEAQ,EAAAR,EAAAxB,MAAA,OACAiC,EAAA,EAAA1E,EAAAyE,EAAArG,OAAA,EAA8C4B,GAAA,EAAQA,IACtDuE,EAAAE,EAAAzE,GACA,MAAAuE,EACAE,EAAAE,OAAA3E,EAAA,GACK,OAAAuE,EACLG,IACKA,EAAA,IACL,KAAAH,GAIAE,EAAAE,OAAA3E,EAAA,EAAA0E,GACAA,EAAA,IAEAD,EAAAE,OAAA3E,EAAA,GACA0E,KAUA,OANAT,GAAAQ,EAAA7F,KAAA,KAEA,KAAAqF,IACAA,EAAAO,EAAA,SAGAJ,GACAA,EAAAH,OACAC,EAAAE,IAEAH,EAoBA,QAAArF,GAAAgG,EAAAN,GACA,KAAAM,IACAA,EAAA,KAEA,KAAAN,IACAA,EAAA,IAEA,IAAAO,GAAApB,EAAAa,GACAQ,EAAArB,EAAAmB,EAMA,IALAE,IACAF,EAAAE,EAAAb,MAAA,KAIAY,MAAAhB,OAIA,MAHAiB,KACAD,EAAAhB,OAAAiB,EAAAjB,QAEAK,EAAAW,EAGA,IAAAA,GAAAP,EAAAX,MAAAoB,GACA,MAAAT,EAIA,IAAAQ,MAAAf,OAAAe,EAAAb,KAEA,MADAa,GAAAf,KAAAO,EACAJ,EAAAY,EAGA,IAAAE,GAAA,MAAAV,EAAAjC,OAAA,GACAiC,EACAD,EAAAO,EAAAK,QAAA,eAAAX,EAEA,OAAAQ,IACAA,EAAAb,KAAAe,EACAd,EAAAY,IAEAE,EAcA,QAAAlI,GAAA8H,EAAAN,GACA,KAAAM,IACAA,EAAA,KAGAA,IAAAK,QAAA,SAOA,KADA,GAAAC,GAAA,EACA,IAAAZ,EAAAlE,QAAAwE,EAAA,OACA,GAAAO,GAAAP,EAAAQ,YAAA,IACA,IAAAD,EAAA,EACA,MAAAb,EAOA,IADAM,IAAAS,MAAA,EAAAF,GACAP,EAAAjB,MAAA,qBACA,MAAAW,KAGAY,EAIA,MAAAI,OAAAJ,EAAA,GAAAtG,KAAA,OAAA0F,EAAAiB,OAAAX,EAAAxG,OAAA,GASA,QAAAoH,GAAAC,GACA,MAAAA,GAYA,QAAAvH,GAAA4D,GACA,MAAA4D,GAAA5D,GACA,IAAAA,EAGAA,EAIA,QAAA6D,GAAA7D,GACA,MAAA4D,GAAA5D,GACAA,EAAAuD,MAAA,GAGAvD,EAIA,QAAA4D,GAAAD,GACA,IAAAA,EACA,QAGA,IAAArH,GAAAqH,EAAArH,MAEA,IAAAA,EAAA,EACA,QAGA,SAAAqH,EAAArD,WAAAhE,EAAA,IACA,KAAAqH,EAAArD,WAAAhE,EAAA,IACA,MAAAqH,EAAArD,WAAAhE,EAAA,IACA,MAAAqH,EAAArD,WAAAhE,EAAA,IACA,MAAAqH,EAAArD,WAAAhE,EAAA,IACA,MAAAqH,EAAArD,WAAAhE,EAAA,IACA,MAAAqH,EAAArD,WAAAhE,EAAA,IACA,KAAAqH,EAAArD,WAAAhE,EAAA,IACA,KAAAqH,EAAArD,WAAAhE,EAAA,GACA,QAGA,QAAA4B,GAAA5B,EAAA,GAA2B4B,GAAA,EAAQA,IACnC,QAAAyF,EAAArD,WAAApC,GACA,QAIA,UAWA,QAAA4F,GAAAC,EAAAC,EAAAC,GACA,GAAAC,GAAAH,EAAAhJ,OAAAiJ,EAAAjJ,MACA,YAAAmJ,EACAA,GAGAA,EAAAH,EAAA7I,aAAA8I,EAAA9I,aACA,IAAAgJ,EACAA,GAGAA,EAAAH,EAAA5I,eAAA6I,EAAA7I,eACA,IAAA+I,GAAAD,EACAC,GAGAA,EAAAH,EAAAjJ,gBAAAkJ,EAAAlJ,gBACA,IAAAoJ,EACAA,GAGAA,EAAAH,EAAAnJ,cAAAoJ,EAAApJ,cACA,IAAAsJ,EACAA,EAGAH,EAAA3I,KAAA4I,EAAA5I,SAaA,QAAA+I,GAAAJ,EAAAC,EAAAI,GACA,GAAAF,GAAAH,EAAAnJ,cAAAoJ,EAAApJ,aACA,YAAAsJ,EACAA,GAGAA,EAAAH,EAAAjJ,gBAAAkJ,EAAAlJ,gBACA,IAAAoJ,GAAAE,EACAF,GAGAA,EAAAH,EAAAhJ,OAAAiJ,EAAAjJ,OACA,IAAAmJ,EACAA,GAGAA,EAAAH,EAAA7I,aAAA8I,EAAA9I,aACA,IAAAgJ,EACAA,GAGAA,EAAAH,EAAA5I,eAAA6I,EAAA7I,eACA,IAAA+I,EACAA,EAGAH,EAAA3I,KAAA4I,EAAA5I,SAIA,QAAAiJ,GAAAC,EAAAC,GACA,MAAAD,KAAAC,EACA,EAGAD,EAAAC,EACA,GAGA,EAOA,QAAAnG,GAAA2F,EAAAC,GACA,GAAAE,GAAAH,EAAAnJ,cAAAoJ,EAAApJ,aACA,YAAAsJ,EACAA,GAGAA,EAAAH,EAAAjJ,gBAAAkJ,EAAAlJ,gBACA,IAAAoJ,EACAA,GAGAA,EAAAG,EAAAN,EAAAhJ,OAAAiJ,EAAAjJ,QACA,IAAAmJ,EACAA,GAGAA,EAAAH,EAAA7I,aAAA8I,EAAA9I,aACA,IAAAgJ,EACAA,GAGAA,EAAAH,EAAA5I,eAAA6I,EAAA7I,eACA,IAAA+I,EACAA,EAGAG,EAAAN,EAAA3I,KAAA4I,EAAA5I,UApYAnD,EAAAqB,QAEA,IAAAwI,GAAA,iEACAmB,EAAA,eAeAhL,GAAA0J,WAsBA1J,EAAAmK,cAwDAnK,EAAAsK,YA2DAtK,EAAA6E,OAEA7E,EAAAyK,WAAA,SAAAF,GACA,YAAAA,EAAAjC,OAAA,MAAAiC,EAAAX,MAAAC,IAyCA7J,EAAA+C,UAEA,IAAAwJ,GAAA,WACA,GAAAC,GAAAvI,OAAAC,OAAA,KACA,sBAAAsI,MAuBAxM,GAAAmE,YAAAoI,EAAAd,EAAAtH,EASAnE,EAAA4L,cAAAW,EAAAd,EAAAG,EAsEA5L,EAAA6L,6BAuCA7L,EAAAkM,sCA8CAlM,EAAAmG,uCN4sBM,SAAUlG,EAAQD,EAASM,GO3lCjC,QAAAmB,KACArB,KAAAqM,UACArM,KAAAsM,KAAAC,EAAA,GAAAC,KAAA3I,OAAAC,OAAA,MAZA,GAAA9C,GAAAd,EAAA,GACAuD,EAAAI,OAAAlC,UAAA4E,eACAgG,EAAA,mBAAAC,IAgBAnL,GAAAoL,UAAA,SAAAC,EAAAC,GAEA,OADAC,GAAA,GAAAvL,GACAwE,EAAA,EAAAC,EAAA4G,EAAAzI,OAAsC4B,EAAAC,EAASD,IAC/C+G,EAAAlJ,IAAAgJ,EAAA7G,GAAA8G,EAEA,OAAAC,IASAvL,EAAAM,UAAAkL,KAAA,WACA,MAAAN,GAAAvM,KAAAsM,KAAAO,KAAAhJ,OAAAiJ,oBAAA9M,KAAAsM,MAAArI,QAQA5C,EAAAM,UAAA+B,IAAA,SAAAiE,EAAAgF,GACA,GAAAI,GAAAR,EAAA5E,EAAA3G,EAAA+C,YAAA4D,GACAqF,EAAAT,EAAAvM,KAAAyD,IAAAkE,GAAAlE,EAAAlD,KAAAP,KAAAsM,KAAAS,GACAE,EAAAjN,KAAAqM,OAAApI,MACA+I,KAAAL,GACA3M,KAAAqM,OAAAa,KAAAvF,GAEAqF,IACAT,EACAvM,KAAAsM,KAAAM,IAAAjF,EAAAsF,GAEAjN,KAAAsM,KAAAS,GAAAE,IAUA5L,EAAAM,UAAA8B,IAAA,SAAAkE,GACA,GAAA4E,EACA,MAAAvM,MAAAsM,KAAA7I,IAAAkE,EAEA,IAAAoF,GAAA/L,EAAA+C,YAAA4D,EACA,OAAAlE,GAAAlD,KAAAP,KAAAsM,KAAAS,IASA1L,EAAAM,UAAAsE,QAAA,SAAA0B,GACA,GAAA4E,EAAA,CACA,GAAAU,GAAAjN,KAAAsM,KAAAa,IAAAxF,EACA,IAAAsF,GAAA,EACA,MAAAA,OAEG,CACH,GAAAF,GAAA/L,EAAA+C,YAAA4D,EACA,IAAAlE,EAAAlD,KAAAP,KAAAsM,KAAAS,GACA,MAAA/M,MAAAsM,KAAAS,GAIA,SAAA3I,OAAA,IAAAuD,EAAA,yBAQAtG,EAAAM,UAAAyL,GAAA,SAAAC,GACA,GAAAA,GAAA,GAAAA,EAAArN,KAAAqM,OAAApI,OACA,MAAAjE,MAAAqM,OAAAgB,EAEA,UAAAjJ,OAAA,yBAAAiJ,IAQAhM,EAAAM,UAAAiE,QAAA,WACA,MAAA5F,MAAAqM,OAAAnB,SAGAtL,EAAAyB,YPmnCM,SAAUxB,EAAQD,EAASM,GQ9tCjC,QAAAoN,GAAA5B,EAAAC,GAEA,GAAA4B,GAAA7B,EAAAnJ,cACAiL,EAAA7B,EAAApJ,cACAkL,EAAA/B,EAAAjJ,gBACAiL,EAAA/B,EAAAlJ,eACA,OAAA+K,GAAAD,GAAAC,GAAAD,GAAAG,GAAAD,GACAzM,EAAA+E,oCAAA2F,EAAAC,IAAA,EAQA,QAAAnK,KACAxB,KAAAqM,UACArM,KAAA2N,SAAA,EAEA3N,KAAA4N,OAAgBrL,eAAA,EAAAE,gBAAA,GAzBhB,GAAAzB,GAAAd,EAAA,EAkCAsB,GAAAG,UAAA4C,gBACA,SAAAsJ,EAAAC,GACA9N,KAAAqM,OAAAnJ,QAAA2K,EAAAC,IAQAtM,EAAAG,UAAA+B,IAAA,SAAAqK,GACAT,EAAAtN,KAAA4N,MAAAG,IACA/N,KAAA4N,MAAAG,EACA/N,KAAAqM,OAAAa,KAAAa,KAEA/N,KAAA2N,SAAA,EACA3N,KAAAqM,OAAAa,KAAAa,KAaAvM,EAAAG,UAAAiE,QAAA,WAKA,MAJA5F,MAAA2N,UACA3N,KAAAqM,OAAA2B,KAAAhN,EAAA+E,qCACA/F,KAAA2N,SAAA,GAEA3N,KAAAqM,QAGAzM,EAAA4B,eRkvCM,SAAU3B,EAAQD,EAASM,GSnzCjC,QAAAU,GAAAqN,GACA,GAAAC,GAAAD,CAKA,OAJA,gBAAAA,KACAC,EAAApJ,KAAAqJ,MAAAF,EAAAnD,QAAA,WAAsD,MAGtD,MAAAoD,EAAAE,SACA,GAAAC,GAAAH,GACA,GAAAI,GAAAJ,GAoQA,QAAAI,GAAAL,GACA,GAAAC,GAAAD,CACA,iBAAAA,KACAC,EAAApJ,KAAAqJ,MAAAF,EAAAnD,QAAA,WAAsD,KAGtD,IAAArE,GAAAzF,EAAAC,OAAAiN,EAAA,WACAjL,EAAAjC,EAAAC,OAAAiN,EAAA,WAGAxH,EAAA1F,EAAAC,OAAAiN,EAAA,YACAnM,EAAAf,EAAAC,OAAAiN,EAAA,mBACAvH,EAAA3F,EAAAC,OAAAiN,EAAA,uBACAvI,EAAA3E,EAAAC,OAAAiN,EAAA,YACAjM,EAAAjB,EAAAC,OAAAiN,EAAA,YAIA,IAAAzH,GAAAzG,KAAA4B,SACA,SAAAwC,OAAA,wBAAAqC,EAGAxD,KACAoD,IAAA7C,QAIA6C,IAAArF,EAAAkJ,WAKA7D,IAAA,SAAA3D,GACA,MAAAX,IAAAf,EAAAqJ,WAAAtI,IAAAf,EAAAqJ,WAAA3H,GACA1B,EAAA2B,SAAAZ,EAAAW,GACAA,IAOA1C,KAAAsB,OAAAD,EAAAoL,UAAA/F,EAAAL,IAAA7C,SAAA,GACAxD,KAAAoB,SAAAC,EAAAoL,UAAAxJ,GAAA,GAEAjD,KAAA+B,aACA/B,KAAA2G,iBACA3G,KAAAuB,UAAAoE,EACA3F,KAAAiC,OA8EA,QAAAsM,KACAvO,KAAAuC,cAAA,EACAvC,KAAAyC,gBAAA,EACAzC,KAAA0C,OAAA,KACA1C,KAAA6C,aAAA,KACA7C,KAAA8C,eAAA,KACA9C,KAAA+C,KAAA,KAyZA,QAAAsL,GAAAJ,GACA,GAAAC,GAAAD,CACA,iBAAAA,KACAC,EAAApJ,KAAAqJ,MAAAF,EAAAnD,QAAA,WAAsD,KAGtD,IAAArE,GAAAzF,EAAAC,OAAAiN,EAAA,WACAE,EAAApN,EAAAC,OAAAiN,EAAA,WAEA,IAAAzH,GAAAzG,KAAA4B,SACA,SAAAwC,OAAA,wBAAAqC,EAGAzG,MAAAoB,SAAA,GAAAC,GACArB,KAAAsB,OAAA,GAAAD,EAEA,IAAAmN,IACAlM,MAAA,EACAE,OAAA,EAEAxC,MAAAyO,UAAAL,EAAA/H,IAAA,SAAAiF,GACA,GAAAA,EAAArB,IAGA,SAAA7F,OAAA,qDAEA,IAAAsK,GAAA1N,EAAAC,OAAAqK,EAAA,UACAqD,EAAA3N,EAAAC,OAAAyN,EAAA,QACAE,EAAA5N,EAAAC,OAAAyN,EAAA,SAEA,IAAAC,EAAAH,EAAAlM,MACAqM,IAAAH,EAAAlM,MAAAsM,EAAAJ,EAAAhM,OACA,SAAA4B,OAAA,uDAIA,OAFAoK,GAAAE,GAGAG,iBAGAtM,cAAAoM,EAAA,EACAlM,gBAAAmM,EAAA,GAEAE,SAAA,GAAAlO,GAAAI,EAAAC,OAAAqK,EAAA,WA11BA,GAAAtK,GAAAd,EAAA,GACA6O,EAAA7O,EAAA,GACAmB,EAAAnB,EAAA,GAAAmB,SACAK,EAAAxB,EAAA,GACA8O,EAAA9O,EAAA,GAAA8O,SAaApO,GAAAiB,cAAA,SAAAoM,GACA,MAAAK,GAAAzM,cAAAoM,IAMArN,EAAAe,UAAAC,SAAA,EAgCAhB,EAAAe,UAAAsN,oBAAA,KACApL,OAAAqL,eAAAtO,EAAAe,UAAA,sBACAwL,IAAA,WAKA,MAJAnN,MAAAiP,qBACAjP,KAAAmP,eAAAnP,KAAAuB,UAAAvB,KAAA+B,YAGA/B,KAAAiP,uBAIArO,EAAAe,UAAAyN,mBAAA,KACAvL,OAAAqL,eAAAtO,EAAAe,UAAA,qBACAwL,IAAA,WAKA,MAJAnN,MAAAoP,oBACApP,KAAAmP,eAAAnP,KAAAuB,UAAAvB,KAAA+B,YAGA/B,KAAAoP,sBAIAxO,EAAAe,UAAA0N,wBACA,SAAA1H,EAAAqD,GACA,GAAAvK,GAAAkH,EAAAO,OAAA8C,EACA,aAAAvK,GAAmB,MAAAA,GAQnBG,EAAAe,UAAAwN,eACA,SAAAxH,EAAAvB,GACA,SAAAhC,OAAA,6CAGAxD,EAAA0O,gBAAA,EACA1O,EAAA2O,eAAA,EAEA3O,EAAA4O,qBAAA,EACA5O,EAAA6O,kBAAA,EAkBA7O,EAAAe,UAAAO,YACA,SAAA2L,EAAA6B,EAAAC,GACA,GAGAhK,GAHAiK,EAAAF,GAAA,KACAG,EAAAF,GAAA/O,EAAA0O,eAGA,QAAAO,GACA,IAAAjP,GAAA0O,gBACA3J,EAAA3F,KAAA8P,kBACA,MACA,KAAAlP,GAAA2O,eACA5J,EAAA3F,KAAA+P,iBACA,MACA,SACA,SAAA3L,OAAA,+BAGA,GAAArC,GAAA/B,KAAA+B,UACA4D,GAAAU,IAAA,SAAAlE,GACA,GAAAO,GAAA,OAAAP,EAAAO,OAAA,KAAA1C,KAAAoB,SAAAgM,GAAAjL,EAAAO,OAIA,OAHA,OAAAA,GAAA,MAAAX,IACAW,EAAA1B,EAAAyD,KAAA1C,EAAAW,KAGAA,SACAH,cAAAJ,EAAAI,cACAE,gBAAAN,EAAAM,gBACAI,aAAAV,EAAAU,aACAC,eAAAX,EAAAW,eACAC,KAAA,OAAAZ,EAAAY,KAAA,KAAA/C,KAAAsB,OAAA8L,GAAAjL,EAAAY,QAEK/C,MAAAkD,QAAA2K,EAAA+B,IAsBLhP,EAAAe,UAAAqO,yBACA,SAAAlP,GACA,GAAAwB,GAAAtB,EAAAC,OAAAH,EAAA,QAMAmP,GACAvN,OAAA1B,EAAAC,OAAAH,EAAA,UACA+B,aAAAP,EACAQ,eAAA9B,EAAAC,OAAAH,EAAA,YAMA,IAHA,MAAAd,KAAA+B,aACAkO,EAAAvN,OAAA1B,EAAA2B,SAAA3C,KAAA+B,WAAAkO,EAAAvN,UAEA1C,KAAAoB,SAAAqC,IAAAwM,EAAAvN,QACA,QAEAuN,GAAAvN,OAAA1C,KAAAoB,SAAA6E,QAAAgK,EAAAvN,OAEA,IAAAiD,MAEAqF,EAAAhL,KAAAkQ,aAAAD,EACAjQ,KAAA+P,kBACA,eACA,iBACA/O,EAAAyK,2BACAsD,EAAAU,kBACA,IAAAzE,GAAA,GACA,GAAA7I,GAAAnC,KAAA+P,kBAAA/E,EAEA,IAAAmF,SAAArP,EAAA0B,OAOA,IANA,GAAAK,GAAAV,EAAAU,aAMAV,KAAAU,kBACA8C,EAAAuH,MACA5K,KAAAtB,EAAAC,OAAAkB,EAAA,sBACAK,OAAAxB,EAAAC,OAAAkB,EAAA,wBACAiO,WAAApP,EAAAC,OAAAkB,EAAA,8BAGAA,EAAAnC,KAAA+P,oBAAA/E,OASA,KANA,GAAAlI,GAAAX,EAAAW,eAMAX,GACAA,EAAAU,eAAAP,GACAH,EAAAW,mBACA6C,EAAAuH,MACA5K,KAAAtB,EAAAC,OAAAkB,EAAA,sBACAK,OAAAxB,EAAAC,OAAAkB,EAAA,wBACAiO,WAAApP,EAAAC,OAAAkB,EAAA,8BAGAA,EAAAnC,KAAA+P,oBAAA/E,GAKA,MAAArF,IAGA/F,EAAAgB,oBAmFA0N,EAAA3M,UAAAkC,OAAAC,OAAAlD,EAAAe,WACA2M,EAAA3M,UAAAmN,SAAAlO,EASA0N,EAAAzM,cACA,SAAAoM,GACA,GAAAoC,GAAAxM,OAAAC,OAAAwK,EAAA3M,WAEA+E,EAAA2J,EAAA/O,OAAAD,EAAAoL,UAAAwB,EAAA3M,OAAAsE,WAAA,GACA3C,EAAAoN,EAAAjP,SAAAC,EAAAoL,UAAAwB,EAAA7M,SAAAwE,WAAA,EACAyK,GAAAtO,WAAAkM,EAAA/M,YACAmP,EAAA1J,eAAAsH,EAAA/H,wBAAAmK,EAAAjP,SAAAwE,UACAyK,EAAAtO,YACAsO,EAAApO,KAAAgM,EAAAlN,KAWA,QAJAuP,GAAArC,EAAA1M,UAAAqE,UAAAsF,QACAqF,EAAAF,EAAApB,uBACAuB,EAAAH,EAAAjB,sBAEAvJ,EAAA,EAAA5B,EAAAqM,EAAArM,OAAsD4B,EAAA5B,EAAY4B,IAAA,CAClE,GAAA4K,GAAAH,EAAAzK,GACA6K,EAAA,GAAAnC,EACAmC,GAAAnO,cAAAkO,EAAAlO,cACAmO,EAAAjO,gBAAAgO,EAAAhO,gBAEAgO,EAAA/N,SACAgO,EAAAhO,OAAAO,EAAAgD,QAAAwK,EAAA/N,QACAgO,EAAA7N,aAAA4N,EAAA5N,aACA6N,EAAA5N,eAAA2N,EAAA3N,eAEA2N,EAAA1N,OACA2N,EAAA3N,KAAA2D,EAAAT,QAAAwK,EAAA1N,OAGAyN,EAAAtD,KAAAwD,IAGAH,EAAArD,KAAAwD,GAKA,MAFA1B,GAAAqB,EAAAjB,mBAAApO,EAAAyK,4BAEA4E,GAMA/B,EAAA3M,UAAAC,SAAA,EAKAiC,OAAAqL,eAAAZ,EAAA3M,UAAA,WACAwL,IAAA,WACA,MAAAnN,MAAAoB,SAAAwE,UAAAS,IAAA,SAAAiF,GACA,aAAAtL,KAAA+B,WAAAf,EAAAyD,KAAAzE,KAAA+B,WAAAuJ,MACKtL,SAqBLsO,EAAA3M,UAAAwN,eACA,SAAAxH,EAAAvB,GAeA,IAdA,GAYAjE,GAAAwO,EAAAC,EAAAC,EAAA1I,EAZA5F,EAAA,EACA6C,EAAA,EACAG,EAAA,EACAD,EAAA,EACAG,EAAA,EACAD,EAAA,EACAvB,EAAA0D,EAAA1D,OACA+G,EAAA,EACA8F,KACAC,KACAC,KACAV,KAGAtF,EAAA/G,GACA,SAAA0D,EAAAO,OAAA8C,GACAzI,IACAyI,IACA5F,EAAA,MAEA,UAAAuC,EAAAO,OAAA8C,GACAA,QAEA,CASA,IARA7I,EAAA,GAAAoM,GACApM,EAAAI,gBAOAsO,EAAA7F,EAAyB6F,EAAA5M,IACzBjE,KAAAqP,wBAAA1H,EAAAkJ,GADuCA,KAQvC,GAHAF,EAAAhJ,EAAAuD,MAAAF,EAAA6F,GAEAD,EAAAE,EAAAH,GAEA3F,GAAA2F,EAAA1M,WACS,CAET,IADA2M,KACA5F,EAAA6F,GACAnP,EAAAgG,OAAAC,EAAAqD,EAAA+F,GACA5I,EAAA4I,EAAA5I,MACA6C,EAAA+F,EAAA3I,KACAwI,EAAA1D,KAAA/E,EAGA,QAAAyI,EAAA3M,OACA,SAAAG,OAAA,yCAGA,QAAAwM,EAAA3M,OACA,SAAAG,OAAA,yCAGA0M,GAAAH,GAAAC,EAIAzO,EAAAM,gBAAA2C,EAAAwL,EAAA,GACAxL,EAAAjD,EAAAM,gBAEAmO,EAAA3M,OAAA,IAEA9B,EAAAO,OAAA+C,EAAAmL,EAAA,GACAnL,GAAAmL,EAAA,GAGAzO,EAAAU,aAAA0C,EAAAqL,EAAA,GACArL,EAAApD,EAAAU,aAEAV,EAAAU,cAAA,EAGAV,EAAAW,eAAAwC,EAAAsL,EAAA,GACAtL,EAAAnD,EAAAW,eAEA8N,EAAA3M,OAAA,IAEA9B,EAAAY,KAAAyC,EAAAoL,EAAA,GACApL,GAAAoL,EAAA,KAIAN,EAAApD,KAAA/K,GACA,gBAAAA,GAAAU,cACAmO,EAAA9D,KAAA/K,GAKA6M,EAAAsB,EAAAtP,EAAA8K,qCACA9L,KAAAiP,oBAAAqB,EAEAtB,EAAAgC,EAAAhQ,EAAAyK,4BACAzL,KAAAoP,mBAAA4B,GAOA1C,EAAA3M,UAAAuO,aACA,SAAAe,EAAAC,EAAAC,EACAC,EAAAC,EAAAC,GAMA,GAAAL,EAAAE,IAAA,EACA,SAAA3I,WAAA,gDACAyI,EAAAE,GAEA,IAAAF,EAAAG,GAAA,EACA,SAAA5I,WAAA,kDACAyI,EAAAG,GAGA,OAAArC,GAAAwC,OAAAN,EAAAC,EAAAG,EAAAC,IAOAhD,EAAA3M,UAAA6P,mBACA,WACA,OAAAxG,GAAA,EAAuBA,EAAAhL,KAAA8P,mBAAA7L,SAAwC+G,EAAA,CAC/D,GAAA7I,GAAAnC,KAAA8P,mBAAA9E,EAMA,IAAAA,EAAA,EAAAhL,KAAA8P,mBAAA7L,OAAA,CACA,GAAAwN,GAAAzR,KAAA8P,mBAAA9E,EAAA,EAEA,IAAA7I,EAAAI,gBAAAkP,EAAAlP,cAAA,CACAJ,EAAAuP,oBAAAD,EAAAhP,gBAAA,CACA,WAKAN,EAAAuP,oBAAAC,MAwBArD,EAAA3M,UAAA6C,oBACA,SAAA1D,GACA,GAAAmP,IACA1N,cAAAvB,EAAAC,OAAAH,EAAA,QACA2B,gBAAAzB,EAAAC,OAAAH,EAAA,WAGAkK,EAAAhL,KAAAkQ,aACAD,EACAjQ,KAAA8P,mBACA,gBACA,kBACA9O,EAAA8K,oCACA9K,EAAAC,OAAAH,EAAA,OAAAF,EAAA4O,sBAGA,IAAAxE,GAAA,GACA,GAAA7I,GAAAnC,KAAA8P,mBAAA9E,EAEA,IAAA7I,EAAAI,gBAAA0N,EAAA1N,cAAA,CACA,GAAAG,GAAA1B,EAAAC,OAAAkB,EAAA,cACA,QAAAO,IACAA,EAAA1C,KAAAoB,SAAAgM,GAAA1K,GACA,MAAA1C,KAAA+B,aACAW,EAAA1B,EAAAyD,KAAAzE,KAAA+B,WAAAW,IAGA,IAAAK,GAAA/B,EAAAC,OAAAkB,EAAA,YAIA,OAHA,QAAAY,IACAA,EAAA/C,KAAAsB,OAAA8L,GAAArK,KAGAL,SACAJ,KAAAtB,EAAAC,OAAAkB,EAAA,qBACAK,OAAAxB,EAAAC,OAAAkB,EAAA,uBACAY,SAKA,OACAL,OAAA,KACAJ,KAAA,KACAE,OAAA,KACAO,KAAA,OAQAuL,EAAA3M,UAAAiQ,wBACA,WACA,QAAA5R,KAAA2G,iBAGA3G,KAAA2G,eAAA1C,QAAAjE,KAAAoB,SAAAyL,SACA7M,KAAA2G,eAAAkL,KAAA,SAAAC,GAA+C,aAAAA,MAQ/CxD,EAAA3M,UAAA0B,iBACA,SAAAuB,EAAAmN,GACA,IAAA/R,KAAA2G,eACA,WAOA,IAJA,MAAA3G,KAAA+B,aACA6C,EAAA5D,EAAA2B,SAAA3C,KAAA+B,WAAA6C,IAGA5E,KAAAoB,SAAAqC,IAAAmB,GACA,MAAA5E,MAAA2G,eAAA3G,KAAAoB,SAAA6E,QAAArB,GAGA,IAAAqF,EACA,UAAAjK,KAAA+B,aACAkI,EAAAjJ,EAAAsI,SAAAtJ,KAAA+B,aAAA,CAKA,GAAAiQ,GAAApN,EAAAkG,QAAA,gBACA,YAAAb,EAAAP,QACA1J,KAAAoB,SAAAqC,IAAAuO,GACA,MAAAhS,MAAA2G,eAAA3G,KAAAoB,SAAA6E,QAAA+L,GAGA,MAAA/H,EAAAH,MAAA,KAAAG,EAAAH,OACA9J,KAAAoB,SAAAqC,IAAA,IAAAmB,GACA,MAAA5E,MAAA2G,eAAA3G,KAAAoB,SAAA6E,QAAA,IAAArB,IAQA,GAAAmN,EACA,WAGA,UAAA3N,OAAA,IAAAQ,EAAA,+BAuBA0J,EAAA3M,UAAAsQ,qBACA,SAAAnR,GACA,GAAA4B,GAAA1B,EAAAC,OAAAH,EAAA,SAIA,IAHA,MAAAd,KAAA+B,aACAW,EAAA1B,EAAA2B,SAAA3C,KAAA+B,WAAAW,KAEA1C,KAAAoB,SAAAqC,IAAAf,GACA,OACAJ,KAAA,KACAE,OAAA,KACA4N,WAAA,KAGA1N,GAAA1C,KAAAoB,SAAA6E,QAAAvD,EAEA,IAAAuN,IACAvN,SACAG,aAAA7B,EAAAC,OAAAH,EAAA,QACAgC,eAAA9B,EAAAC,OAAAH,EAAA,WAGAkK,EAAAhL,KAAAkQ,aACAD,EACAjQ,KAAA+P,kBACA,eACA,iBACA/O,EAAAyK,2BACAzK,EAAAC,OAAAH,EAAA,OAAAF,EAAA4O,sBAGA,IAAAxE,GAAA,GACA,GAAA7I,GAAAnC,KAAA+P,kBAAA/E,EAEA,IAAA7I,EAAAO,SAAAuN,EAAAvN,OACA,OACAJ,KAAAtB,EAAAC,OAAAkB,EAAA,sBACAK,OAAAxB,EAAAC,OAAAkB,EAAA,wBACAiO,WAAApP,EAAAC,OAAAkB,EAAA,6BAKA,OACAG,KAAA,KACAE,OAAA,KACA4N,WAAA,OAIAxQ,EAAA0O,yBA+FAD,EAAA1M,UAAAkC,OAAAC,OAAAlD,EAAAe,WACA0M,EAAA1M,UAAAuQ,YAAAtR,EAKAyN,EAAA1M,UAAAC,SAAA,EAKAiC,OAAAqL,eAAAb,EAAA1M,UAAA,WACAwL,IAAA,WAEA,OADAlK,MACA4C,EAAA,EAAmBA,EAAA7F,KAAAyO,UAAAxK,OAA2B4B,IAC9C,OAAAsM,GAAA,EAAqBA,EAAAnS,KAAAyO,UAAA5I,GAAAiJ,SAAA7L,QAAAgB,OAA+CkO,IACpElP,EAAAiK,KAAAlN,KAAAyO,UAAA5I,GAAAiJ,SAAA7L,QAAAkP,GAGA,OAAAlP,MAmBAoL,EAAA1M,UAAA6C,oBACA,SAAA1D,GACA,GAAAmP,IACA1N,cAAAvB,EAAAC,OAAAH,EAAA,QACA2B,gBAAAzB,EAAAC,OAAAH,EAAA,WAKAsR,EAAArD,EAAAwC,OAAAtB,EAAAjQ,KAAAyO,UACA,SAAAwB,EAAAoC,GACA,GAAAxG,GAAAoE,EAAA1N,cAAA8P,EAAAxD,gBAAAtM,aACA,OAAAsJ,GACAA,EAGAoE,EAAAxN,gBACA4P,EAAAxD,gBAAApM,kBAEA4P,EAAArS,KAAAyO,UAAA2D,EAEA,OAAAC,GASAA,EAAAvD,SAAAtK,qBACAlC,KAAA2N,EAAA1N,eACA8P,EAAAxD,gBAAAtM,cAAA,GACAC,OAAAyN,EAAAxN,iBACA4P,EAAAxD,gBAAAtM,gBAAA0N,EAAA1N,cACA8P,EAAAxD,gBAAApM,gBAAA,EACA,GACA6P,KAAAxR,EAAAwR,QAdA5P,OAAA,KACAJ,KAAA,KACAE,OAAA,KACAO,KAAA,OAmBAsL,EAAA1M,UAAAiQ,wBACA,WACA,MAAA5R,MAAAyO,UAAA8D,MAAA,SAAAjH,GACA,MAAAA,GAAAwD,SAAA8C,6BASAvD,EAAA1M,UAAA0B,iBACA,SAAAuB,EAAAmN,GACA,OAAAlM,GAAA,EAAmBA,EAAA7F,KAAAyO,UAAAxK,OAA2B4B,IAAA,CAC9C,GAAAwM,GAAArS,KAAAyO,UAAA5I,GAEAzC,EAAAiP,EAAAvD,SAAAzL,iBAAAuB,GAAA,EACA,IAAAxB,EACA,MAAAA,GAGA,GAAA2O,EACA,WAGA,UAAA3N,OAAA,IAAAQ,EAAA,+BAkBAyJ,EAAA1M,UAAAsQ,qBACA,SAAAnR,GACA,OAAA+E,GAAA,EAAmBA,EAAA7F,KAAAyO,UAAAxK,OAA2B4B,IAAA,CAC9C,GAAAwM,GAAArS,KAAAyO,UAAA5I,EAIA,IAAAwM,EAAAvD,SAAA7L,QAAAgD,QAAAjF,EAAAC,OAAAH,EAAA,iBAGA,GAAA0R,GAAAH,EAAAvD,SAAAmD,qBAAAnR,EACA,IAAA0R,EAAA,CACA,GAAAC,IACAnQ,KAAAkQ,EAAAlQ,MACA+P,EAAAxD,gBAAAtM,cAAA,GACAC,OAAAgQ,EAAAhQ,QACA6P,EAAAxD,gBAAAtM,gBAAAiQ,EAAAlQ,KACA+P,EAAAxD,gBAAApM,gBAAA,EACA,GAEA,OAAAgQ,KAIA,OACAnQ,KAAA,KACAE,OAAA,OASA6L,EAAA1M,UAAAwN,eACA,SAAAxH,EAAAvB,GACApG,KAAAiP,uBACAjP,KAAAoP,qBACA,QAAAvJ,GAAA,EAAmBA,EAAA7F,KAAAyO,UAAAxK,OAA2B4B,IAG9C,OAFAwM,GAAArS,KAAAyO,UAAA5I,GACA6M,EAAAL,EAAAvD,SAAAgB,mBACAqC,EAAA,EAAqBA,EAAAO,EAAAzO,OAA4BkO,IAAA,CACjD,GAAAhQ,GAAAuQ,EAAAP,GAEAzP,EAAA2P,EAAAvD,SAAA1N,SAAAgM,GAAAjL,EAAAO,OACA,QAAA2P,EAAAvD,SAAA/M,aACAW,EAAA1B,EAAAyD,KAAA4N,EAAAvD,SAAA/M,WAAAW,IAEA1C,KAAAoB,SAAAsC,IAAAhB,GACAA,EAAA1C,KAAAoB,SAAA6E,QAAAvD,EAEA,IAAAK,GAAAsP,EAAAvD,SAAAxN,OAAA8L,GAAAjL,EAAAY,KACA/C,MAAAsB,OAAAoC,IAAAX,GACAA,EAAA/C,KAAAsB,OAAA2E,QAAAlD,EAMA,IAAA4P,IACAjQ,SACAH,cAAAJ,EAAAI,eACA8P,EAAAxD,gBAAAtM,cAAA,GACAE,gBAAAN,EAAAM,iBACA4P,EAAAxD,gBAAAtM,gBAAAJ,EAAAI,cACA8P,EAAAxD,gBAAApM,gBAAA,EACA,GACAI,aAAAV,EAAAU,aACAC,eAAAX,EAAAW,eACAC,OAGA/C,MAAAiP,oBAAA/B,KAAAyF,GACA,gBAAAA,GAAA9P,cACA7C,KAAAoP,mBAAAlC,KAAAyF,GAKA3D,EAAAhP,KAAAiP,oBAAAjO,EAAA8K,qCACAkD,EAAAhP,KAAAoP,mBAAApO,EAAAyK,6BAGA7L,EAAAyO,4BTu0CM,SAAUxO,EAAQD,GUz2ExB,QAAAgT,GAAAC,EAAAC,EAAA7B,EAAA8B,EAAAC,EAAA1B,GAUA,GAAA2B,GAAAC,KAAAC,OAAAL,EAAAD,GAAA,GAAAA,EACAhH,EAAAmH,EAAA/B,EAAA8B,EAAAE,IAAA,EACA,YAAApH,EAEAoH,EAEApH,EAAA,EAEAiH,EAAAG,EAAA,EAEAL,EAAAK,EAAAH,EAAA7B,EAAA8B,EAAAC,EAAA1B,GAKAA,GAAA1R,EAAA6P,kBACAqD,EAAAC,EAAA9O,OAAA6O,GAAA,EAEAG,EAKAA,EAAAJ,EAAA,EAEAD,EAAAC,EAAAI,EAAAhC,EAAA8B,EAAAC,EAAA1B,GAIAA,GAAA1R,EAAA6P,kBACAwD,EAEAJ,EAAA,KAAAA,EA1DAjT,EAAA4P,qBAAA,EACA5P,EAAA6P,kBAAA,EAgFA7P,EAAA2R,OAAA,SAAAN,EAAA8B,EAAAC,EAAA1B,GACA,OAAAyB,EAAA9O,OACA,QAGA,IAAA+G,GAAA4H,GAAA,EAAAG,EAAA9O,OAAAgN,EAAA8B,EACAC,EAAA1B,GAAA1R,EAAA4P,qBACA,IAAAxE,EAAA,EACA,QAMA,MAAAA,EAAA,MACA,IAAAgI,EAAAD,EAAA/H,GAAA+H,EAAA/H,EAAA,UAGAA,CAGA,OAAAA,KVw4EM,SAAUnL,EAAQD,GW19ExB,QAAAwT,GAAAC,EAAAC,EAAAC,GACA,GAAAxC,GAAAsC,EAAAC,EACAD,GAAAC,GAAAD,EAAAE,GACAF,EAAAE,GAAAxC,EAWA,QAAAyC,GAAAC,EAAAC,GACA,MAAAR,MAAAS,MAAAF,EAAAP,KAAAU,UAAAF,EAAAD,IAeA,QAAAI,GAAAR,EAAAS,EAAApT,EAAAqT,GAKA,GAAArT,EAAAqT,EAAA,CAYA,GAAAC,GAAAR,EAAA9S,EAAAqT,GACAlO,EAAAnF,EAAA,CAEA0S,GAAAC,EAAAW,EAAAD,EASA,QARAE,GAAAZ,EAAAU,GAQA5B,EAAAzR,EAAmByR,EAAA4B,EAAO5B,IAC1B2B,EAAAT,EAAAlB,GAAA8B,IAAA,IACApO,GAAA,EACAuN,EAAAC,EAAAxN,EAAAsM,GAIAiB,GAAAC,EAAAxN,EAAA,EAAAsM,EACA,IAAA+B,GAAArO,EAAA,CAIAgO,GAAAR,EAAAS,EAAApT,EAAAwT,EAAA,GACAL,EAAAR,EAAAS,EAAAI,EAAA,EAAAH,IAYAnU,EAAAoP,UAAA,SAAAqE,EAAAS,GACAD,EAAAR,EAAAS,EAAA,EAAAT,EAAApP,OAAA,KX6/EM,SAAUpE,EAAQD,EAASM,GY3kFjC,QAAAW,GAAAsT,EAAAC,EAAAxP,EAAAyP,EAAAxP,GACA7E,KAAAsU,YACAtU,KAAAuU,kBACAvU,KAAAsC,KAAA,MAAA6R,EAAA,KAAAA,EACAnU,KAAAwC,OAAA,MAAA4R,EAAA,KAAAA,EACApU,KAAA0C,OAAA,MAAAkC,EAAA,KAAAA,EACA5E,KAAA+C,KAAA,MAAA8B,EAAA,KAAAA,EACA7E,KAAAwU,IAAA,EACA,MAAAH,GAAArU,KAAA0D,IAAA2Q,GAnCA,GAAA1T,GAAAT,EAAA,GAAAS,mBACAK,EAAAd,EAAA,GAIAuU,EAAA,UAGAC,EAAA,GAKAF,EAAA,oBAiCA3T,GAAA8T,wBACA,SAAAC,EAAA9S,EAAA+S,GA+FA,QAAAC,GAAA3S,EAAA4S,GACA,UAAA5S,GAAAgO,SAAAhO,EAAAO,OACAsS,EAAAtR,IAAAqR,OACO,CACP,GAAArS,GAAAmS,EACA7T,EAAAyD,KAAAoQ,EAAA1S,EAAAO,QACAP,EAAAO,MACAsS,GAAAtR,IAAA,GAAA7C,GAAAsB,EAAAU,aACAV,EAAAW,eACAJ,EACAqS,EACA5S,EAAAY,QAvGA,GAAAiS,GAAA,GAAAnU,GAMAoU,EAAAL,EAAAtM,MAAAmM,GACAS,EAAA,EACAC,EAAA,WAMA,QAAAC,KACA,MAAAF,GAAAD,EAAAhR,OACAgR,EAAAC,KAAA/E,OAPA,GAAAkF,GAAAD,IAEAE,EAAAF,KAAA,EACA,OAAAC,GAAAC,GASAC,EAAA,EAAA7D,EAAA,EAKA8D,EAAA,IAgEA,OA9DA1T,GAAAI,YAAA,SAAAC,GACA,UAAAqT,EAAA,CAGA,KAAAD,EAAApT,EAAAI,eAMS,CAIT,GAAAkT,GAAAR,EAAAC,GACAH,EAAAU,EAAArK,OAAA,EAAAjJ,EAAAM,gBACAiP,EAOA,OANAuD,GAAAC,GAAAO,EAAArK,OAAAjJ,EAAAM,gBACAiP,GACAA,EAAAvP,EAAAM,gBACAqS,EAAAU,EAAAT,QAEAS,EAAArT,GAhBA2S,EAAAU,EAAAL,KACAI,IACA7D,EAAA,EAqBA,KAAA6D,EAAApT,EAAAI,eACAyS,EAAAtR,IAAAyR,KACAI,GAEA,IAAA7D,EAAAvP,EAAAM,gBAAA,CACA,GAAAgT,GAAAR,EAAAC,EACAF,GAAAtR,IAAA+R,EAAArK,OAAA,EAAAjJ,EAAAM,kBACAwS,EAAAC,GAAAO,EAAArK,OAAAjJ,EAAAM,iBACAiP,EAAAvP,EAAAM,gBAEA+S,EAAArT,GACKnC,MAELkV,EAAAD,EAAAhR,SACAuR,GAEAV,EAAAU,EAAAL,KAGAH,EAAAtR,IAAAuR,EAAAzK,OAAA0K,GAAAzQ,KAAA,MAIA3C,EAAAmB,QAAAC,QAAA,SAAAC,GACA,GAAAC,GAAAtB,EAAAuB,iBAAAF,EACA,OAAAC,IACA,MAAAyR,IACA1R,EAAAnC,EAAAyD,KAAAoQ,EAAA1R,IAEA6R,EAAA1R,iBAAAH,EAAAC,MAIA4R,GAwBAnU,EAAAc,UAAA+B,IAAA,SAAAgS,GACA,GAAAvK,MAAAwK,QAAAD,GACAA,EAAAxS,QAAA,SAAA0S,GACA5V,KAAA0D,IAAAkS,IACK5V,UAEL,KAAA0V,EAAAlB,IAAA,gBAAAkB,GAMA,SAAAlN,WACA,8EAAAkN,EANAA,IACA1V,KAAAsU,SAAApH,KAAAwI,GAQA,MAAA1V,OASAa,EAAAc,UAAAkU,QAAA,SAAAH,GACA,GAAAvK,MAAAwK,QAAAD,GACA,OAAA7P,GAAA6P,EAAAzR,OAAA,EAAiC4B,GAAA,EAAQA,IACzC7F,KAAA6V,QAAAH,EAAA7P,QAGA,KAAA6P,EAAAlB,IAAA,gBAAAkB,GAIA,SAAAlN,WACA,8EAAAkN,EAJA1V,MAAAsU,SAAAwB,QAAAJ,GAOA,MAAA1V,OAUAa,EAAAc,UAAAoU,KAAA,SAAAC,GAEA,OADAJ,GACA/P,EAAA,EAAAC,EAAA9F,KAAAsU,SAAArQ,OAA6C4B,EAAAC,EAASD,IACtD+P,EAAA5V,KAAAsU,SAAAzO,GACA+P,EAAApB,GACAoB,EAAAG,KAAAC,GAGA,KAAAJ,GACAI,EAAAJ,GAAoBlT,OAAA1C,KAAA0C,OACpBJ,KAAAtC,KAAAsC,KACAE,OAAAxC,KAAAwC,OACAO,KAAA/C,KAAA+C,QAYAlC,EAAAc,UAAA8C,KAAA,SAAAwR,GACA,GAAAC,GACArQ,EACAC,EAAA9F,KAAAsU,SAAArQ,MACA,IAAA6B,EAAA,GAEA,IADAoQ,KACArQ,EAAA,EAAeA,EAAAC,EAAA,EAAWD,IAC1BqQ,EAAAhJ,KAAAlN,KAAAsU,SAAAzO,IACAqQ,EAAAhJ,KAAA+I,EAEAC,GAAAhJ,KAAAlN,KAAAsU,SAAAzO,IACA7F,KAAAsU,SAAA4B,EAEA,MAAAlW,OAUAa,EAAAc,UAAAwU,aAAA,SAAAC,EAAAC,GACA,GAAAC,GAAAtW,KAAAsU,SAAAtU,KAAAsU,SAAArQ,OAAA,EAUA,OATAqS,GAAA9B,GACA8B,EAAAH,aAAAC,EAAAC,GAEA,gBAAAC,GACAtW,KAAAsU,SAAAtU,KAAAsU,SAAArQ,OAAA,GAAAqS,EAAAxL,QAAAsL,EAAAC,GAGArW,KAAAsU,SAAApH,KAAA,GAAApC,QAAAsL,EAAAC,IAEArW,MAUAa,EAAAc,UAAA2B,iBACA,SAAAK,EAAAC,GACA5D,KAAAuU,eAAAvT,EAAA+C,YAAAJ,IAAAC,GASA/C,EAAAc,UAAA4U,mBACA,SAAAP,GACA,OAAAnQ,GAAA,EAAAC,EAAA9F,KAAAsU,SAAArQ,OAA+C4B,EAAAC,EAASD,IACxD7F,KAAAsU,SAAAzO,GAAA2O,IACAxU,KAAAsU,SAAAzO,GAAA0Q,mBAAAP,EAKA,QADA/S,GAAAY,OAAAG,KAAAhE,KAAAuU,gBACA1O,EAAA,EAAAC,EAAA7C,EAAAgB,OAAyC4B,EAAAC,EAASD,IAClDmQ,EAAAhV,EAAAwK,cAAAvI,EAAA4C,IAAA7F,KAAAuU,eAAAtR,EAAA4C,MAQAhF,EAAAc,UAAAiF,SAAA,WACA,GAAA+J,GAAA,EAIA,OAHA3Q,MAAA+V,KAAA,SAAAH,GACAjF,GAAAiF,IAEAjF,GAOA9P,EAAAc,UAAA6U,sBAAA,SAAA1V,GACA,GAAAuB,IACA0S,KAAA,GACAzS,KAAA,EACAE,OAAA,GAEA6D,EAAA,GAAA1F,GAAAG,GACA2V,GAAA,EACAC,EAAA,KACAC,EAAA,KACAC,EAAA,KACAC,EAAA,IAqEA,OApEA7W,MAAA+V,KAAA,SAAAH,EAAAhT,GACAP,EAAA0S,MAAAa,EACA,OAAAhT,EAAAF,QACA,OAAAE,EAAAN,MACA,OAAAM,EAAAJ,QACAkU,IAAA9T,EAAAF,QACAiU,IAAA/T,EAAAN,MACAsU,IAAAhU,EAAAJ,QACAqU,IAAAjU,EAAAG,MACAsD,EAAArD,YACAN,OAAAE,EAAAF,OACAE,UACAN,KAAAM,EAAAN,KACAE,OAAAI,EAAAJ,QAEAH,WACAC,KAAAD,EAAAC,KACAE,OAAAH,EAAAG,QAEAO,KAAAH,EAAAG,OAGA2T,EAAA9T,EAAAF,OACAiU,EAAA/T,EAAAN,KACAsU,EAAAhU,EAAAJ,OACAqU,EAAAjU,EAAAG,KACA0T,GAAA,GACKA,IACLpQ,EAAArD,YACAX,WACAC,KAAAD,EAAAC,KACAE,OAAAH,EAAAG,UAGAkU,EAAA,KACAD,GAAA,EAEA,QAAAxJ,GAAA,EAAAhJ,EAAA2R,EAAA3R,OAA4CgJ,EAAAhJ,EAAcgJ,IAC1D2I,EAAA3N,WAAAgF,KAAAyH,GACArS,EAAAC,OACAD,EAAAG,OAAA,EAEAyK,EAAA,IAAAhJ,GACAyS,EAAA,KACAD,GAAA,GACSA,GACTpQ,EAAArD,YACAN,OAAAE,EAAAF,OACAE,UACAN,KAAAM,EAAAN,KACAE,OAAAI,EAAAJ,QAEAH,WACAC,KAAAD,EAAAC,KACAE,OAAAH,EAAAG,QAEAO,KAAAH,EAAAG,QAIAV,EAAAG,WAIAxC,KAAAuW,mBAAA,SAAApT,EAAA2T,GACAzQ,EAAA/C,iBAAAH,EAAA2T,MAGU/B,KAAA1S,EAAA0S,KAAA1O,QAGVzG,EAAAiB","file":"source-map.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"sourceMap\"] = factory();\n\telse\n\t\troot[\"sourceMap\"] = factory();\n})(this, function() {\nreturn \n\n\n// WEBPACK FOOTER //\n// webpack/universalModuleDefinition","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"sourceMap\"] = factory();\n\telse\n\t\troot[\"sourceMap\"] = factory();\n})(this, function() {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t/*\n\t * Copyright 2009-2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE.txt or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\texports.SourceMapGenerator = __webpack_require__(1).SourceMapGenerator;\n\texports.SourceMapConsumer = __webpack_require__(7).SourceMapConsumer;\n\texports.SourceNode = __webpack_require__(10).SourceNode;\n\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\t\n\tvar base64VLQ = __webpack_require__(2);\n\tvar util = __webpack_require__(4);\n\tvar ArraySet = __webpack_require__(5).ArraySet;\n\tvar MappingList = __webpack_require__(6).MappingList;\n\t\n\t/**\n\t * An instance of the SourceMapGenerator represents a source map which is\n\t * being built incrementally. You may pass an object with the following\n\t * properties:\n\t *\n\t *   - file: The filename of the generated source.\n\t *   - sourceRoot: A root for all relative URLs in this source map.\n\t */\n\tfunction SourceMapGenerator(aArgs) {\n\t  if (!aArgs) {\n\t    aArgs = {};\n\t  }\n\t  this._file = util.getArg(aArgs, 'file', null);\n\t  this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);\n\t  this._skipValidation = util.getArg(aArgs, 'skipValidation', false);\n\t  this._sources = new ArraySet();\n\t  this._names = new ArraySet();\n\t  this._mappings = new MappingList();\n\t  this._sourcesContents = null;\n\t}\n\t\n\tSourceMapGenerator.prototype._version = 3;\n\t\n\t/**\n\t * Creates a new SourceMapGenerator based on a SourceMapConsumer\n\t *\n\t * @param aSourceMapConsumer The SourceMap.\n\t */\n\tSourceMapGenerator.fromSourceMap =\n\t  function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {\n\t    var sourceRoot = aSourceMapConsumer.sourceRoot;\n\t    var generator = new SourceMapGenerator({\n\t      file: aSourceMapConsumer.file,\n\t      sourceRoot: sourceRoot\n\t    });\n\t    aSourceMapConsumer.eachMapping(function (mapping) {\n\t      var newMapping = {\n\t        generated: {\n\t          line: mapping.generatedLine,\n\t          column: mapping.generatedColumn\n\t        }\n\t      };\n\t\n\t      if (mapping.source != null) {\n\t        newMapping.source = mapping.source;\n\t        if (sourceRoot != null) {\n\t          newMapping.source = util.relative(sourceRoot, newMapping.source);\n\t        }\n\t\n\t        newMapping.original = {\n\t          line: mapping.originalLine,\n\t          column: mapping.originalColumn\n\t        };\n\t\n\t        if (mapping.name != null) {\n\t          newMapping.name = mapping.name;\n\t        }\n\t      }\n\t\n\t      generator.addMapping(newMapping);\n\t    });\n\t    aSourceMapConsumer.sources.forEach(function (sourceFile) {\n\t      var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n\t      if (content != null) {\n\t        generator.setSourceContent(sourceFile, content);\n\t      }\n\t    });\n\t    return generator;\n\t  };\n\t\n\t/**\n\t * Add a single mapping from original source line and column to the generated\n\t * source's line and column for this source map being created. The mapping\n\t * object should have the following properties:\n\t *\n\t *   - generated: An object with the generated line and column positions.\n\t *   - original: An object with the original line and column positions.\n\t *   - source: The original source file (relative to the sourceRoot).\n\t *   - name: An optional original token name for this mapping.\n\t */\n\tSourceMapGenerator.prototype.addMapping =\n\t  function SourceMapGenerator_addMapping(aArgs) {\n\t    var generated = util.getArg(aArgs, 'generated');\n\t    var original = util.getArg(aArgs, 'original', null);\n\t    var source = util.getArg(aArgs, 'source', null);\n\t    var name = util.getArg(aArgs, 'name', null);\n\t\n\t    if (!this._skipValidation) {\n\t      this._validateMapping(generated, original, source, name);\n\t    }\n\t\n\t    if (source != null) {\n\t      source = String(source);\n\t      if (!this._sources.has(source)) {\n\t        this._sources.add(source);\n\t      }\n\t    }\n\t\n\t    if (name != null) {\n\t      name = String(name);\n\t      if (!this._names.has(name)) {\n\t        this._names.add(name);\n\t      }\n\t    }\n\t\n\t    this._mappings.add({\n\t      generatedLine: generated.line,\n\t      generatedColumn: generated.column,\n\t      originalLine: original != null && original.line,\n\t      originalColumn: original != null && original.column,\n\t      source: source,\n\t      name: name\n\t    });\n\t  };\n\t\n\t/**\n\t * Set the source content for a source file.\n\t */\n\tSourceMapGenerator.prototype.setSourceContent =\n\t  function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {\n\t    var source = aSourceFile;\n\t    if (this._sourceRoot != null) {\n\t      source = util.relative(this._sourceRoot, source);\n\t    }\n\t\n\t    if (aSourceContent != null) {\n\t      // Add the source content to the _sourcesContents map.\n\t      // Create a new _sourcesContents map if the property is null.\n\t      if (!this._sourcesContents) {\n\t        this._sourcesContents = Object.create(null);\n\t      }\n\t      this._sourcesContents[util.toSetString(source)] = aSourceContent;\n\t    } else if (this._sourcesContents) {\n\t      // Remove the source file from the _sourcesContents map.\n\t      // If the _sourcesContents map is empty, set the property to null.\n\t      delete this._sourcesContents[util.toSetString(source)];\n\t      if (Object.keys(this._sourcesContents).length === 0) {\n\t        this._sourcesContents = null;\n\t      }\n\t    }\n\t  };\n\t\n\t/**\n\t * Applies the mappings of a sub-source-map for a specific source file to the\n\t * source map being generated. Each mapping to the supplied source file is\n\t * rewritten using the supplied source map. Note: The resolution for the\n\t * resulting mappings is the minimium of this map and the supplied map.\n\t *\n\t * @param aSourceMapConsumer The source map to be applied.\n\t * @param aSourceFile Optional. The filename of the source file.\n\t *        If omitted, SourceMapConsumer's file property will be used.\n\t * @param aSourceMapPath Optional. The dirname of the path to the source map\n\t *        to be applied. If relative, it is relative to the SourceMapConsumer.\n\t *        This parameter is needed when the two source maps aren't in the same\n\t *        directory, and the source map to be applied contains relative source\n\t *        paths. If so, those relative source paths need to be rewritten\n\t *        relative to the SourceMapGenerator.\n\t */\n\tSourceMapGenerator.prototype.applySourceMap =\n\t  function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {\n\t    var sourceFile = aSourceFile;\n\t    // If aSourceFile is omitted, we will use the file property of the SourceMap\n\t    if (aSourceFile == null) {\n\t      if (aSourceMapConsumer.file == null) {\n\t        throw new Error(\n\t          'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +\n\t          'or the source map\\'s \"file\" property. Both were omitted.'\n\t        );\n\t      }\n\t      sourceFile = aSourceMapConsumer.file;\n\t    }\n\t    var sourceRoot = this._sourceRoot;\n\t    // Make \"sourceFile\" relative if an absolute Url is passed.\n\t    if (sourceRoot != null) {\n\t      sourceFile = util.relative(sourceRoot, sourceFile);\n\t    }\n\t    // Applying the SourceMap can add and remove items from the sources and\n\t    // the names array.\n\t    var newSources = new ArraySet();\n\t    var newNames = new ArraySet();\n\t\n\t    // Find mappings for the \"sourceFile\"\n\t    this._mappings.unsortedForEach(function (mapping) {\n\t      if (mapping.source === sourceFile && mapping.originalLine != null) {\n\t        // Check if it can be mapped by the source map, then update the mapping.\n\t        var original = aSourceMapConsumer.originalPositionFor({\n\t          line: mapping.originalLine,\n\t          column: mapping.originalColumn\n\t        });\n\t        if (original.source != null) {\n\t          // Copy mapping\n\t          mapping.source = original.source;\n\t          if (aSourceMapPath != null) {\n\t            mapping.source = util.join(aSourceMapPath, mapping.source)\n\t          }\n\t          if (sourceRoot != null) {\n\t            mapping.source = util.relative(sourceRoot, mapping.source);\n\t          }\n\t          mapping.originalLine = original.line;\n\t          mapping.originalColumn = original.column;\n\t          if (original.name != null) {\n\t            mapping.name = original.name;\n\t          }\n\t        }\n\t      }\n\t\n\t      var source = mapping.source;\n\t      if (source != null && !newSources.has(source)) {\n\t        newSources.add(source);\n\t      }\n\t\n\t      var name = mapping.name;\n\t      if (name != null && !newNames.has(name)) {\n\t        newNames.add(name);\n\t      }\n\t\n\t    }, this);\n\t    this._sources = newSources;\n\t    this._names = newNames;\n\t\n\t    // Copy sourcesContents of applied map.\n\t    aSourceMapConsumer.sources.forEach(function (sourceFile) {\n\t      var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n\t      if (content != null) {\n\t        if (aSourceMapPath != null) {\n\t          sourceFile = util.join(aSourceMapPath, sourceFile);\n\t        }\n\t        if (sourceRoot != null) {\n\t          sourceFile = util.relative(sourceRoot, sourceFile);\n\t        }\n\t        this.setSourceContent(sourceFile, content);\n\t      }\n\t    }, this);\n\t  };\n\t\n\t/**\n\t * A mapping can have one of the three levels of data:\n\t *\n\t *   1. Just the generated position.\n\t *   2. The Generated position, original position, and original source.\n\t *   3. Generated and original position, original source, as well as a name\n\t *      token.\n\t *\n\t * To maintain consistency, we validate that any new mapping being added falls\n\t * in to one of these categories.\n\t */\n\tSourceMapGenerator.prototype._validateMapping =\n\t  function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,\n\t                                              aName) {\n\t    // When aOriginal is truthy but has empty values for .line and .column,\n\t    // it is most likely a programmer error. In this case we throw a very\n\t    // specific error message to try to guide them the right way.\n\t    // For example: https://github.com/Polymer/polymer-bundler/pull/519\n\t    if (aOriginal && typeof aOriginal.line !== 'number' && typeof aOriginal.column !== 'number') {\n\t        throw new Error(\n\t            'original.line and original.column are not numbers -- you probably meant to omit ' +\n\t            'the original mapping entirely and only map the generated position. If so, pass ' +\n\t            'null for the original mapping instead of an object with empty or null values.'\n\t        );\n\t    }\n\t\n\t    if (aGenerated && 'line' in aGenerated && 'column' in aGenerated\n\t        && aGenerated.line > 0 && aGenerated.column >= 0\n\t        && !aOriginal && !aSource && !aName) {\n\t      // Case 1.\n\t      return;\n\t    }\n\t    else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated\n\t             && aOriginal && 'line' in aOriginal && 'column' in aOriginal\n\t             && aGenerated.line > 0 && aGenerated.column >= 0\n\t             && aOriginal.line > 0 && aOriginal.column >= 0\n\t             && aSource) {\n\t      // Cases 2 and 3.\n\t      return;\n\t    }\n\t    else {\n\t      throw new Error('Invalid mapping: ' + JSON.stringify({\n\t        generated: aGenerated,\n\t        source: aSource,\n\t        original: aOriginal,\n\t        name: aName\n\t      }));\n\t    }\n\t  };\n\t\n\t/**\n\t * Serialize the accumulated mappings in to the stream of base 64 VLQs\n\t * specified by the source map format.\n\t */\n\tSourceMapGenerator.prototype._serializeMappings =\n\t  function SourceMapGenerator_serializeMappings() {\n\t    var previousGeneratedColumn = 0;\n\t    var previousGeneratedLine = 1;\n\t    var previousOriginalColumn = 0;\n\t    var previousOriginalLine = 0;\n\t    var previousName = 0;\n\t    var previousSource = 0;\n\t    var result = '';\n\t    var next;\n\t    var mapping;\n\t    var nameIdx;\n\t    var sourceIdx;\n\t\n\t    var mappings = this._mappings.toArray();\n\t    for (var i = 0, len = mappings.length; i < len; i++) {\n\t      mapping = mappings[i];\n\t      next = ''\n\t\n\t      if (mapping.generatedLine !== previousGeneratedLine) {\n\t        previousGeneratedColumn = 0;\n\t        while (mapping.generatedLine !== previousGeneratedLine) {\n\t          next += ';';\n\t          previousGeneratedLine++;\n\t        }\n\t      }\n\t      else {\n\t        if (i > 0) {\n\t          if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {\n\t            continue;\n\t          }\n\t          next += ',';\n\t        }\n\t      }\n\t\n\t      next += base64VLQ.encode(mapping.generatedColumn\n\t                                 - previousGeneratedColumn);\n\t      previousGeneratedColumn = mapping.generatedColumn;\n\t\n\t      if (mapping.source != null) {\n\t        sourceIdx = this._sources.indexOf(mapping.source);\n\t        next += base64VLQ.encode(sourceIdx - previousSource);\n\t        previousSource = sourceIdx;\n\t\n\t        // lines are stored 0-based in SourceMap spec version 3\n\t        next += base64VLQ.encode(mapping.originalLine - 1\n\t                                   - previousOriginalLine);\n\t        previousOriginalLine = mapping.originalLine - 1;\n\t\n\t        next += base64VLQ.encode(mapping.originalColumn\n\t                                   - previousOriginalColumn);\n\t        previousOriginalColumn = mapping.originalColumn;\n\t\n\t        if (mapping.name != null) {\n\t          nameIdx = this._names.indexOf(mapping.name);\n\t          next += base64VLQ.encode(nameIdx - previousName);\n\t          previousName = nameIdx;\n\t        }\n\t      }\n\t\n\t      result += next;\n\t    }\n\t\n\t    return result;\n\t  };\n\t\n\tSourceMapGenerator.prototype._generateSourcesContent =\n\t  function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {\n\t    return aSources.map(function (source) {\n\t      if (!this._sourcesContents) {\n\t        return null;\n\t      }\n\t      if (aSourceRoot != null) {\n\t        source = util.relative(aSourceRoot, source);\n\t      }\n\t      var key = util.toSetString(source);\n\t      return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)\n\t        ? this._sourcesContents[key]\n\t        : null;\n\t    }, this);\n\t  };\n\t\n\t/**\n\t * Externalize the source map.\n\t */\n\tSourceMapGenerator.prototype.toJSON =\n\t  function SourceMapGenerator_toJSON() {\n\t    var map = {\n\t      version: this._version,\n\t      sources: this._sources.toArray(),\n\t      names: this._names.toArray(),\n\t      mappings: this._serializeMappings()\n\t    };\n\t    if (this._file != null) {\n\t      map.file = this._file;\n\t    }\n\t    if (this._sourceRoot != null) {\n\t      map.sourceRoot = this._sourceRoot;\n\t    }\n\t    if (this._sourcesContents) {\n\t      map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);\n\t    }\n\t\n\t    return map;\n\t  };\n\t\n\t/**\n\t * Render the source map being generated to a string.\n\t */\n\tSourceMapGenerator.prototype.toString =\n\t  function SourceMapGenerator_toString() {\n\t    return JSON.stringify(this.toJSON());\n\t  };\n\t\n\texports.SourceMapGenerator = SourceMapGenerator;\n\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t *\n\t * Based on the Base 64 VLQ implementation in Closure Compiler:\n\t * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java\n\t *\n\t * Copyright 2011 The Closure Compiler Authors. All rights reserved.\n\t * Redistribution and use in source and binary forms, with or without\n\t * modification, are permitted provided that the following conditions are\n\t * met:\n\t *\n\t *  * Redistributions of source code must retain the above copyright\n\t *    notice, this list of conditions and the following disclaimer.\n\t *  * Redistributions in binary form must reproduce the above\n\t *    copyright notice, this list of conditions and the following\n\t *    disclaimer in the documentation and/or other materials provided\n\t *    with the distribution.\n\t *  * Neither the name of Google Inc. nor the names of its\n\t *    contributors may be used to endorse or promote products derived\n\t *    from this software without specific prior written permission.\n\t *\n\t * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n\t * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n\t * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n\t * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n\t * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n\t * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n\t * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n\t * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n\t * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n\t * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n\t * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\t */\n\t\n\tvar base64 = __webpack_require__(3);\n\t\n\t// A single base 64 digit can contain 6 bits of data. For the base 64 variable\n\t// length quantities we use in the source map spec, the first bit is the sign,\n\t// the next four bits are the actual value, and the 6th bit is the\n\t// continuation bit. The continuation bit tells us whether there are more\n\t// digits in this value following this digit.\n\t//\n\t//   Continuation\n\t//   |    Sign\n\t//   |    |\n\t//   V    V\n\t//   101011\n\t\n\tvar VLQ_BASE_SHIFT = 5;\n\t\n\t// binary: 100000\n\tvar VLQ_BASE = 1 << VLQ_BASE_SHIFT;\n\t\n\t// binary: 011111\n\tvar VLQ_BASE_MASK = VLQ_BASE - 1;\n\t\n\t// binary: 100000\n\tvar VLQ_CONTINUATION_BIT = VLQ_BASE;\n\t\n\t/**\n\t * Converts from a two-complement value to a value where the sign bit is\n\t * placed in the least significant bit.  For example, as decimals:\n\t *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)\n\t *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)\n\t */\n\tfunction toVLQSigned(aValue) {\n\t  return aValue < 0\n\t    ? ((-aValue) << 1) + 1\n\t    : (aValue << 1) + 0;\n\t}\n\t\n\t/**\n\t * Converts to a two-complement value from a value where the sign bit is\n\t * placed in the least significant bit.  For example, as decimals:\n\t *   2 (10 binary) becomes 1, 3 (11 binary) becomes -1\n\t *   4 (100 binary) becomes 2, 5 (101 binary) becomes -2\n\t */\n\tfunction fromVLQSigned(aValue) {\n\t  var isNegative = (aValue & 1) === 1;\n\t  var shifted = aValue >> 1;\n\t  return isNegative\n\t    ? -shifted\n\t    : shifted;\n\t}\n\t\n\t/**\n\t * Returns the base 64 VLQ encoded value.\n\t */\n\texports.encode = function base64VLQ_encode(aValue) {\n\t  var encoded = \"\";\n\t  var digit;\n\t\n\t  var vlq = toVLQSigned(aValue);\n\t\n\t  do {\n\t    digit = vlq & VLQ_BASE_MASK;\n\t    vlq >>>= VLQ_BASE_SHIFT;\n\t    if (vlq > 0) {\n\t      // There are still more digits in this value, so we must make sure the\n\t      // continuation bit is marked.\n\t      digit |= VLQ_CONTINUATION_BIT;\n\t    }\n\t    encoded += base64.encode(digit);\n\t  } while (vlq > 0);\n\t\n\t  return encoded;\n\t};\n\t\n\t/**\n\t * Decodes the next base 64 VLQ value from the given string and returns the\n\t * value and the rest of the string via the out parameter.\n\t */\n\texports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {\n\t  var strLen = aStr.length;\n\t  var result = 0;\n\t  var shift = 0;\n\t  var continuation, digit;\n\t\n\t  do {\n\t    if (aIndex >= strLen) {\n\t      throw new Error(\"Expected more digits in base 64 VLQ value.\");\n\t    }\n\t\n\t    digit = base64.decode(aStr.charCodeAt(aIndex++));\n\t    if (digit === -1) {\n\t      throw new Error(\"Invalid base64 digit: \" + aStr.charAt(aIndex - 1));\n\t    }\n\t\n\t    continuation = !!(digit & VLQ_CONTINUATION_BIT);\n\t    digit &= VLQ_BASE_MASK;\n\t    result = result + (digit << shift);\n\t    shift += VLQ_BASE_SHIFT;\n\t  } while (continuation);\n\t\n\t  aOutParam.value = fromVLQSigned(result);\n\t  aOutParam.rest = aIndex;\n\t};\n\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\t\n\tvar intToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');\n\t\n\t/**\n\t * Encode an integer in the range of 0 to 63 to a single base 64 digit.\n\t */\n\texports.encode = function (number) {\n\t  if (0 <= number && number < intToCharMap.length) {\n\t    return intToCharMap[number];\n\t  }\n\t  throw new TypeError(\"Must be between 0 and 63: \" + number);\n\t};\n\t\n\t/**\n\t * Decode a single base 64 character code digit to an integer. Returns -1 on\n\t * failure.\n\t */\n\texports.decode = function (charCode) {\n\t  var bigA = 65;     // 'A'\n\t  var bigZ = 90;     // 'Z'\n\t\n\t  var littleA = 97;  // 'a'\n\t  var littleZ = 122; // 'z'\n\t\n\t  var zero = 48;     // '0'\n\t  var nine = 57;     // '9'\n\t\n\t  var plus = 43;     // '+'\n\t  var slash = 47;    // '/'\n\t\n\t  var littleOffset = 26;\n\t  var numberOffset = 52;\n\t\n\t  // 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ\n\t  if (bigA <= charCode && charCode <= bigZ) {\n\t    return (charCode - bigA);\n\t  }\n\t\n\t  // 26 - 51: abcdefghijklmnopqrstuvwxyz\n\t  if (littleA <= charCode && charCode <= littleZ) {\n\t    return (charCode - littleA + littleOffset);\n\t  }\n\t\n\t  // 52 - 61: 0123456789\n\t  if (zero <= charCode && charCode <= nine) {\n\t    return (charCode - zero + numberOffset);\n\t  }\n\t\n\t  // 62: +\n\t  if (charCode == plus) {\n\t    return 62;\n\t  }\n\t\n\t  // 63: /\n\t  if (charCode == slash) {\n\t    return 63;\n\t  }\n\t\n\t  // Invalid base64 digit.\n\t  return -1;\n\t};\n\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\t\n\t/**\n\t * This is a helper function for getting values from parameter/options\n\t * objects.\n\t *\n\t * @param args The object we are extracting values from\n\t * @param name The name of the property we are getting.\n\t * @param defaultValue An optional value to return if the property is missing\n\t * from the object. If this is not specified and the property is missing, an\n\t * error will be thrown.\n\t */\n\tfunction getArg(aArgs, aName, aDefaultValue) {\n\t  if (aName in aArgs) {\n\t    return aArgs[aName];\n\t  } else if (arguments.length === 3) {\n\t    return aDefaultValue;\n\t  } else {\n\t    throw new Error('\"' + aName + '\" is a required argument.');\n\t  }\n\t}\n\texports.getArg = getArg;\n\t\n\tvar urlRegexp = /^(?:([\\w+\\-.]+):)?\\/\\/(?:(\\w+:\\w+)@)?([\\w.]*)(?::(\\d+))?(\\S*)$/;\n\tvar dataUrlRegexp = /^data:.+\\,.+$/;\n\t\n\tfunction urlParse(aUrl) {\n\t  var match = aUrl.match(urlRegexp);\n\t  if (!match) {\n\t    return null;\n\t  }\n\t  return {\n\t    scheme: match[1],\n\t    auth: match[2],\n\t    host: match[3],\n\t    port: match[4],\n\t    path: match[5]\n\t  };\n\t}\n\texports.urlParse = urlParse;\n\t\n\tfunction urlGenerate(aParsedUrl) {\n\t  var url = '';\n\t  if (aParsedUrl.scheme) {\n\t    url += aParsedUrl.scheme + ':';\n\t  }\n\t  url += '//';\n\t  if (aParsedUrl.auth) {\n\t    url += aParsedUrl.auth + '@';\n\t  }\n\t  if (aParsedUrl.host) {\n\t    url += aParsedUrl.host;\n\t  }\n\t  if (aParsedUrl.port) {\n\t    url += \":\" + aParsedUrl.port\n\t  }\n\t  if (aParsedUrl.path) {\n\t    url += aParsedUrl.path;\n\t  }\n\t  return url;\n\t}\n\texports.urlGenerate = urlGenerate;\n\t\n\t/**\n\t * Normalizes a path, or the path portion of a URL:\n\t *\n\t * - Replaces consecutive slashes with one slash.\n\t * - Removes unnecessary '.' parts.\n\t * - Removes unnecessary '<dir>/..' parts.\n\t *\n\t * Based on code in the Node.js 'path' core module.\n\t *\n\t * @param aPath The path or url to normalize.\n\t */\n\tfunction normalize(aPath) {\n\t  var path = aPath;\n\t  var url = urlParse(aPath);\n\t  if (url) {\n\t    if (!url.path) {\n\t      return aPath;\n\t    }\n\t    path = url.path;\n\t  }\n\t  var isAbsolute = exports.isAbsolute(path);\n\t\n\t  var parts = path.split(/\\/+/);\n\t  for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {\n\t    part = parts[i];\n\t    if (part === '.') {\n\t      parts.splice(i, 1);\n\t    } else if (part === '..') {\n\t      up++;\n\t    } else if (up > 0) {\n\t      if (part === '') {\n\t        // The first part is blank if the path is absolute. Trying to go\n\t        // above the root is a no-op. Therefore we can remove all '..' parts\n\t        // directly after the root.\n\t        parts.splice(i + 1, up);\n\t        up = 0;\n\t      } else {\n\t        parts.splice(i, 2);\n\t        up--;\n\t      }\n\t    }\n\t  }\n\t  path = parts.join('/');\n\t\n\t  if (path === '') {\n\t    path = isAbsolute ? '/' : '.';\n\t  }\n\t\n\t  if (url) {\n\t    url.path = path;\n\t    return urlGenerate(url);\n\t  }\n\t  return path;\n\t}\n\texports.normalize = normalize;\n\t\n\t/**\n\t * Joins two paths/URLs.\n\t *\n\t * @param aRoot The root path or URL.\n\t * @param aPath The path or URL to be joined with the root.\n\t *\n\t * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a\n\t *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended\n\t *   first.\n\t * - Otherwise aPath is a path. If aRoot is a URL, then its path portion\n\t *   is updated with the result and aRoot is returned. Otherwise the result\n\t *   is returned.\n\t *   - If aPath is absolute, the result is aPath.\n\t *   - Otherwise the two paths are joined with a slash.\n\t * - Joining for example 'http://' and 'www.example.com' is also supported.\n\t */\n\tfunction join(aRoot, aPath) {\n\t  if (aRoot === \"\") {\n\t    aRoot = \".\";\n\t  }\n\t  if (aPath === \"\") {\n\t    aPath = \".\";\n\t  }\n\t  var aPathUrl = urlParse(aPath);\n\t  var aRootUrl = urlParse(aRoot);\n\t  if (aRootUrl) {\n\t    aRoot = aRootUrl.path || '/';\n\t  }\n\t\n\t  // `join(foo, '//www.example.org')`\n\t  if (aPathUrl && !aPathUrl.scheme) {\n\t    if (aRootUrl) {\n\t      aPathUrl.scheme = aRootUrl.scheme;\n\t    }\n\t    return urlGenerate(aPathUrl);\n\t  }\n\t\n\t  if (aPathUrl || aPath.match(dataUrlRegexp)) {\n\t    return aPath;\n\t  }\n\t\n\t  // `join('http://', 'www.example.com')`\n\t  if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {\n\t    aRootUrl.host = aPath;\n\t    return urlGenerate(aRootUrl);\n\t  }\n\t\n\t  var joined = aPath.charAt(0) === '/'\n\t    ? aPath\n\t    : normalize(aRoot.replace(/\\/+$/, '') + '/' + aPath);\n\t\n\t  if (aRootUrl) {\n\t    aRootUrl.path = joined;\n\t    return urlGenerate(aRootUrl);\n\t  }\n\t  return joined;\n\t}\n\texports.join = join;\n\t\n\texports.isAbsolute = function (aPath) {\n\t  return aPath.charAt(0) === '/' || !!aPath.match(urlRegexp);\n\t};\n\t\n\t/**\n\t * Make a path relative to a URL or another path.\n\t *\n\t * @param aRoot The root path or URL.\n\t * @param aPath The path or URL to be made relative to aRoot.\n\t */\n\tfunction relative(aRoot, aPath) {\n\t  if (aRoot === \"\") {\n\t    aRoot = \".\";\n\t  }\n\t\n\t  aRoot = aRoot.replace(/\\/$/, '');\n\t\n\t  // It is possible for the path to be above the root. In this case, simply\n\t  // checking whether the root is a prefix of the path won't work. Instead, we\n\t  // need to remove components from the root one by one, until either we find\n\t  // a prefix that fits, or we run out of components to remove.\n\t  var level = 0;\n\t  while (aPath.indexOf(aRoot + '/') !== 0) {\n\t    var index = aRoot.lastIndexOf(\"/\");\n\t    if (index < 0) {\n\t      return aPath;\n\t    }\n\t\n\t    // If the only part of the root that is left is the scheme (i.e. http://,\n\t    // file:///, etc.), one or more slashes (/), or simply nothing at all, we\n\t    // have exhausted all components, so the path is not relative to the root.\n\t    aRoot = aRoot.slice(0, index);\n\t    if (aRoot.match(/^([^\\/]+:\\/)?\\/*$/)) {\n\t      return aPath;\n\t    }\n\t\n\t    ++level;\n\t  }\n\t\n\t  // Make sure we add a \"../\" for each component we removed from the root.\n\t  return Array(level + 1).join(\"../\") + aPath.substr(aRoot.length + 1);\n\t}\n\texports.relative = relative;\n\t\n\tvar supportsNullProto = (function () {\n\t  var obj = Object.create(null);\n\t  return !('__proto__' in obj);\n\t}());\n\t\n\tfunction identity (s) {\n\t  return s;\n\t}\n\t\n\t/**\n\t * Because behavior goes wacky when you set `__proto__` on objects, we\n\t * have to prefix all the strings in our set with an arbitrary character.\n\t *\n\t * See https://github.com/mozilla/source-map/pull/31 and\n\t * https://github.com/mozilla/source-map/issues/30\n\t *\n\t * @param String aStr\n\t */\n\tfunction toSetString(aStr) {\n\t  if (isProtoString(aStr)) {\n\t    return '$' + aStr;\n\t  }\n\t\n\t  return aStr;\n\t}\n\texports.toSetString = supportsNullProto ? identity : toSetString;\n\t\n\tfunction fromSetString(aStr) {\n\t  if (isProtoString(aStr)) {\n\t    return aStr.slice(1);\n\t  }\n\t\n\t  return aStr;\n\t}\n\texports.fromSetString = supportsNullProto ? identity : fromSetString;\n\t\n\tfunction isProtoString(s) {\n\t  if (!s) {\n\t    return false;\n\t  }\n\t\n\t  var length = s.length;\n\t\n\t  if (length < 9 /* \"__proto__\".length */) {\n\t    return false;\n\t  }\n\t\n\t  if (s.charCodeAt(length - 1) !== 95  /* '_' */ ||\n\t      s.charCodeAt(length - 2) !== 95  /* '_' */ ||\n\t      s.charCodeAt(length - 3) !== 111 /* 'o' */ ||\n\t      s.charCodeAt(length - 4) !== 116 /* 't' */ ||\n\t      s.charCodeAt(length - 5) !== 111 /* 'o' */ ||\n\t      s.charCodeAt(length - 6) !== 114 /* 'r' */ ||\n\t      s.charCodeAt(length - 7) !== 112 /* 'p' */ ||\n\t      s.charCodeAt(length - 8) !== 95  /* '_' */ ||\n\t      s.charCodeAt(length - 9) !== 95  /* '_' */) {\n\t    return false;\n\t  }\n\t\n\t  for (var i = length - 10; i >= 0; i--) {\n\t    if (s.charCodeAt(i) !== 36 /* '$' */) {\n\t      return false;\n\t    }\n\t  }\n\t\n\t  return true;\n\t}\n\t\n\t/**\n\t * Comparator between two mappings where the original positions are compared.\n\t *\n\t * Optionally pass in `true` as `onlyCompareGenerated` to consider two\n\t * mappings with the same original source/line/column, but different generated\n\t * line and column the same. Useful when searching for a mapping with a\n\t * stubbed out mapping.\n\t */\n\tfunction compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {\n\t  var cmp = mappingA.source - mappingB.source;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\t\n\t  cmp = mappingA.originalLine - mappingB.originalLine;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\t\n\t  cmp = mappingA.originalColumn - mappingB.originalColumn;\n\t  if (cmp !== 0 || onlyCompareOriginal) {\n\t    return cmp;\n\t  }\n\t\n\t  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\t\n\t  cmp = mappingA.generatedLine - mappingB.generatedLine;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\t\n\t  return mappingA.name - mappingB.name;\n\t}\n\texports.compareByOriginalPositions = compareByOriginalPositions;\n\t\n\t/**\n\t * Comparator between two mappings with deflated source and name indices where\n\t * the generated positions are compared.\n\t *\n\t * Optionally pass in `true` as `onlyCompareGenerated` to consider two\n\t * mappings with the same generated line and column, but different\n\t * source/name/original line and column the same. Useful when searching for a\n\t * mapping with a stubbed out mapping.\n\t */\n\tfunction compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {\n\t  var cmp = mappingA.generatedLine - mappingB.generatedLine;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\t\n\t  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n\t  if (cmp !== 0 || onlyCompareGenerated) {\n\t    return cmp;\n\t  }\n\t\n\t  cmp = mappingA.source - mappingB.source;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\t\n\t  cmp = mappingA.originalLine - mappingB.originalLine;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\t\n\t  cmp = mappingA.originalColumn - mappingB.originalColumn;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\t\n\t  return mappingA.name - mappingB.name;\n\t}\n\texports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;\n\t\n\tfunction strcmp(aStr1, aStr2) {\n\t  if (aStr1 === aStr2) {\n\t    return 0;\n\t  }\n\t\n\t  if (aStr1 > aStr2) {\n\t    return 1;\n\t  }\n\t\n\t  return -1;\n\t}\n\t\n\t/**\n\t * Comparator between two mappings with inflated source and name strings where\n\t * the generated positions are compared.\n\t */\n\tfunction compareByGeneratedPositionsInflated(mappingA, mappingB) {\n\t  var cmp = mappingA.generatedLine - mappingB.generatedLine;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\t\n\t  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\t\n\t  cmp = strcmp(mappingA.source, mappingB.source);\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\t\n\t  cmp = mappingA.originalLine - mappingB.originalLine;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\t\n\t  cmp = mappingA.originalColumn - mappingB.originalColumn;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\t\n\t  return strcmp(mappingA.name, mappingB.name);\n\t}\n\texports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;\n\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\t\n\tvar util = __webpack_require__(4);\n\tvar has = Object.prototype.hasOwnProperty;\n\tvar hasNativeMap = typeof Map !== \"undefined\";\n\t\n\t/**\n\t * A data structure which is a combination of an array and a set. Adding a new\n\t * member is O(1), testing for membership is O(1), and finding the index of an\n\t * element is O(1). Removing elements from the set is not supported. Only\n\t * strings are supported for membership.\n\t */\n\tfunction ArraySet() {\n\t  this._array = [];\n\t  this._set = hasNativeMap ? new Map() : Object.create(null);\n\t}\n\t\n\t/**\n\t * Static method for creating ArraySet instances from an existing array.\n\t */\n\tArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {\n\t  var set = new ArraySet();\n\t  for (var i = 0, len = aArray.length; i < len; i++) {\n\t    set.add(aArray[i], aAllowDuplicates);\n\t  }\n\t  return set;\n\t};\n\t\n\t/**\n\t * Return how many unique items are in this ArraySet. If duplicates have been\n\t * added, than those do not count towards the size.\n\t *\n\t * @returns Number\n\t */\n\tArraySet.prototype.size = function ArraySet_size() {\n\t  return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;\n\t};\n\t\n\t/**\n\t * Add the given string to this set.\n\t *\n\t * @param String aStr\n\t */\n\tArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {\n\t  var sStr = hasNativeMap ? aStr : util.toSetString(aStr);\n\t  var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);\n\t  var idx = this._array.length;\n\t  if (!isDuplicate || aAllowDuplicates) {\n\t    this._array.push(aStr);\n\t  }\n\t  if (!isDuplicate) {\n\t    if (hasNativeMap) {\n\t      this._set.set(aStr, idx);\n\t    } else {\n\t      this._set[sStr] = idx;\n\t    }\n\t  }\n\t};\n\t\n\t/**\n\t * Is the given string a member of this set?\n\t *\n\t * @param String aStr\n\t */\n\tArraySet.prototype.has = function ArraySet_has(aStr) {\n\t  if (hasNativeMap) {\n\t    return this._set.has(aStr);\n\t  } else {\n\t    var sStr = util.toSetString(aStr);\n\t    return has.call(this._set, sStr);\n\t  }\n\t};\n\t\n\t/**\n\t * What is the index of the given string in the array?\n\t *\n\t * @param String aStr\n\t */\n\tArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {\n\t  if (hasNativeMap) {\n\t    var idx = this._set.get(aStr);\n\t    if (idx >= 0) {\n\t        return idx;\n\t    }\n\t  } else {\n\t    var sStr = util.toSetString(aStr);\n\t    if (has.call(this._set, sStr)) {\n\t      return this._set[sStr];\n\t    }\n\t  }\n\t\n\t  throw new Error('\"' + aStr + '\" is not in the set.');\n\t};\n\t\n\t/**\n\t * What is the element at the given index?\n\t *\n\t * @param Number aIdx\n\t */\n\tArraySet.prototype.at = function ArraySet_at(aIdx) {\n\t  if (aIdx >= 0 && aIdx < this._array.length) {\n\t    return this._array[aIdx];\n\t  }\n\t  throw new Error('No element indexed by ' + aIdx);\n\t};\n\t\n\t/**\n\t * Returns the array representation of this set (which has the proper indices\n\t * indicated by indexOf). Note that this is a copy of the internal array used\n\t * for storing the members so that no one can mess with internal state.\n\t */\n\tArraySet.prototype.toArray = function ArraySet_toArray() {\n\t  return this._array.slice();\n\t};\n\t\n\texports.ArraySet = ArraySet;\n\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2014 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\t\n\tvar util = __webpack_require__(4);\n\t\n\t/**\n\t * Determine whether mappingB is after mappingA with respect to generated\n\t * position.\n\t */\n\tfunction generatedPositionAfter(mappingA, mappingB) {\n\t  // Optimized for most common case\n\t  var lineA = mappingA.generatedLine;\n\t  var lineB = mappingB.generatedLine;\n\t  var columnA = mappingA.generatedColumn;\n\t  var columnB = mappingB.generatedColumn;\n\t  return lineB > lineA || lineB == lineA && columnB >= columnA ||\n\t         util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;\n\t}\n\t\n\t/**\n\t * A data structure to provide a sorted view of accumulated mappings in a\n\t * performance conscious manner. It trades a neglibable overhead in general\n\t * case for a large speedup in case of mappings being added in order.\n\t */\n\tfunction MappingList() {\n\t  this._array = [];\n\t  this._sorted = true;\n\t  // Serves as infimum\n\t  this._last = {generatedLine: -1, generatedColumn: 0};\n\t}\n\t\n\t/**\n\t * Iterate through internal items. This method takes the same arguments that\n\t * `Array.prototype.forEach` takes.\n\t *\n\t * NOTE: The order of the mappings is NOT guaranteed.\n\t */\n\tMappingList.prototype.unsortedForEach =\n\t  function MappingList_forEach(aCallback, aThisArg) {\n\t    this._array.forEach(aCallback, aThisArg);\n\t  };\n\t\n\t/**\n\t * Add the given source mapping.\n\t *\n\t * @param Object aMapping\n\t */\n\tMappingList.prototype.add = function MappingList_add(aMapping) {\n\t  if (generatedPositionAfter(this._last, aMapping)) {\n\t    this._last = aMapping;\n\t    this._array.push(aMapping);\n\t  } else {\n\t    this._sorted = false;\n\t    this._array.push(aMapping);\n\t  }\n\t};\n\t\n\t/**\n\t * Returns the flat, sorted array of mappings. The mappings are sorted by\n\t * generated position.\n\t *\n\t * WARNING: This method returns internal data without copying, for\n\t * performance. The return value must NOT be mutated, and should be treated as\n\t * an immutable borrow. If you want to take ownership, you must make your own\n\t * copy.\n\t */\n\tMappingList.prototype.toArray = function MappingList_toArray() {\n\t  if (!this._sorted) {\n\t    this._array.sort(util.compareByGeneratedPositionsInflated);\n\t    this._sorted = true;\n\t  }\n\t  return this._array;\n\t};\n\t\n\texports.MappingList = MappingList;\n\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\t\n\tvar util = __webpack_require__(4);\n\tvar binarySearch = __webpack_require__(8);\n\tvar ArraySet = __webpack_require__(5).ArraySet;\n\tvar base64VLQ = __webpack_require__(2);\n\tvar quickSort = __webpack_require__(9).quickSort;\n\t\n\tfunction SourceMapConsumer(aSourceMap) {\n\t  var sourceMap = aSourceMap;\n\t  if (typeof aSourceMap === 'string') {\n\t    sourceMap = JSON.parse(aSourceMap.replace(/^\\)\\]\\}'/, ''));\n\t  }\n\t\n\t  return sourceMap.sections != null\n\t    ? new IndexedSourceMapConsumer(sourceMap)\n\t    : new BasicSourceMapConsumer(sourceMap);\n\t}\n\t\n\tSourceMapConsumer.fromSourceMap = function(aSourceMap) {\n\t  return BasicSourceMapConsumer.fromSourceMap(aSourceMap);\n\t}\n\t\n\t/**\n\t * The version of the source mapping spec that we are consuming.\n\t */\n\tSourceMapConsumer.prototype._version = 3;\n\t\n\t// `__generatedMappings` and `__originalMappings` are arrays that hold the\n\t// parsed mapping coordinates from the source map's \"mappings\" attribute. They\n\t// are lazily instantiated, accessed via the `_generatedMappings` and\n\t// `_originalMappings` getters respectively, and we only parse the mappings\n\t// and create these arrays once queried for a source location. We jump through\n\t// these hoops because there can be many thousands of mappings, and parsing\n\t// them is expensive, so we only want to do it if we must.\n\t//\n\t// Each object in the arrays is of the form:\n\t//\n\t//     {\n\t//       generatedLine: The line number in the generated code,\n\t//       generatedColumn: The column number in the generated code,\n\t//       source: The path to the original source file that generated this\n\t//               chunk of code,\n\t//       originalLine: The line number in the original source that\n\t//                     corresponds to this chunk of generated code,\n\t//       originalColumn: The column number in the original source that\n\t//                       corresponds to this chunk of generated code,\n\t//       name: The name of the original symbol which generated this chunk of\n\t//             code.\n\t//     }\n\t//\n\t// All properties except for `generatedLine` and `generatedColumn` can be\n\t// `null`.\n\t//\n\t// `_generatedMappings` is ordered by the generated positions.\n\t//\n\t// `_originalMappings` is ordered by the original positions.\n\t\n\tSourceMapConsumer.prototype.__generatedMappings = null;\n\tObject.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {\n\t  get: function () {\n\t    if (!this.__generatedMappings) {\n\t      this._parseMappings(this._mappings, this.sourceRoot);\n\t    }\n\t\n\t    return this.__generatedMappings;\n\t  }\n\t});\n\t\n\tSourceMapConsumer.prototype.__originalMappings = null;\n\tObject.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {\n\t  get: function () {\n\t    if (!this.__originalMappings) {\n\t      this._parseMappings(this._mappings, this.sourceRoot);\n\t    }\n\t\n\t    return this.__originalMappings;\n\t  }\n\t});\n\t\n\tSourceMapConsumer.prototype._charIsMappingSeparator =\n\t  function SourceMapConsumer_charIsMappingSeparator(aStr, index) {\n\t    var c = aStr.charAt(index);\n\t    return c === \";\" || c === \",\";\n\t  };\n\t\n\t/**\n\t * Parse the mappings in a string in to a data structure which we can easily\n\t * query (the ordered arrays in the `this.__generatedMappings` and\n\t * `this.__originalMappings` properties).\n\t */\n\tSourceMapConsumer.prototype._parseMappings =\n\t  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n\t    throw new Error(\"Subclasses must implement _parseMappings\");\n\t  };\n\t\n\tSourceMapConsumer.GENERATED_ORDER = 1;\n\tSourceMapConsumer.ORIGINAL_ORDER = 2;\n\t\n\tSourceMapConsumer.GREATEST_LOWER_BOUND = 1;\n\tSourceMapConsumer.LEAST_UPPER_BOUND = 2;\n\t\n\t/**\n\t * Iterate over each mapping between an original source/line/column and a\n\t * generated line/column in this source map.\n\t *\n\t * @param Function aCallback\n\t *        The function that is called with each mapping.\n\t * @param Object aContext\n\t *        Optional. If specified, this object will be the value of `this` every\n\t *        time that `aCallback` is called.\n\t * @param aOrder\n\t *        Either `SourceMapConsumer.GENERATED_ORDER` or\n\t *        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to\n\t *        iterate over the mappings sorted by the generated file's line/column\n\t *        order or the original's source/line/column order, respectively. Defaults to\n\t *        `SourceMapConsumer.GENERATED_ORDER`.\n\t */\n\tSourceMapConsumer.prototype.eachMapping =\n\t  function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {\n\t    var context = aContext || null;\n\t    var order = aOrder || SourceMapConsumer.GENERATED_ORDER;\n\t\n\t    var mappings;\n\t    switch (order) {\n\t    case SourceMapConsumer.GENERATED_ORDER:\n\t      mappings = this._generatedMappings;\n\t      break;\n\t    case SourceMapConsumer.ORIGINAL_ORDER:\n\t      mappings = this._originalMappings;\n\t      break;\n\t    default:\n\t      throw new Error(\"Unknown order of iteration.\");\n\t    }\n\t\n\t    var sourceRoot = this.sourceRoot;\n\t    mappings.map(function (mapping) {\n\t      var source = mapping.source === null ? null : this._sources.at(mapping.source);\n\t      if (source != null && sourceRoot != null) {\n\t        source = util.join(sourceRoot, source);\n\t      }\n\t      return {\n\t        source: source,\n\t        generatedLine: mapping.generatedLine,\n\t        generatedColumn: mapping.generatedColumn,\n\t        originalLine: mapping.originalLine,\n\t        originalColumn: mapping.originalColumn,\n\t        name: mapping.name === null ? null : this._names.at(mapping.name)\n\t      };\n\t    }, this).forEach(aCallback, context);\n\t  };\n\t\n\t/**\n\t * Returns all generated line and column information for the original source,\n\t * line, and column provided. If no column is provided, returns all mappings\n\t * corresponding to a either the line we are searching for or the next\n\t * closest line that has any mappings. Otherwise, returns all mappings\n\t * corresponding to the given line and either the column we are searching for\n\t * or the next closest column that has any offsets.\n\t *\n\t * The only argument is an object with the following properties:\n\t *\n\t *   - source: The filename of the original source.\n\t *   - line: The line number in the original source.\n\t *   - column: Optional. the column number in the original source.\n\t *\n\t * and an array of objects is returned, each with the following properties:\n\t *\n\t *   - line: The line number in the generated source, or null.\n\t *   - column: The column number in the generated source, or null.\n\t */\n\tSourceMapConsumer.prototype.allGeneratedPositionsFor =\n\t  function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {\n\t    var line = util.getArg(aArgs, 'line');\n\t\n\t    // When there is no exact match, BasicSourceMapConsumer.prototype._findMapping\n\t    // returns the index of the closest mapping less than the needle. By\n\t    // setting needle.originalColumn to 0, we thus find the last mapping for\n\t    // the given line, provided such a mapping exists.\n\t    var needle = {\n\t      source: util.getArg(aArgs, 'source'),\n\t      originalLine: line,\n\t      originalColumn: util.getArg(aArgs, 'column', 0)\n\t    };\n\t\n\t    if (this.sourceRoot != null) {\n\t      needle.source = util.relative(this.sourceRoot, needle.source);\n\t    }\n\t    if (!this._sources.has(needle.source)) {\n\t      return [];\n\t    }\n\t    needle.source = this._sources.indexOf(needle.source);\n\t\n\t    var mappings = [];\n\t\n\t    var index = this._findMapping(needle,\n\t                                  this._originalMappings,\n\t                                  \"originalLine\",\n\t                                  \"originalColumn\",\n\t                                  util.compareByOriginalPositions,\n\t                                  binarySearch.LEAST_UPPER_BOUND);\n\t    if (index >= 0) {\n\t      var mapping = this._originalMappings[index];\n\t\n\t      if (aArgs.column === undefined) {\n\t        var originalLine = mapping.originalLine;\n\t\n\t        // Iterate until either we run out of mappings, or we run into\n\t        // a mapping for a different line than the one we found. Since\n\t        // mappings are sorted, this is guaranteed to find all mappings for\n\t        // the line we found.\n\t        while (mapping && mapping.originalLine === originalLine) {\n\t          mappings.push({\n\t            line: util.getArg(mapping, 'generatedLine', null),\n\t            column: util.getArg(mapping, 'generatedColumn', null),\n\t            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n\t          });\n\t\n\t          mapping = this._originalMappings[++index];\n\t        }\n\t      } else {\n\t        var originalColumn = mapping.originalColumn;\n\t\n\t        // Iterate until either we run out of mappings, or we run into\n\t        // a mapping for a different line than the one we were searching for.\n\t        // Since mappings are sorted, this is guaranteed to find all mappings for\n\t        // the line we are searching for.\n\t        while (mapping &&\n\t               mapping.originalLine === line &&\n\t               mapping.originalColumn == originalColumn) {\n\t          mappings.push({\n\t            line: util.getArg(mapping, 'generatedLine', null),\n\t            column: util.getArg(mapping, 'generatedColumn', null),\n\t            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n\t          });\n\t\n\t          mapping = this._originalMappings[++index];\n\t        }\n\t      }\n\t    }\n\t\n\t    return mappings;\n\t  };\n\t\n\texports.SourceMapConsumer = SourceMapConsumer;\n\t\n\t/**\n\t * A BasicSourceMapConsumer instance represents a parsed source map which we can\n\t * query for information about the original file positions by giving it a file\n\t * position in the generated source.\n\t *\n\t * The only parameter is the raw source map (either as a JSON string, or\n\t * already parsed to an object). According to the spec, source maps have the\n\t * following attributes:\n\t *\n\t *   - version: Which version of the source map spec this map is following.\n\t *   - sources: An array of URLs to the original source files.\n\t *   - names: An array of identifiers which can be referrenced by individual mappings.\n\t *   - sourceRoot: Optional. The URL root from which all sources are relative.\n\t *   - sourcesContent: Optional. An array of contents of the original source files.\n\t *   - mappings: A string of base64 VLQs which contain the actual mappings.\n\t *   - file: Optional. The generated file this source map is associated with.\n\t *\n\t * Here is an example source map, taken from the source map spec[0]:\n\t *\n\t *     {\n\t *       version : 3,\n\t *       file: \"out.js\",\n\t *       sourceRoot : \"\",\n\t *       sources: [\"foo.js\", \"bar.js\"],\n\t *       names: [\"src\", \"maps\", \"are\", \"fun\"],\n\t *       mappings: \"AA,AB;;ABCDE;\"\n\t *     }\n\t *\n\t * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#\n\t */\n\tfunction BasicSourceMapConsumer(aSourceMap) {\n\t  var sourceMap = aSourceMap;\n\t  if (typeof aSourceMap === 'string') {\n\t    sourceMap = JSON.parse(aSourceMap.replace(/^\\)\\]\\}'/, ''));\n\t  }\n\t\n\t  var version = util.getArg(sourceMap, 'version');\n\t  var sources = util.getArg(sourceMap, 'sources');\n\t  // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which\n\t  // requires the array) to play nice here.\n\t  var names = util.getArg(sourceMap, 'names', []);\n\t  var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);\n\t  var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);\n\t  var mappings = util.getArg(sourceMap, 'mappings');\n\t  var file = util.getArg(sourceMap, 'file', null);\n\t\n\t  // Once again, Sass deviates from the spec and supplies the version as a\n\t  // string rather than a number, so we use loose equality checking here.\n\t  if (version != this._version) {\n\t    throw new Error('Unsupported version: ' + version);\n\t  }\n\t\n\t  sources = sources\n\t    .map(String)\n\t    // Some source maps produce relative source paths like \"./foo.js\" instead of\n\t    // \"foo.js\".  Normalize these first so that future comparisons will succeed.\n\t    // See bugzil.la/1090768.\n\t    .map(util.normalize)\n\t    // Always ensure that absolute sources are internally stored relative to\n\t    // the source root, if the source root is absolute. Not doing this would\n\t    // be particularly problematic when the source root is a prefix of the\n\t    // source (valid, but why??). See github issue #199 and bugzil.la/1188982.\n\t    .map(function (source) {\n\t      return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source)\n\t        ? util.relative(sourceRoot, source)\n\t        : source;\n\t    });\n\t\n\t  // Pass `true` below to allow duplicate names and sources. While source maps\n\t  // are intended to be compressed and deduplicated, the TypeScript compiler\n\t  // sometimes generates source maps with duplicates in them. See Github issue\n\t  // #72 and bugzil.la/889492.\n\t  this._names = ArraySet.fromArray(names.map(String), true);\n\t  this._sources = ArraySet.fromArray(sources, true);\n\t\n\t  this.sourceRoot = sourceRoot;\n\t  this.sourcesContent = sourcesContent;\n\t  this._mappings = mappings;\n\t  this.file = file;\n\t}\n\t\n\tBasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);\n\tBasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;\n\t\n\t/**\n\t * Create a BasicSourceMapConsumer from a SourceMapGenerator.\n\t *\n\t * @param SourceMapGenerator aSourceMap\n\t *        The source map that will be consumed.\n\t * @returns BasicSourceMapConsumer\n\t */\n\tBasicSourceMapConsumer.fromSourceMap =\n\t  function SourceMapConsumer_fromSourceMap(aSourceMap) {\n\t    var smc = Object.create(BasicSourceMapConsumer.prototype);\n\t\n\t    var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);\n\t    var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);\n\t    smc.sourceRoot = aSourceMap._sourceRoot;\n\t    smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),\n\t                                                            smc.sourceRoot);\n\t    smc.file = aSourceMap._file;\n\t\n\t    // Because we are modifying the entries (by converting string sources and\n\t    // names to indices into the sources and names ArraySets), we have to make\n\t    // a copy of the entry or else bad things happen. Shared mutable state\n\t    // strikes again! See github issue #191.\n\t\n\t    var generatedMappings = aSourceMap._mappings.toArray().slice();\n\t    var destGeneratedMappings = smc.__generatedMappings = [];\n\t    var destOriginalMappings = smc.__originalMappings = [];\n\t\n\t    for (var i = 0, length = generatedMappings.length; i < length; i++) {\n\t      var srcMapping = generatedMappings[i];\n\t      var destMapping = new Mapping;\n\t      destMapping.generatedLine = srcMapping.generatedLine;\n\t      destMapping.generatedColumn = srcMapping.generatedColumn;\n\t\n\t      if (srcMapping.source) {\n\t        destMapping.source = sources.indexOf(srcMapping.source);\n\t        destMapping.originalLine = srcMapping.originalLine;\n\t        destMapping.originalColumn = srcMapping.originalColumn;\n\t\n\t        if (srcMapping.name) {\n\t          destMapping.name = names.indexOf(srcMapping.name);\n\t        }\n\t\n\t        destOriginalMappings.push(destMapping);\n\t      }\n\t\n\t      destGeneratedMappings.push(destMapping);\n\t    }\n\t\n\t    quickSort(smc.__originalMappings, util.compareByOriginalPositions);\n\t\n\t    return smc;\n\t  };\n\t\n\t/**\n\t * The version of the source mapping spec that we are consuming.\n\t */\n\tBasicSourceMapConsumer.prototype._version = 3;\n\t\n\t/**\n\t * The list of original sources.\n\t */\n\tObject.defineProperty(BasicSourceMapConsumer.prototype, 'sources', {\n\t  get: function () {\n\t    return this._sources.toArray().map(function (s) {\n\t      return this.sourceRoot != null ? util.join(this.sourceRoot, s) : s;\n\t    }, this);\n\t  }\n\t});\n\t\n\t/**\n\t * Provide the JIT with a nice shape / hidden class.\n\t */\n\tfunction Mapping() {\n\t  this.generatedLine = 0;\n\t  this.generatedColumn = 0;\n\t  this.source = null;\n\t  this.originalLine = null;\n\t  this.originalColumn = null;\n\t  this.name = null;\n\t}\n\t\n\t/**\n\t * Parse the mappings in a string in to a data structure which we can easily\n\t * query (the ordered arrays in the `this.__generatedMappings` and\n\t * `this.__originalMappings` properties).\n\t */\n\tBasicSourceMapConsumer.prototype._parseMappings =\n\t  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n\t    var generatedLine = 1;\n\t    var previousGeneratedColumn = 0;\n\t    var previousOriginalLine = 0;\n\t    var previousOriginalColumn = 0;\n\t    var previousSource = 0;\n\t    var previousName = 0;\n\t    var length = aStr.length;\n\t    var index = 0;\n\t    var cachedSegments = {};\n\t    var temp = {};\n\t    var originalMappings = [];\n\t    var generatedMappings = [];\n\t    var mapping, str, segment, end, value;\n\t\n\t    while (index < length) {\n\t      if (aStr.charAt(index) === ';') {\n\t        generatedLine++;\n\t        index++;\n\t        previousGeneratedColumn = 0;\n\t      }\n\t      else if (aStr.charAt(index) === ',') {\n\t        index++;\n\t      }\n\t      else {\n\t        mapping = new Mapping();\n\t        mapping.generatedLine = generatedLine;\n\t\n\t        // Because each offset is encoded relative to the previous one,\n\t        // many segments often have the same encoding. We can exploit this\n\t        // fact by caching the parsed variable length fields of each segment,\n\t        // allowing us to avoid a second parse if we encounter the same\n\t        // segment again.\n\t        for (end = index; end < length; end++) {\n\t          if (this._charIsMappingSeparator(aStr, end)) {\n\t            break;\n\t          }\n\t        }\n\t        str = aStr.slice(index, end);\n\t\n\t        segment = cachedSegments[str];\n\t        if (segment) {\n\t          index += str.length;\n\t        } else {\n\t          segment = [];\n\t          while (index < end) {\n\t            base64VLQ.decode(aStr, index, temp);\n\t            value = temp.value;\n\t            index = temp.rest;\n\t            segment.push(value);\n\t          }\n\t\n\t          if (segment.length === 2) {\n\t            throw new Error('Found a source, but no line and column');\n\t          }\n\t\n\t          if (segment.length === 3) {\n\t            throw new Error('Found a source and line, but no column');\n\t          }\n\t\n\t          cachedSegments[str] = segment;\n\t        }\n\t\n\t        // Generated column.\n\t        mapping.generatedColumn = previousGeneratedColumn + segment[0];\n\t        previousGeneratedColumn = mapping.generatedColumn;\n\t\n\t        if (segment.length > 1) {\n\t          // Original source.\n\t          mapping.source = previousSource + segment[1];\n\t          previousSource += segment[1];\n\t\n\t          // Original line.\n\t          mapping.originalLine = previousOriginalLine + segment[2];\n\t          previousOriginalLine = mapping.originalLine;\n\t          // Lines are stored 0-based\n\t          mapping.originalLine += 1;\n\t\n\t          // Original column.\n\t          mapping.originalColumn = previousOriginalColumn + segment[3];\n\t          previousOriginalColumn = mapping.originalColumn;\n\t\n\t          if (segment.length > 4) {\n\t            // Original name.\n\t            mapping.name = previousName + segment[4];\n\t            previousName += segment[4];\n\t          }\n\t        }\n\t\n\t        generatedMappings.push(mapping);\n\t        if (typeof mapping.originalLine === 'number') {\n\t          originalMappings.push(mapping);\n\t        }\n\t      }\n\t    }\n\t\n\t    quickSort(generatedMappings, util.compareByGeneratedPositionsDeflated);\n\t    this.__generatedMappings = generatedMappings;\n\t\n\t    quickSort(originalMappings, util.compareByOriginalPositions);\n\t    this.__originalMappings = originalMappings;\n\t  };\n\t\n\t/**\n\t * Find the mapping that best matches the hypothetical \"needle\" mapping that\n\t * we are searching for in the given \"haystack\" of mappings.\n\t */\n\tBasicSourceMapConsumer.prototype._findMapping =\n\t  function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,\n\t                                         aColumnName, aComparator, aBias) {\n\t    // To return the position we are searching for, we must first find the\n\t    // mapping for the given position and then return the opposite position it\n\t    // points to. Because the mappings are sorted, we can use binary search to\n\t    // find the best mapping.\n\t\n\t    if (aNeedle[aLineName] <= 0) {\n\t      throw new TypeError('Line must be greater than or equal to 1, got '\n\t                          + aNeedle[aLineName]);\n\t    }\n\t    if (aNeedle[aColumnName] < 0) {\n\t      throw new TypeError('Column must be greater than or equal to 0, got '\n\t                          + aNeedle[aColumnName]);\n\t    }\n\t\n\t    return binarySearch.search(aNeedle, aMappings, aComparator, aBias);\n\t  };\n\t\n\t/**\n\t * Compute the last column for each generated mapping. The last column is\n\t * inclusive.\n\t */\n\tBasicSourceMapConsumer.prototype.computeColumnSpans =\n\t  function SourceMapConsumer_computeColumnSpans() {\n\t    for (var index = 0; index < this._generatedMappings.length; ++index) {\n\t      var mapping = this._generatedMappings[index];\n\t\n\t      // Mappings do not contain a field for the last generated columnt. We\n\t      // can come up with an optimistic estimate, however, by assuming that\n\t      // mappings are contiguous (i.e. given two consecutive mappings, the\n\t      // first mapping ends where the second one starts).\n\t      if (index + 1 < this._generatedMappings.length) {\n\t        var nextMapping = this._generatedMappings[index + 1];\n\t\n\t        if (mapping.generatedLine === nextMapping.generatedLine) {\n\t          mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;\n\t          continue;\n\t        }\n\t      }\n\t\n\t      // The last mapping for each line spans the entire line.\n\t      mapping.lastGeneratedColumn = Infinity;\n\t    }\n\t  };\n\t\n\t/**\n\t * Returns the original source, line, and column information for the generated\n\t * source's line and column positions provided. The only argument is an object\n\t * with the following properties:\n\t *\n\t *   - line: The line number in the generated source.\n\t *   - column: The column number in the generated source.\n\t *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or\n\t *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the\n\t *     closest element that is smaller than or greater than the one we are\n\t *     searching for, respectively, if the exact element cannot be found.\n\t *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.\n\t *\n\t * and an object is returned with the following properties:\n\t *\n\t *   - source: The original source file, or null.\n\t *   - line: The line number in the original source, or null.\n\t *   - column: The column number in the original source, or null.\n\t *   - name: The original identifier, or null.\n\t */\n\tBasicSourceMapConsumer.prototype.originalPositionFor =\n\t  function SourceMapConsumer_originalPositionFor(aArgs) {\n\t    var needle = {\n\t      generatedLine: util.getArg(aArgs, 'line'),\n\t      generatedColumn: util.getArg(aArgs, 'column')\n\t    };\n\t\n\t    var index = this._findMapping(\n\t      needle,\n\t      this._generatedMappings,\n\t      \"generatedLine\",\n\t      \"generatedColumn\",\n\t      util.compareByGeneratedPositionsDeflated,\n\t      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)\n\t    );\n\t\n\t    if (index >= 0) {\n\t      var mapping = this._generatedMappings[index];\n\t\n\t      if (mapping.generatedLine === needle.generatedLine) {\n\t        var source = util.getArg(mapping, 'source', null);\n\t        if (source !== null) {\n\t          source = this._sources.at(source);\n\t          if (this.sourceRoot != null) {\n\t            source = util.join(this.sourceRoot, source);\n\t          }\n\t        }\n\t        var name = util.getArg(mapping, 'name', null);\n\t        if (name !== null) {\n\t          name = this._names.at(name);\n\t        }\n\t        return {\n\t          source: source,\n\t          line: util.getArg(mapping, 'originalLine', null),\n\t          column: util.getArg(mapping, 'originalColumn', null),\n\t          name: name\n\t        };\n\t      }\n\t    }\n\t\n\t    return {\n\t      source: null,\n\t      line: null,\n\t      column: null,\n\t      name: null\n\t    };\n\t  };\n\t\n\t/**\n\t * Return true if we have the source content for every source in the source\n\t * map, false otherwise.\n\t */\n\tBasicSourceMapConsumer.prototype.hasContentsOfAllSources =\n\t  function BasicSourceMapConsumer_hasContentsOfAllSources() {\n\t    if (!this.sourcesContent) {\n\t      return false;\n\t    }\n\t    return this.sourcesContent.length >= this._sources.size() &&\n\t      !this.sourcesContent.some(function (sc) { return sc == null; });\n\t  };\n\t\n\t/**\n\t * Returns the original source content. The only argument is the url of the\n\t * original source file. Returns null if no original source content is\n\t * available.\n\t */\n\tBasicSourceMapConsumer.prototype.sourceContentFor =\n\t  function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {\n\t    if (!this.sourcesContent) {\n\t      return null;\n\t    }\n\t\n\t    if (this.sourceRoot != null) {\n\t      aSource = util.relative(this.sourceRoot, aSource);\n\t    }\n\t\n\t    if (this._sources.has(aSource)) {\n\t      return this.sourcesContent[this._sources.indexOf(aSource)];\n\t    }\n\t\n\t    var url;\n\t    if (this.sourceRoot != null\n\t        && (url = util.urlParse(this.sourceRoot))) {\n\t      // XXX: file:// URIs and absolute paths lead to unexpected behavior for\n\t      // many users. We can help them out when they expect file:// URIs to\n\t      // behave like it would if they were running a local HTTP server. See\n\t      // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.\n\t      var fileUriAbsPath = aSource.replace(/^file:\\/\\//, \"\");\n\t      if (url.scheme == \"file\"\n\t          && this._sources.has(fileUriAbsPath)) {\n\t        return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]\n\t      }\n\t\n\t      if ((!url.path || url.path == \"/\")\n\t          && this._sources.has(\"/\" + aSource)) {\n\t        return this.sourcesContent[this._sources.indexOf(\"/\" + aSource)];\n\t      }\n\t    }\n\t\n\t    // This function is used recursively from\n\t    // IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we\n\t    // don't want to throw if we can't find the source - we just want to\n\t    // return null, so we provide a flag to exit gracefully.\n\t    if (nullOnMissing) {\n\t      return null;\n\t    }\n\t    else {\n\t      throw new Error('\"' + aSource + '\" is not in the SourceMap.');\n\t    }\n\t  };\n\t\n\t/**\n\t * Returns the generated line and column information for the original source,\n\t * line, and column positions provided. The only argument is an object with\n\t * the following properties:\n\t *\n\t *   - source: The filename of the original source.\n\t *   - line: The line number in the original source.\n\t *   - column: The column number in the original source.\n\t *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or\n\t *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the\n\t *     closest element that is smaller than or greater than the one we are\n\t *     searching for, respectively, if the exact element cannot be found.\n\t *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.\n\t *\n\t * and an object is returned with the following properties:\n\t *\n\t *   - line: The line number in the generated source, or null.\n\t *   - column: The column number in the generated source, or null.\n\t */\n\tBasicSourceMapConsumer.prototype.generatedPositionFor =\n\t  function SourceMapConsumer_generatedPositionFor(aArgs) {\n\t    var source = util.getArg(aArgs, 'source');\n\t    if (this.sourceRoot != null) {\n\t      source = util.relative(this.sourceRoot, source);\n\t    }\n\t    if (!this._sources.has(source)) {\n\t      return {\n\t        line: null,\n\t        column: null,\n\t        lastColumn: null\n\t      };\n\t    }\n\t    source = this._sources.indexOf(source);\n\t\n\t    var needle = {\n\t      source: source,\n\t      originalLine: util.getArg(aArgs, 'line'),\n\t      originalColumn: util.getArg(aArgs, 'column')\n\t    };\n\t\n\t    var index = this._findMapping(\n\t      needle,\n\t      this._originalMappings,\n\t      \"originalLine\",\n\t      \"originalColumn\",\n\t      util.compareByOriginalPositions,\n\t      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)\n\t    );\n\t\n\t    if (index >= 0) {\n\t      var mapping = this._originalMappings[index];\n\t\n\t      if (mapping.source === needle.source) {\n\t        return {\n\t          line: util.getArg(mapping, 'generatedLine', null),\n\t          column: util.getArg(mapping, 'generatedColumn', null),\n\t          lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n\t        };\n\t      }\n\t    }\n\t\n\t    return {\n\t      line: null,\n\t      column: null,\n\t      lastColumn: null\n\t    };\n\t  };\n\t\n\texports.BasicSourceMapConsumer = BasicSourceMapConsumer;\n\t\n\t/**\n\t * An IndexedSourceMapConsumer instance represents a parsed source map which\n\t * we can query for information. It differs from BasicSourceMapConsumer in\n\t * that it takes \"indexed\" source maps (i.e. ones with a \"sections\" field) as\n\t * input.\n\t *\n\t * The only parameter is a raw source map (either as a JSON string, or already\n\t * parsed to an object). According to the spec for indexed source maps, they\n\t * have the following attributes:\n\t *\n\t *   - version: Which version of the source map spec this map is following.\n\t *   - file: Optional. The generated file this source map is associated with.\n\t *   - sections: A list of section definitions.\n\t *\n\t * Each value under the \"sections\" field has two fields:\n\t *   - offset: The offset into the original specified at which this section\n\t *       begins to apply, defined as an object with a \"line\" and \"column\"\n\t *       field.\n\t *   - map: A source map definition. This source map could also be indexed,\n\t *       but doesn't have to be.\n\t *\n\t * Instead of the \"map\" field, it's also possible to have a \"url\" field\n\t * specifying a URL to retrieve a source map from, but that's currently\n\t * unsupported.\n\t *\n\t * Here's an example source map, taken from the source map spec[0], but\n\t * modified to omit a section which uses the \"url\" field.\n\t *\n\t *  {\n\t *    version : 3,\n\t *    file: \"app.js\",\n\t *    sections: [{\n\t *      offset: {line:100, column:10},\n\t *      map: {\n\t *        version : 3,\n\t *        file: \"section.js\",\n\t *        sources: [\"foo.js\", \"bar.js\"],\n\t *        names: [\"src\", \"maps\", \"are\", \"fun\"],\n\t *        mappings: \"AAAA,E;;ABCDE;\"\n\t *      }\n\t *    }],\n\t *  }\n\t *\n\t * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt\n\t */\n\tfunction IndexedSourceMapConsumer(aSourceMap) {\n\t  var sourceMap = aSourceMap;\n\t  if (typeof aSourceMap === 'string') {\n\t    sourceMap = JSON.parse(aSourceMap.replace(/^\\)\\]\\}'/, ''));\n\t  }\n\t\n\t  var version = util.getArg(sourceMap, 'version');\n\t  var sections = util.getArg(sourceMap, 'sections');\n\t\n\t  if (version != this._version) {\n\t    throw new Error('Unsupported version: ' + version);\n\t  }\n\t\n\t  this._sources = new ArraySet();\n\t  this._names = new ArraySet();\n\t\n\t  var lastOffset = {\n\t    line: -1,\n\t    column: 0\n\t  };\n\t  this._sections = sections.map(function (s) {\n\t    if (s.url) {\n\t      // The url field will require support for asynchronicity.\n\t      // See https://github.com/mozilla/source-map/issues/16\n\t      throw new Error('Support for url field in sections not implemented.');\n\t    }\n\t    var offset = util.getArg(s, 'offset');\n\t    var offsetLine = util.getArg(offset, 'line');\n\t    var offsetColumn = util.getArg(offset, 'column');\n\t\n\t    if (offsetLine < lastOffset.line ||\n\t        (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {\n\t      throw new Error('Section offsets must be ordered and non-overlapping.');\n\t    }\n\t    lastOffset = offset;\n\t\n\t    return {\n\t      generatedOffset: {\n\t        // The offset fields are 0-based, but we use 1-based indices when\n\t        // encoding/decoding from VLQ.\n\t        generatedLine: offsetLine + 1,\n\t        generatedColumn: offsetColumn + 1\n\t      },\n\t      consumer: new SourceMapConsumer(util.getArg(s, 'map'))\n\t    }\n\t  });\n\t}\n\t\n\tIndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);\n\tIndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;\n\t\n\t/**\n\t * The version of the source mapping spec that we are consuming.\n\t */\n\tIndexedSourceMapConsumer.prototype._version = 3;\n\t\n\t/**\n\t * The list of original sources.\n\t */\n\tObject.defineProperty(IndexedSourceMapConsumer.prototype, 'sources', {\n\t  get: function () {\n\t    var sources = [];\n\t    for (var i = 0; i < this._sections.length; i++) {\n\t      for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {\n\t        sources.push(this._sections[i].consumer.sources[j]);\n\t      }\n\t    }\n\t    return sources;\n\t  }\n\t});\n\t\n\t/**\n\t * Returns the original source, line, and column information for the generated\n\t * source's line and column positions provided. The only argument is an object\n\t * with the following properties:\n\t *\n\t *   - line: The line number in the generated source.\n\t *   - column: The column number in the generated source.\n\t *\n\t * and an object is returned with the following properties:\n\t *\n\t *   - source: The original source file, or null.\n\t *   - line: The line number in the original source, or null.\n\t *   - column: The column number in the original source, or null.\n\t *   - name: The original identifier, or null.\n\t */\n\tIndexedSourceMapConsumer.prototype.originalPositionFor =\n\t  function IndexedSourceMapConsumer_originalPositionFor(aArgs) {\n\t    var needle = {\n\t      generatedLine: util.getArg(aArgs, 'line'),\n\t      generatedColumn: util.getArg(aArgs, 'column')\n\t    };\n\t\n\t    // Find the section containing the generated position we're trying to map\n\t    // to an original position.\n\t    var sectionIndex = binarySearch.search(needle, this._sections,\n\t      function(needle, section) {\n\t        var cmp = needle.generatedLine - section.generatedOffset.generatedLine;\n\t        if (cmp) {\n\t          return cmp;\n\t        }\n\t\n\t        return (needle.generatedColumn -\n\t                section.generatedOffset.generatedColumn);\n\t      });\n\t    var section = this._sections[sectionIndex];\n\t\n\t    if (!section) {\n\t      return {\n\t        source: null,\n\t        line: null,\n\t        column: null,\n\t        name: null\n\t      };\n\t    }\n\t\n\t    return section.consumer.originalPositionFor({\n\t      line: needle.generatedLine -\n\t        (section.generatedOffset.generatedLine - 1),\n\t      column: needle.generatedColumn -\n\t        (section.generatedOffset.generatedLine === needle.generatedLine\n\t         ? section.generatedOffset.generatedColumn - 1\n\t         : 0),\n\t      bias: aArgs.bias\n\t    });\n\t  };\n\t\n\t/**\n\t * Return true if we have the source content for every source in the source\n\t * map, false otherwise.\n\t */\n\tIndexedSourceMapConsumer.prototype.hasContentsOfAllSources =\n\t  function IndexedSourceMapConsumer_hasContentsOfAllSources() {\n\t    return this._sections.every(function (s) {\n\t      return s.consumer.hasContentsOfAllSources();\n\t    });\n\t  };\n\t\n\t/**\n\t * Returns the original source content. The only argument is the url of the\n\t * original source file. Returns null if no original source content is\n\t * available.\n\t */\n\tIndexedSourceMapConsumer.prototype.sourceContentFor =\n\t  function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {\n\t    for (var i = 0; i < this._sections.length; i++) {\n\t      var section = this._sections[i];\n\t\n\t      var content = section.consumer.sourceContentFor(aSource, true);\n\t      if (content) {\n\t        return content;\n\t      }\n\t    }\n\t    if (nullOnMissing) {\n\t      return null;\n\t    }\n\t    else {\n\t      throw new Error('\"' + aSource + '\" is not in the SourceMap.');\n\t    }\n\t  };\n\t\n\t/**\n\t * Returns the generated line and column information for the original source,\n\t * line, and column positions provided. The only argument is an object with\n\t * the following properties:\n\t *\n\t *   - source: The filename of the original source.\n\t *   - line: The line number in the original source.\n\t *   - column: The column number in the original source.\n\t *\n\t * and an object is returned with the following properties:\n\t *\n\t *   - line: The line number in the generated source, or null.\n\t *   - column: The column number in the generated source, or null.\n\t */\n\tIndexedSourceMapConsumer.prototype.generatedPositionFor =\n\t  function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {\n\t    for (var i = 0; i < this._sections.length; i++) {\n\t      var section = this._sections[i];\n\t\n\t      // Only consider this section if the requested source is in the list of\n\t      // sources of the consumer.\n\t      if (section.consumer.sources.indexOf(util.getArg(aArgs, 'source')) === -1) {\n\t        continue;\n\t      }\n\t      var generatedPosition = section.consumer.generatedPositionFor(aArgs);\n\t      if (generatedPosition) {\n\t        var ret = {\n\t          line: generatedPosition.line +\n\t            (section.generatedOffset.generatedLine - 1),\n\t          column: generatedPosition.column +\n\t            (section.generatedOffset.generatedLine === generatedPosition.line\n\t             ? section.generatedOffset.generatedColumn - 1\n\t             : 0)\n\t        };\n\t        return ret;\n\t      }\n\t    }\n\t\n\t    return {\n\t      line: null,\n\t      column: null\n\t    };\n\t  };\n\t\n\t/**\n\t * Parse the mappings in a string in to a data structure which we can easily\n\t * query (the ordered arrays in the `this.__generatedMappings` and\n\t * `this.__originalMappings` properties).\n\t */\n\tIndexedSourceMapConsumer.prototype._parseMappings =\n\t  function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n\t    this.__generatedMappings = [];\n\t    this.__originalMappings = [];\n\t    for (var i = 0; i < this._sections.length; i++) {\n\t      var section = this._sections[i];\n\t      var sectionMappings = section.consumer._generatedMappings;\n\t      for (var j = 0; j < sectionMappings.length; j++) {\n\t        var mapping = sectionMappings[j];\n\t\n\t        var source = section.consumer._sources.at(mapping.source);\n\t        if (section.consumer.sourceRoot !== null) {\n\t          source = util.join(section.consumer.sourceRoot, source);\n\t        }\n\t        this._sources.add(source);\n\t        source = this._sources.indexOf(source);\n\t\n\t        var name = section.consumer._names.at(mapping.name);\n\t        this._names.add(name);\n\t        name = this._names.indexOf(name);\n\t\n\t        // The mappings coming from the consumer for the section have\n\t        // generated positions relative to the start of the section, so we\n\t        // need to offset them to be relative to the start of the concatenated\n\t        // generated file.\n\t        var adjustedMapping = {\n\t          source: source,\n\t          generatedLine: mapping.generatedLine +\n\t            (section.generatedOffset.generatedLine - 1),\n\t          generatedColumn: mapping.generatedColumn +\n\t            (section.generatedOffset.generatedLine === mapping.generatedLine\n\t            ? section.generatedOffset.generatedColumn - 1\n\t            : 0),\n\t          originalLine: mapping.originalLine,\n\t          originalColumn: mapping.originalColumn,\n\t          name: name\n\t        };\n\t\n\t        this.__generatedMappings.push(adjustedMapping);\n\t        if (typeof adjustedMapping.originalLine === 'number') {\n\t          this.__originalMappings.push(adjustedMapping);\n\t        }\n\t      }\n\t    }\n\t\n\t    quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);\n\t    quickSort(this.__originalMappings, util.compareByOriginalPositions);\n\t  };\n\t\n\texports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;\n\n\n/***/ }),\n/* 8 */\n/***/ (function(module, exports) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\t\n\texports.GREATEST_LOWER_BOUND = 1;\n\texports.LEAST_UPPER_BOUND = 2;\n\t\n\t/**\n\t * Recursive implementation of binary search.\n\t *\n\t * @param aLow Indices here and lower do not contain the needle.\n\t * @param aHigh Indices here and higher do not contain the needle.\n\t * @param aNeedle The element being searched for.\n\t * @param aHaystack The non-empty array being searched.\n\t * @param aCompare Function which takes two elements and returns -1, 0, or 1.\n\t * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or\n\t *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the\n\t *     closest element that is smaller than or greater than the one we are\n\t *     searching for, respectively, if the exact element cannot be found.\n\t */\n\tfunction recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {\n\t  // This function terminates when one of the following is true:\n\t  //\n\t  //   1. We find the exact element we are looking for.\n\t  //\n\t  //   2. We did not find the exact element, but we can return the index of\n\t  //      the next-closest element.\n\t  //\n\t  //   3. We did not find the exact element, and there is no next-closest\n\t  //      element than the one we are searching for, so we return -1.\n\t  var mid = Math.floor((aHigh - aLow) / 2) + aLow;\n\t  var cmp = aCompare(aNeedle, aHaystack[mid], true);\n\t  if (cmp === 0) {\n\t    // Found the element we are looking for.\n\t    return mid;\n\t  }\n\t  else if (cmp > 0) {\n\t    // Our needle is greater than aHaystack[mid].\n\t    if (aHigh - mid > 1) {\n\t      // The element is in the upper half.\n\t      return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);\n\t    }\n\t\n\t    // The exact needle element was not found in this haystack. Determine if\n\t    // we are in termination case (3) or (2) and return the appropriate thing.\n\t    if (aBias == exports.LEAST_UPPER_BOUND) {\n\t      return aHigh < aHaystack.length ? aHigh : -1;\n\t    } else {\n\t      return mid;\n\t    }\n\t  }\n\t  else {\n\t    // Our needle is less than aHaystack[mid].\n\t    if (mid - aLow > 1) {\n\t      // The element is in the lower half.\n\t      return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);\n\t    }\n\t\n\t    // we are in termination case (3) or (2) and return the appropriate thing.\n\t    if (aBias == exports.LEAST_UPPER_BOUND) {\n\t      return mid;\n\t    } else {\n\t      return aLow < 0 ? -1 : aLow;\n\t    }\n\t  }\n\t}\n\t\n\t/**\n\t * This is an implementation of binary search which will always try and return\n\t * the index of the closest element if there is no exact hit. This is because\n\t * mappings between original and generated line/col pairs are single points,\n\t * and there is an implicit region between each of them, so a miss just means\n\t * that you aren't on the very start of a region.\n\t *\n\t * @param aNeedle The element you are looking for.\n\t * @param aHaystack The array that is being searched.\n\t * @param aCompare A function which takes the needle and an element in the\n\t *     array and returns -1, 0, or 1 depending on whether the needle is less\n\t *     than, equal to, or greater than the element, respectively.\n\t * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or\n\t *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the\n\t *     closest element that is smaller than or greater than the one we are\n\t *     searching for, respectively, if the exact element cannot be found.\n\t *     Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.\n\t */\n\texports.search = function search(aNeedle, aHaystack, aCompare, aBias) {\n\t  if (aHaystack.length === 0) {\n\t    return -1;\n\t  }\n\t\n\t  var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack,\n\t                              aCompare, aBias || exports.GREATEST_LOWER_BOUND);\n\t  if (index < 0) {\n\t    return -1;\n\t  }\n\t\n\t  // We have found either the exact element, or the next-closest element than\n\t  // the one we are searching for. However, there may be more than one such\n\t  // element. Make sure we always return the smallest of these.\n\t  while (index - 1 >= 0) {\n\t    if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {\n\t      break;\n\t    }\n\t    --index;\n\t  }\n\t\n\t  return index;\n\t};\n\n\n/***/ }),\n/* 9 */\n/***/ (function(module, exports) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\t\n\t// It turns out that some (most?) JavaScript engines don't self-host\n\t// `Array.prototype.sort`. This makes sense because C++ will likely remain\n\t// faster than JS when doing raw CPU-intensive sorting. However, when using a\n\t// custom comparator function, calling back and forth between the VM's C++ and\n\t// JIT'd JS is rather slow *and* loses JIT type information, resulting in\n\t// worse generated code for the comparator function than would be optimal. In\n\t// fact, when sorting with a comparator, these costs outweigh the benefits of\n\t// sorting in C++. By using our own JS-implemented Quick Sort (below), we get\n\t// a ~3500ms mean speed-up in `bench/bench.html`.\n\t\n\t/**\n\t * Swap the elements indexed by `x` and `y` in the array `ary`.\n\t *\n\t * @param {Array} ary\n\t *        The array.\n\t * @param {Number} x\n\t *        The index of the first item.\n\t * @param {Number} y\n\t *        The index of the second item.\n\t */\n\tfunction swap(ary, x, y) {\n\t  var temp = ary[x];\n\t  ary[x] = ary[y];\n\t  ary[y] = temp;\n\t}\n\t\n\t/**\n\t * Returns a random integer within the range `low .. high` inclusive.\n\t *\n\t * @param {Number} low\n\t *        The lower bound on the range.\n\t * @param {Number} high\n\t *        The upper bound on the range.\n\t */\n\tfunction randomIntInRange(low, high) {\n\t  return Math.round(low + (Math.random() * (high - low)));\n\t}\n\t\n\t/**\n\t * The Quick Sort algorithm.\n\t *\n\t * @param {Array} ary\n\t *        An array to sort.\n\t * @param {function} comparator\n\t *        Function to use to compare two items.\n\t * @param {Number} p\n\t *        Start index of the array\n\t * @param {Number} r\n\t *        End index of the array\n\t */\n\tfunction doQuickSort(ary, comparator, p, r) {\n\t  // If our lower bound is less than our upper bound, we (1) partition the\n\t  // array into two pieces and (2) recurse on each half. If it is not, this is\n\t  // the empty array and our base case.\n\t\n\t  if (p < r) {\n\t    // (1) Partitioning.\n\t    //\n\t    // The partitioning chooses a pivot between `p` and `r` and moves all\n\t    // elements that are less than or equal to the pivot to the before it, and\n\t    // all the elements that are greater than it after it. The effect is that\n\t    // once partition is done, the pivot is in the exact place it will be when\n\t    // the array is put in sorted order, and it will not need to be moved\n\t    // again. This runs in O(n) time.\n\t\n\t    // Always choose a random pivot so that an input array which is reverse\n\t    // sorted does not cause O(n^2) running time.\n\t    var pivotIndex = randomIntInRange(p, r);\n\t    var i = p - 1;\n\t\n\t    swap(ary, pivotIndex, r);\n\t    var pivot = ary[r];\n\t\n\t    // Immediately after `j` is incremented in this loop, the following hold\n\t    // true:\n\t    //\n\t    //   * Every element in `ary[p .. i]` is less than or equal to the pivot.\n\t    //\n\t    //   * Every element in `ary[i+1 .. j-1]` is greater than the pivot.\n\t    for (var j = p; j < r; j++) {\n\t      if (comparator(ary[j], pivot) <= 0) {\n\t        i += 1;\n\t        swap(ary, i, j);\n\t      }\n\t    }\n\t\n\t    swap(ary, i + 1, j);\n\t    var q = i + 1;\n\t\n\t    // (2) Recurse on each half.\n\t\n\t    doQuickSort(ary, comparator, p, q - 1);\n\t    doQuickSort(ary, comparator, q + 1, r);\n\t  }\n\t}\n\t\n\t/**\n\t * Sort the given array in-place with the given comparator function.\n\t *\n\t * @param {Array} ary\n\t *        An array to sort.\n\t * @param {function} comparator\n\t *        Function to use to compare two items.\n\t */\n\texports.quickSort = function (ary, comparator) {\n\t  doQuickSort(ary, comparator, 0, ary.length - 1);\n\t};\n\n\n/***/ }),\n/* 10 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\t\n\tvar SourceMapGenerator = __webpack_require__(1).SourceMapGenerator;\n\tvar util = __webpack_require__(4);\n\t\n\t// Matches a Windows-style `\\r\\n` newline or a `\\n` newline used by all other\n\t// operating systems these days (capturing the result).\n\tvar REGEX_NEWLINE = /(\\r?\\n)/;\n\t\n\t// Newline character code for charCodeAt() comparisons\n\tvar NEWLINE_CODE = 10;\n\t\n\t// Private symbol for identifying `SourceNode`s when multiple versions of\n\t// the source-map library are loaded. This MUST NOT CHANGE across\n\t// versions!\n\tvar isSourceNode = \"$$$isSourceNode$$$\";\n\t\n\t/**\n\t * SourceNodes provide a way to abstract over interpolating/concatenating\n\t * snippets of generated JavaScript source code while maintaining the line and\n\t * column information associated with the original source code.\n\t *\n\t * @param aLine The original line number.\n\t * @param aColumn The original column number.\n\t * @param aSource The original source's filename.\n\t * @param aChunks Optional. An array of strings which are snippets of\n\t *        generated JS, or other SourceNodes.\n\t * @param aName The original identifier.\n\t */\n\tfunction SourceNode(aLine, aColumn, aSource, aChunks, aName) {\n\t  this.children = [];\n\t  this.sourceContents = {};\n\t  this.line = aLine == null ? null : aLine;\n\t  this.column = aColumn == null ? null : aColumn;\n\t  this.source = aSource == null ? null : aSource;\n\t  this.name = aName == null ? null : aName;\n\t  this[isSourceNode] = true;\n\t  if (aChunks != null) this.add(aChunks);\n\t}\n\t\n\t/**\n\t * Creates a SourceNode from generated code and a SourceMapConsumer.\n\t *\n\t * @param aGeneratedCode The generated code\n\t * @param aSourceMapConsumer The SourceMap for the generated code\n\t * @param aRelativePath Optional. The path that relative sources in the\n\t *        SourceMapConsumer should be relative to.\n\t */\n\tSourceNode.fromStringWithSourceMap =\n\t  function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {\n\t    // The SourceNode we want to fill with the generated code\n\t    // and the SourceMap\n\t    var node = new SourceNode();\n\t\n\t    // All even indices of this array are one line of the generated code,\n\t    // while all odd indices are the newlines between two adjacent lines\n\t    // (since `REGEX_NEWLINE` captures its match).\n\t    // Processed fragments are accessed by calling `shiftNextLine`.\n\t    var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);\n\t    var remainingLinesIndex = 0;\n\t    var shiftNextLine = function() {\n\t      var lineContents = getNextLine();\n\t      // The last line of a file might not have a newline.\n\t      var newLine = getNextLine() || \"\";\n\t      return lineContents + newLine;\n\t\n\t      function getNextLine() {\n\t        return remainingLinesIndex < remainingLines.length ?\n\t            remainingLines[remainingLinesIndex++] : undefined;\n\t      }\n\t    };\n\t\n\t    // We need to remember the position of \"remainingLines\"\n\t    var lastGeneratedLine = 1, lastGeneratedColumn = 0;\n\t\n\t    // The generate SourceNodes we need a code range.\n\t    // To extract it current and last mapping is used.\n\t    // Here we store the last mapping.\n\t    var lastMapping = null;\n\t\n\t    aSourceMapConsumer.eachMapping(function (mapping) {\n\t      if (lastMapping !== null) {\n\t        // We add the code from \"lastMapping\" to \"mapping\":\n\t        // First check if there is a new line in between.\n\t        if (lastGeneratedLine < mapping.generatedLine) {\n\t          // Associate first line with \"lastMapping\"\n\t          addMappingWithCode(lastMapping, shiftNextLine());\n\t          lastGeneratedLine++;\n\t          lastGeneratedColumn = 0;\n\t          // The remaining code is added without mapping\n\t        } else {\n\t          // There is no new line in between.\n\t          // Associate the code between \"lastGeneratedColumn\" and\n\t          // \"mapping.generatedColumn\" with \"lastMapping\"\n\t          var nextLine = remainingLines[remainingLinesIndex];\n\t          var code = nextLine.substr(0, mapping.generatedColumn -\n\t                                        lastGeneratedColumn);\n\t          remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn -\n\t                                              lastGeneratedColumn);\n\t          lastGeneratedColumn = mapping.generatedColumn;\n\t          addMappingWithCode(lastMapping, code);\n\t          // No more remaining code, continue\n\t          lastMapping = mapping;\n\t          return;\n\t        }\n\t      }\n\t      // We add the generated code until the first mapping\n\t      // to the SourceNode without any mapping.\n\t      // Each line is added as separate string.\n\t      while (lastGeneratedLine < mapping.generatedLine) {\n\t        node.add(shiftNextLine());\n\t        lastGeneratedLine++;\n\t      }\n\t      if (lastGeneratedColumn < mapping.generatedColumn) {\n\t        var nextLine = remainingLines[remainingLinesIndex];\n\t        node.add(nextLine.substr(0, mapping.generatedColumn));\n\t        remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);\n\t        lastGeneratedColumn = mapping.generatedColumn;\n\t      }\n\t      lastMapping = mapping;\n\t    }, this);\n\t    // We have processed all mappings.\n\t    if (remainingLinesIndex < remainingLines.length) {\n\t      if (lastMapping) {\n\t        // Associate the remaining code in the current line with \"lastMapping\"\n\t        addMappingWithCode(lastMapping, shiftNextLine());\n\t      }\n\t      // and add the remaining lines without any mapping\n\t      node.add(remainingLines.splice(remainingLinesIndex).join(\"\"));\n\t    }\n\t\n\t    // Copy sourcesContent into SourceNode\n\t    aSourceMapConsumer.sources.forEach(function (sourceFile) {\n\t      var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n\t      if (content != null) {\n\t        if (aRelativePath != null) {\n\t          sourceFile = util.join(aRelativePath, sourceFile);\n\t        }\n\t        node.setSourceContent(sourceFile, content);\n\t      }\n\t    });\n\t\n\t    return node;\n\t\n\t    function addMappingWithCode(mapping, code) {\n\t      if (mapping === null || mapping.source === undefined) {\n\t        node.add(code);\n\t      } else {\n\t        var source = aRelativePath\n\t          ? util.join(aRelativePath, mapping.source)\n\t          : mapping.source;\n\t        node.add(new SourceNode(mapping.originalLine,\n\t                                mapping.originalColumn,\n\t                                source,\n\t                                code,\n\t                                mapping.name));\n\t      }\n\t    }\n\t  };\n\t\n\t/**\n\t * Add a chunk of generated JS to this source node.\n\t *\n\t * @param aChunk A string snippet of generated JS code, another instance of\n\t *        SourceNode, or an array where each member is one of those things.\n\t */\n\tSourceNode.prototype.add = function SourceNode_add(aChunk) {\n\t  if (Array.isArray(aChunk)) {\n\t    aChunk.forEach(function (chunk) {\n\t      this.add(chunk);\n\t    }, this);\n\t  }\n\t  else if (aChunk[isSourceNode] || typeof aChunk === \"string\") {\n\t    if (aChunk) {\n\t      this.children.push(aChunk);\n\t    }\n\t  }\n\t  else {\n\t    throw new TypeError(\n\t      \"Expected a SourceNode, string, or an array of SourceNodes and strings. Got \" + aChunk\n\t    );\n\t  }\n\t  return this;\n\t};\n\t\n\t/**\n\t * Add a chunk of generated JS to the beginning of this source node.\n\t *\n\t * @param aChunk A string snippet of generated JS code, another instance of\n\t *        SourceNode, or an array where each member is one of those things.\n\t */\n\tSourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {\n\t  if (Array.isArray(aChunk)) {\n\t    for (var i = aChunk.length-1; i >= 0; i--) {\n\t      this.prepend(aChunk[i]);\n\t    }\n\t  }\n\t  else if (aChunk[isSourceNode] || typeof aChunk === \"string\") {\n\t    this.children.unshift(aChunk);\n\t  }\n\t  else {\n\t    throw new TypeError(\n\t      \"Expected a SourceNode, string, or an array of SourceNodes and strings. Got \" + aChunk\n\t    );\n\t  }\n\t  return this;\n\t};\n\t\n\t/**\n\t * Walk over the tree of JS snippets in this node and its children. The\n\t * walking function is called once for each snippet of JS and is passed that\n\t * snippet and the its original associated source's line/column location.\n\t *\n\t * @param aFn The traversal function.\n\t */\n\tSourceNode.prototype.walk = function SourceNode_walk(aFn) {\n\t  var chunk;\n\t  for (var i = 0, len = this.children.length; i < len; i++) {\n\t    chunk = this.children[i];\n\t    if (chunk[isSourceNode]) {\n\t      chunk.walk(aFn);\n\t    }\n\t    else {\n\t      if (chunk !== '') {\n\t        aFn(chunk, { source: this.source,\n\t                     line: this.line,\n\t                     column: this.column,\n\t                     name: this.name });\n\t      }\n\t    }\n\t  }\n\t};\n\t\n\t/**\n\t * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between\n\t * each of `this.children`.\n\t *\n\t * @param aSep The separator.\n\t */\n\tSourceNode.prototype.join = function SourceNode_join(aSep) {\n\t  var newChildren;\n\t  var i;\n\t  var len = this.children.length;\n\t  if (len > 0) {\n\t    newChildren = [];\n\t    for (i = 0; i < len-1; i++) {\n\t      newChildren.push(this.children[i]);\n\t      newChildren.push(aSep);\n\t    }\n\t    newChildren.push(this.children[i]);\n\t    this.children = newChildren;\n\t  }\n\t  return this;\n\t};\n\t\n\t/**\n\t * Call String.prototype.replace on the very right-most source snippet. Useful\n\t * for trimming whitespace from the end of a source node, etc.\n\t *\n\t * @param aPattern The pattern to replace.\n\t * @param aReplacement The thing to replace the pattern with.\n\t */\n\tSourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {\n\t  var lastChild = this.children[this.children.length - 1];\n\t  if (lastChild[isSourceNode]) {\n\t    lastChild.replaceRight(aPattern, aReplacement);\n\t  }\n\t  else if (typeof lastChild === 'string') {\n\t    this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);\n\t  }\n\t  else {\n\t    this.children.push(''.replace(aPattern, aReplacement));\n\t  }\n\t  return this;\n\t};\n\t\n\t/**\n\t * Set the source content for a source file. This will be added to the SourceMapGenerator\n\t * in the sourcesContent field.\n\t *\n\t * @param aSourceFile The filename of the source file\n\t * @param aSourceContent The content of the source file\n\t */\n\tSourceNode.prototype.setSourceContent =\n\t  function SourceNode_setSourceContent(aSourceFile, aSourceContent) {\n\t    this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;\n\t  };\n\t\n\t/**\n\t * Walk over the tree of SourceNodes. The walking function is called for each\n\t * source file content and is passed the filename and source content.\n\t *\n\t * @param aFn The traversal function.\n\t */\n\tSourceNode.prototype.walkSourceContents =\n\t  function SourceNode_walkSourceContents(aFn) {\n\t    for (var i = 0, len = this.children.length; i < len; i++) {\n\t      if (this.children[i][isSourceNode]) {\n\t        this.children[i].walkSourceContents(aFn);\n\t      }\n\t    }\n\t\n\t    var sources = Object.keys(this.sourceContents);\n\t    for (var i = 0, len = sources.length; i < len; i++) {\n\t      aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);\n\t    }\n\t  };\n\t\n\t/**\n\t * Return the string representation of this source node. Walks over the tree\n\t * and concatenates all the various snippets together to one string.\n\t */\n\tSourceNode.prototype.toString = function SourceNode_toString() {\n\t  var str = \"\";\n\t  this.walk(function (chunk) {\n\t    str += chunk;\n\t  });\n\t  return str;\n\t};\n\t\n\t/**\n\t * Returns the string representation of this source node along with a source\n\t * map.\n\t */\n\tSourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {\n\t  var generated = {\n\t    code: \"\",\n\t    line: 1,\n\t    column: 0\n\t  };\n\t  var map = new SourceMapGenerator(aArgs);\n\t  var sourceMappingActive = false;\n\t  var lastOriginalSource = null;\n\t  var lastOriginalLine = null;\n\t  var lastOriginalColumn = null;\n\t  var lastOriginalName = null;\n\t  this.walk(function (chunk, original) {\n\t    generated.code += chunk;\n\t    if (original.source !== null\n\t        && original.line !== null\n\t        && original.column !== null) {\n\t      if(lastOriginalSource !== original.source\n\t         || lastOriginalLine !== original.line\n\t         || lastOriginalColumn !== original.column\n\t         || lastOriginalName !== original.name) {\n\t        map.addMapping({\n\t          source: original.source,\n\t          original: {\n\t            line: original.line,\n\t            column: original.column\n\t          },\n\t          generated: {\n\t            line: generated.line,\n\t            column: generated.column\n\t          },\n\t          name: original.name\n\t        });\n\t      }\n\t      lastOriginalSource = original.source;\n\t      lastOriginalLine = original.line;\n\t      lastOriginalColumn = original.column;\n\t      lastOriginalName = original.name;\n\t      sourceMappingActive = true;\n\t    } else if (sourceMappingActive) {\n\t      map.addMapping({\n\t        generated: {\n\t          line: generated.line,\n\t          column: generated.column\n\t        }\n\t      });\n\t      lastOriginalSource = null;\n\t      sourceMappingActive = false;\n\t    }\n\t    for (var idx = 0, length = chunk.length; idx < length; idx++) {\n\t      if (chunk.charCodeAt(idx) === NEWLINE_CODE) {\n\t        generated.line++;\n\t        generated.column = 0;\n\t        // Mappings end at eol\n\t        if (idx + 1 === length) {\n\t          lastOriginalSource = null;\n\t          sourceMappingActive = false;\n\t        } else if (sourceMappingActive) {\n\t          map.addMapping({\n\t            source: original.source,\n\t            original: {\n\t              line: original.line,\n\t              column: original.column\n\t            },\n\t            generated: {\n\t              line: generated.line,\n\t              column: generated.column\n\t            },\n\t            name: original.name\n\t          });\n\t        }\n\t      } else {\n\t        generated.column++;\n\t      }\n\t    }\n\t  });\n\t  this.walkSourceContents(function (sourceFile, sourceContent) {\n\t    map.setSourceContent(sourceFile, sourceContent);\n\t  });\n\t\n\t  return { code: generated.code, map: map };\n\t};\n\t\n\texports.SourceNode = SourceNode;\n\n\n/***/ })\n/******/ ])\n});\n;\n\n\n// WEBPACK FOOTER //\n// source-map.min.js"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.loaded = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 42c329f865e32e011afb","/*\n * Copyright 2009-2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE.txt or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\nexports.SourceMapGenerator = require('./lib/source-map-generator').SourceMapGenerator;\nexports.SourceMapConsumer = require('./lib/source-map-consumer').SourceMapConsumer;\nexports.SourceNode = require('./lib/source-node').SourceNode;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./source-map.js\n// module id = 0\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar base64VLQ = require('./base64-vlq');\nvar util = require('./util');\nvar ArraySet = require('./array-set').ArraySet;\nvar MappingList = require('./mapping-list').MappingList;\n\n/**\n * An instance of the SourceMapGenerator represents a source map which is\n * being built incrementally. You may pass an object with the following\n * properties:\n *\n *   - file: The filename of the generated source.\n *   - sourceRoot: A root for all relative URLs in this source map.\n */\nfunction SourceMapGenerator(aArgs) {\n  if (!aArgs) {\n    aArgs = {};\n  }\n  this._file = util.getArg(aArgs, 'file', null);\n  this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);\n  this._skipValidation = util.getArg(aArgs, 'skipValidation', false);\n  this._sources = new ArraySet();\n  this._names = new ArraySet();\n  this._mappings = new MappingList();\n  this._sourcesContents = null;\n}\n\nSourceMapGenerator.prototype._version = 3;\n\n/**\n * Creates a new SourceMapGenerator based on a SourceMapConsumer\n *\n * @param aSourceMapConsumer The SourceMap.\n */\nSourceMapGenerator.fromSourceMap =\n  function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {\n    var sourceRoot = aSourceMapConsumer.sourceRoot;\n    var generator = new SourceMapGenerator({\n      file: aSourceMapConsumer.file,\n      sourceRoot: sourceRoot\n    });\n    aSourceMapConsumer.eachMapping(function (mapping) {\n      var newMapping = {\n        generated: {\n          line: mapping.generatedLine,\n          column: mapping.generatedColumn\n        }\n      };\n\n      if (mapping.source != null) {\n        newMapping.source = mapping.source;\n        if (sourceRoot != null) {\n          newMapping.source = util.relative(sourceRoot, newMapping.source);\n        }\n\n        newMapping.original = {\n          line: mapping.originalLine,\n          column: mapping.originalColumn\n        };\n\n        if (mapping.name != null) {\n          newMapping.name = mapping.name;\n        }\n      }\n\n      generator.addMapping(newMapping);\n    });\n    aSourceMapConsumer.sources.forEach(function (sourceFile) {\n      var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n      if (content != null) {\n        generator.setSourceContent(sourceFile, content);\n      }\n    });\n    return generator;\n  };\n\n/**\n * Add a single mapping from original source line and column to the generated\n * source's line and column for this source map being created. The mapping\n * object should have the following properties:\n *\n *   - generated: An object with the generated line and column positions.\n *   - original: An object with the original line and column positions.\n *   - source: The original source file (relative to the sourceRoot).\n *   - name: An optional original token name for this mapping.\n */\nSourceMapGenerator.prototype.addMapping =\n  function SourceMapGenerator_addMapping(aArgs) {\n    var generated = util.getArg(aArgs, 'generated');\n    var original = util.getArg(aArgs, 'original', null);\n    var source = util.getArg(aArgs, 'source', null);\n    var name = util.getArg(aArgs, 'name', null);\n\n    if (!this._skipValidation) {\n      this._validateMapping(generated, original, source, name);\n    }\n\n    if (source != null) {\n      source = String(source);\n      if (!this._sources.has(source)) {\n        this._sources.add(source);\n      }\n    }\n\n    if (name != null) {\n      name = String(name);\n      if (!this._names.has(name)) {\n        this._names.add(name);\n      }\n    }\n\n    this._mappings.add({\n      generatedLine: generated.line,\n      generatedColumn: generated.column,\n      originalLine: original != null && original.line,\n      originalColumn: original != null && original.column,\n      source: source,\n      name: name\n    });\n  };\n\n/**\n * Set the source content for a source file.\n */\nSourceMapGenerator.prototype.setSourceContent =\n  function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {\n    var source = aSourceFile;\n    if (this._sourceRoot != null) {\n      source = util.relative(this._sourceRoot, source);\n    }\n\n    if (aSourceContent != null) {\n      // Add the source content to the _sourcesContents map.\n      // Create a new _sourcesContents map if the property is null.\n      if (!this._sourcesContents) {\n        this._sourcesContents = Object.create(null);\n      }\n      this._sourcesContents[util.toSetString(source)] = aSourceContent;\n    } else if (this._sourcesContents) {\n      // Remove the source file from the _sourcesContents map.\n      // If the _sourcesContents map is empty, set the property to null.\n      delete this._sourcesContents[util.toSetString(source)];\n      if (Object.keys(this._sourcesContents).length === 0) {\n        this._sourcesContents = null;\n      }\n    }\n  };\n\n/**\n * Applies the mappings of a sub-source-map for a specific source file to the\n * source map being generated. Each mapping to the supplied source file is\n * rewritten using the supplied source map. Note: The resolution for the\n * resulting mappings is the minimium of this map and the supplied map.\n *\n * @param aSourceMapConsumer The source map to be applied.\n * @param aSourceFile Optional. The filename of the source file.\n *        If omitted, SourceMapConsumer's file property will be used.\n * @param aSourceMapPath Optional. The dirname of the path to the source map\n *        to be applied. If relative, it is relative to the SourceMapConsumer.\n *        This parameter is needed when the two source maps aren't in the same\n *        directory, and the source map to be applied contains relative source\n *        paths. If so, those relative source paths need to be rewritten\n *        relative to the SourceMapGenerator.\n */\nSourceMapGenerator.prototype.applySourceMap =\n  function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {\n    var sourceFile = aSourceFile;\n    // If aSourceFile is omitted, we will use the file property of the SourceMap\n    if (aSourceFile == null) {\n      if (aSourceMapConsumer.file == null) {\n        throw new Error(\n          'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +\n          'or the source map\\'s \"file\" property. Both were omitted.'\n        );\n      }\n      sourceFile = aSourceMapConsumer.file;\n    }\n    var sourceRoot = this._sourceRoot;\n    // Make \"sourceFile\" relative if an absolute Url is passed.\n    if (sourceRoot != null) {\n      sourceFile = util.relative(sourceRoot, sourceFile);\n    }\n    // Applying the SourceMap can add and remove items from the sources and\n    // the names array.\n    var newSources = new ArraySet();\n    var newNames = new ArraySet();\n\n    // Find mappings for the \"sourceFile\"\n    this._mappings.unsortedForEach(function (mapping) {\n      if (mapping.source === sourceFile && mapping.originalLine != null) {\n        // Check if it can be mapped by the source map, then update the mapping.\n        var original = aSourceMapConsumer.originalPositionFor({\n          line: mapping.originalLine,\n          column: mapping.originalColumn\n        });\n        if (original.source != null) {\n          // Copy mapping\n          mapping.source = original.source;\n          if (aSourceMapPath != null) {\n            mapping.source = util.join(aSourceMapPath, mapping.source)\n          }\n          if (sourceRoot != null) {\n            mapping.source = util.relative(sourceRoot, mapping.source);\n          }\n          mapping.originalLine = original.line;\n          mapping.originalColumn = original.column;\n          if (original.name != null) {\n            mapping.name = original.name;\n          }\n        }\n      }\n\n      var source = mapping.source;\n      if (source != null && !newSources.has(source)) {\n        newSources.add(source);\n      }\n\n      var name = mapping.name;\n      if (name != null && !newNames.has(name)) {\n        newNames.add(name);\n      }\n\n    }, this);\n    this._sources = newSources;\n    this._names = newNames;\n\n    // Copy sourcesContents of applied map.\n    aSourceMapConsumer.sources.forEach(function (sourceFile) {\n      var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n      if (content != null) {\n        if (aSourceMapPath != null) {\n          sourceFile = util.join(aSourceMapPath, sourceFile);\n        }\n        if (sourceRoot != null) {\n          sourceFile = util.relative(sourceRoot, sourceFile);\n        }\n        this.setSourceContent(sourceFile, content);\n      }\n    }, this);\n  };\n\n/**\n * A mapping can have one of the three levels of data:\n *\n *   1. Just the generated position.\n *   2. The Generated position, original position, and original source.\n *   3. Generated and original position, original source, as well as a name\n *      token.\n *\n * To maintain consistency, we validate that any new mapping being added falls\n * in to one of these categories.\n */\nSourceMapGenerator.prototype._validateMapping =\n  function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,\n                                              aName) {\n    // When aOriginal is truthy but has empty values for .line and .column,\n    // it is most likely a programmer error. In this case we throw a very\n    // specific error message to try to guide them the right way.\n    // For example: https://github.com/Polymer/polymer-bundler/pull/519\n    if (aOriginal && typeof aOriginal.line !== 'number' && typeof aOriginal.column !== 'number') {\n        throw new Error(\n            'original.line and original.column are not numbers -- you probably meant to omit ' +\n            'the original mapping entirely and only map the generated position. If so, pass ' +\n            'null for the original mapping instead of an object with empty or null values.'\n        );\n    }\n\n    if (aGenerated && 'line' in aGenerated && 'column' in aGenerated\n        && aGenerated.line > 0 && aGenerated.column >= 0\n        && !aOriginal && !aSource && !aName) {\n      // Case 1.\n      return;\n    }\n    else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated\n             && aOriginal && 'line' in aOriginal && 'column' in aOriginal\n             && aGenerated.line > 0 && aGenerated.column >= 0\n             && aOriginal.line > 0 && aOriginal.column >= 0\n             && aSource) {\n      // Cases 2 and 3.\n      return;\n    }\n    else {\n      throw new Error('Invalid mapping: ' + JSON.stringify({\n        generated: aGenerated,\n        source: aSource,\n        original: aOriginal,\n        name: aName\n      }));\n    }\n  };\n\n/**\n * Serialize the accumulated mappings in to the stream of base 64 VLQs\n * specified by the source map format.\n */\nSourceMapGenerator.prototype._serializeMappings =\n  function SourceMapGenerator_serializeMappings() {\n    var previousGeneratedColumn = 0;\n    var previousGeneratedLine = 1;\n    var previousOriginalColumn = 0;\n    var previousOriginalLine = 0;\n    var previousName = 0;\n    var previousSource = 0;\n    var result = '';\n    var next;\n    var mapping;\n    var nameIdx;\n    var sourceIdx;\n\n    var mappings = this._mappings.toArray();\n    for (var i = 0, len = mappings.length; i < len; i++) {\n      mapping = mappings[i];\n      next = ''\n\n      if (mapping.generatedLine !== previousGeneratedLine) {\n        previousGeneratedColumn = 0;\n        while (mapping.generatedLine !== previousGeneratedLine) {\n          next += ';';\n          previousGeneratedLine++;\n        }\n      }\n      else {\n        if (i > 0) {\n          if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {\n            continue;\n          }\n          next += ',';\n        }\n      }\n\n      next += base64VLQ.encode(mapping.generatedColumn\n                                 - previousGeneratedColumn);\n      previousGeneratedColumn = mapping.generatedColumn;\n\n      if (mapping.source != null) {\n        sourceIdx = this._sources.indexOf(mapping.source);\n        next += base64VLQ.encode(sourceIdx - previousSource);\n        previousSource = sourceIdx;\n\n        // lines are stored 0-based in SourceMap spec version 3\n        next += base64VLQ.encode(mapping.originalLine - 1\n                                   - previousOriginalLine);\n        previousOriginalLine = mapping.originalLine - 1;\n\n        next += base64VLQ.encode(mapping.originalColumn\n                                   - previousOriginalColumn);\n        previousOriginalColumn = mapping.originalColumn;\n\n        if (mapping.name != null) {\n          nameIdx = this._names.indexOf(mapping.name);\n          next += base64VLQ.encode(nameIdx - previousName);\n          previousName = nameIdx;\n        }\n      }\n\n      result += next;\n    }\n\n    return result;\n  };\n\nSourceMapGenerator.prototype._generateSourcesContent =\n  function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {\n    return aSources.map(function (source) {\n      if (!this._sourcesContents) {\n        return null;\n      }\n      if (aSourceRoot != null) {\n        source = util.relative(aSourceRoot, source);\n      }\n      var key = util.toSetString(source);\n      return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)\n        ? this._sourcesContents[key]\n        : null;\n    }, this);\n  };\n\n/**\n * Externalize the source map.\n */\nSourceMapGenerator.prototype.toJSON =\n  function SourceMapGenerator_toJSON() {\n    var map = {\n      version: this._version,\n      sources: this._sources.toArray(),\n      names: this._names.toArray(),\n      mappings: this._serializeMappings()\n    };\n    if (this._file != null) {\n      map.file = this._file;\n    }\n    if (this._sourceRoot != null) {\n      map.sourceRoot = this._sourceRoot;\n    }\n    if (this._sourcesContents) {\n      map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);\n    }\n\n    return map;\n  };\n\n/**\n * Render the source map being generated to a string.\n */\nSourceMapGenerator.prototype.toString =\n  function SourceMapGenerator_toString() {\n    return JSON.stringify(this.toJSON());\n  };\n\nexports.SourceMapGenerator = SourceMapGenerator;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/source-map-generator.js\n// module id = 1\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n *\n * Based on the Base 64 VLQ implementation in Closure Compiler:\n * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java\n *\n * Copyright 2011 The Closure Compiler Authors. All rights reserved.\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n *  * Redistributions of source code must retain the above copyright\n *    notice, this list of conditions and the following disclaimer.\n *  * Redistributions in binary form must reproduce the above\n *    copyright notice, this list of conditions and the following\n *    disclaimer in the documentation and/or other materials provided\n *    with the distribution.\n *  * Neither the name of Google Inc. nor the names of its\n *    contributors may be used to endorse or promote products derived\n *    from this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\nvar base64 = require('./base64');\n\n// A single base 64 digit can contain 6 bits of data. For the base 64 variable\n// length quantities we use in the source map spec, the first bit is the sign,\n// the next four bits are the actual value, and the 6th bit is the\n// continuation bit. The continuation bit tells us whether there are more\n// digits in this value following this digit.\n//\n//   Continuation\n//   |    Sign\n//   |    |\n//   V    V\n//   101011\n\nvar VLQ_BASE_SHIFT = 5;\n\n// binary: 100000\nvar VLQ_BASE = 1 << VLQ_BASE_SHIFT;\n\n// binary: 011111\nvar VLQ_BASE_MASK = VLQ_BASE - 1;\n\n// binary: 100000\nvar VLQ_CONTINUATION_BIT = VLQ_BASE;\n\n/**\n * Converts from a two-complement value to a value where the sign bit is\n * placed in the least significant bit.  For example, as decimals:\n *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)\n *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)\n */\nfunction toVLQSigned(aValue) {\n  return aValue < 0\n    ? ((-aValue) << 1) + 1\n    : (aValue << 1) + 0;\n}\n\n/**\n * Converts to a two-complement value from a value where the sign bit is\n * placed in the least significant bit.  For example, as decimals:\n *   2 (10 binary) becomes 1, 3 (11 binary) becomes -1\n *   4 (100 binary) becomes 2, 5 (101 binary) becomes -2\n */\nfunction fromVLQSigned(aValue) {\n  var isNegative = (aValue & 1) === 1;\n  var shifted = aValue >> 1;\n  return isNegative\n    ? -shifted\n    : shifted;\n}\n\n/**\n * Returns the base 64 VLQ encoded value.\n */\nexports.encode = function base64VLQ_encode(aValue) {\n  var encoded = \"\";\n  var digit;\n\n  var vlq = toVLQSigned(aValue);\n\n  do {\n    digit = vlq & VLQ_BASE_MASK;\n    vlq >>>= VLQ_BASE_SHIFT;\n    if (vlq > 0) {\n      // There are still more digits in this value, so we must make sure the\n      // continuation bit is marked.\n      digit |= VLQ_CONTINUATION_BIT;\n    }\n    encoded += base64.encode(digit);\n  } while (vlq > 0);\n\n  return encoded;\n};\n\n/**\n * Decodes the next base 64 VLQ value from the given string and returns the\n * value and the rest of the string via the out parameter.\n */\nexports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {\n  var strLen = aStr.length;\n  var result = 0;\n  var shift = 0;\n  var continuation, digit;\n\n  do {\n    if (aIndex >= strLen) {\n      throw new Error(\"Expected more digits in base 64 VLQ value.\");\n    }\n\n    digit = base64.decode(aStr.charCodeAt(aIndex++));\n    if (digit === -1) {\n      throw new Error(\"Invalid base64 digit: \" + aStr.charAt(aIndex - 1));\n    }\n\n    continuation = !!(digit & VLQ_CONTINUATION_BIT);\n    digit &= VLQ_BASE_MASK;\n    result = result + (digit << shift);\n    shift += VLQ_BASE_SHIFT;\n  } while (continuation);\n\n  aOutParam.value = fromVLQSigned(result);\n  aOutParam.rest = aIndex;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/base64-vlq.js\n// module id = 2\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar intToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');\n\n/**\n * Encode an integer in the range of 0 to 63 to a single base 64 digit.\n */\nexports.encode = function (number) {\n  if (0 <= number && number < intToCharMap.length) {\n    return intToCharMap[number];\n  }\n  throw new TypeError(\"Must be between 0 and 63: \" + number);\n};\n\n/**\n * Decode a single base 64 character code digit to an integer. Returns -1 on\n * failure.\n */\nexports.decode = function (charCode) {\n  var bigA = 65;     // 'A'\n  var bigZ = 90;     // 'Z'\n\n  var littleA = 97;  // 'a'\n  var littleZ = 122; // 'z'\n\n  var zero = 48;     // '0'\n  var nine = 57;     // '9'\n\n  var plus = 43;     // '+'\n  var slash = 47;    // '/'\n\n  var littleOffset = 26;\n  var numberOffset = 52;\n\n  // 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ\n  if (bigA <= charCode && charCode <= bigZ) {\n    return (charCode - bigA);\n  }\n\n  // 26 - 51: abcdefghijklmnopqrstuvwxyz\n  if (littleA <= charCode && charCode <= littleZ) {\n    return (charCode - littleA + littleOffset);\n  }\n\n  // 52 - 61: 0123456789\n  if (zero <= charCode && charCode <= nine) {\n    return (charCode - zero + numberOffset);\n  }\n\n  // 62: +\n  if (charCode == plus) {\n    return 62;\n  }\n\n  // 63: /\n  if (charCode == slash) {\n    return 63;\n  }\n\n  // Invalid base64 digit.\n  return -1;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/base64.js\n// module id = 3\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\n/**\n * This is a helper function for getting values from parameter/options\n * objects.\n *\n * @param args The object we are extracting values from\n * @param name The name of the property we are getting.\n * @param defaultValue An optional value to return if the property is missing\n * from the object. If this is not specified and the property is missing, an\n * error will be thrown.\n */\nfunction getArg(aArgs, aName, aDefaultValue) {\n  if (aName in aArgs) {\n    return aArgs[aName];\n  } else if (arguments.length === 3) {\n    return aDefaultValue;\n  } else {\n    throw new Error('\"' + aName + '\" is a required argument.');\n  }\n}\nexports.getArg = getArg;\n\nvar urlRegexp = /^(?:([\\w+\\-.]+):)?\\/\\/(?:(\\w+:\\w+)@)?([\\w.]*)(?::(\\d+))?(\\S*)$/;\nvar dataUrlRegexp = /^data:.+\\,.+$/;\n\nfunction urlParse(aUrl) {\n  var match = aUrl.match(urlRegexp);\n  if (!match) {\n    return null;\n  }\n  return {\n    scheme: match[1],\n    auth: match[2],\n    host: match[3],\n    port: match[4],\n    path: match[5]\n  };\n}\nexports.urlParse = urlParse;\n\nfunction urlGenerate(aParsedUrl) {\n  var url = '';\n  if (aParsedUrl.scheme) {\n    url += aParsedUrl.scheme + ':';\n  }\n  url += '//';\n  if (aParsedUrl.auth) {\n    url += aParsedUrl.auth + '@';\n  }\n  if (aParsedUrl.host) {\n    url += aParsedUrl.host;\n  }\n  if (aParsedUrl.port) {\n    url += \":\" + aParsedUrl.port\n  }\n  if (aParsedUrl.path) {\n    url += aParsedUrl.path;\n  }\n  return url;\n}\nexports.urlGenerate = urlGenerate;\n\n/**\n * Normalizes a path, or the path portion of a URL:\n *\n * - Replaces consecutive slashes with one slash.\n * - Removes unnecessary '.' parts.\n * - Removes unnecessary '<dir>/..' parts.\n *\n * Based on code in the Node.js 'path' core module.\n *\n * @param aPath The path or url to normalize.\n */\nfunction normalize(aPath) {\n  var path = aPath;\n  var url = urlParse(aPath);\n  if (url) {\n    if (!url.path) {\n      return aPath;\n    }\n    path = url.path;\n  }\n  var isAbsolute = exports.isAbsolute(path);\n\n  var parts = path.split(/\\/+/);\n  for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {\n    part = parts[i];\n    if (part === '.') {\n      parts.splice(i, 1);\n    } else if (part === '..') {\n      up++;\n    } else if (up > 0) {\n      if (part === '') {\n        // The first part is blank if the path is absolute. Trying to go\n        // above the root is a no-op. Therefore we can remove all '..' parts\n        // directly after the root.\n        parts.splice(i + 1, up);\n        up = 0;\n      } else {\n        parts.splice(i, 2);\n        up--;\n      }\n    }\n  }\n  path = parts.join('/');\n\n  if (path === '') {\n    path = isAbsolute ? '/' : '.';\n  }\n\n  if (url) {\n    url.path = path;\n    return urlGenerate(url);\n  }\n  return path;\n}\nexports.normalize = normalize;\n\n/**\n * Joins two paths/URLs.\n *\n * @param aRoot The root path or URL.\n * @param aPath The path or URL to be joined with the root.\n *\n * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a\n *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended\n *   first.\n * - Otherwise aPath is a path. If aRoot is a URL, then its path portion\n *   is updated with the result and aRoot is returned. Otherwise the result\n *   is returned.\n *   - If aPath is absolute, the result is aPath.\n *   - Otherwise the two paths are joined with a slash.\n * - Joining for example 'http://' and 'www.example.com' is also supported.\n */\nfunction join(aRoot, aPath) {\n  if (aRoot === \"\") {\n    aRoot = \".\";\n  }\n  if (aPath === \"\") {\n    aPath = \".\";\n  }\n  var aPathUrl = urlParse(aPath);\n  var aRootUrl = urlParse(aRoot);\n  if (aRootUrl) {\n    aRoot = aRootUrl.path || '/';\n  }\n\n  // `join(foo, '//www.example.org')`\n  if (aPathUrl && !aPathUrl.scheme) {\n    if (aRootUrl) {\n      aPathUrl.scheme = aRootUrl.scheme;\n    }\n    return urlGenerate(aPathUrl);\n  }\n\n  if (aPathUrl || aPath.match(dataUrlRegexp)) {\n    return aPath;\n  }\n\n  // `join('http://', 'www.example.com')`\n  if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {\n    aRootUrl.host = aPath;\n    return urlGenerate(aRootUrl);\n  }\n\n  var joined = aPath.charAt(0) === '/'\n    ? aPath\n    : normalize(aRoot.replace(/\\/+$/, '') + '/' + aPath);\n\n  if (aRootUrl) {\n    aRootUrl.path = joined;\n    return urlGenerate(aRootUrl);\n  }\n  return joined;\n}\nexports.join = join;\n\nexports.isAbsolute = function (aPath) {\n  return aPath.charAt(0) === '/' || !!aPath.match(urlRegexp);\n};\n\n/**\n * Make a path relative to a URL or another path.\n *\n * @param aRoot The root path or URL.\n * @param aPath The path or URL to be made relative to aRoot.\n */\nfunction relative(aRoot, aPath) {\n  if (aRoot === \"\") {\n    aRoot = \".\";\n  }\n\n  aRoot = aRoot.replace(/\\/$/, '');\n\n  // It is possible for the path to be above the root. In this case, simply\n  // checking whether the root is a prefix of the path won't work. Instead, we\n  // need to remove components from the root one by one, until either we find\n  // a prefix that fits, or we run out of components to remove.\n  var level = 0;\n  while (aPath.indexOf(aRoot + '/') !== 0) {\n    var index = aRoot.lastIndexOf(\"/\");\n    if (index < 0) {\n      return aPath;\n    }\n\n    // If the only part of the root that is left is the scheme (i.e. http://,\n    // file:///, etc.), one or more slashes (/), or simply nothing at all, we\n    // have exhausted all components, so the path is not relative to the root.\n    aRoot = aRoot.slice(0, index);\n    if (aRoot.match(/^([^\\/]+:\\/)?\\/*$/)) {\n      return aPath;\n    }\n\n    ++level;\n  }\n\n  // Make sure we add a \"../\" for each component we removed from the root.\n  return Array(level + 1).join(\"../\") + aPath.substr(aRoot.length + 1);\n}\nexports.relative = relative;\n\nvar supportsNullProto = (function () {\n  var obj = Object.create(null);\n  return !('__proto__' in obj);\n}());\n\nfunction identity (s) {\n  return s;\n}\n\n/**\n * Because behavior goes wacky when you set `__proto__` on objects, we\n * have to prefix all the strings in our set with an arbitrary character.\n *\n * See https://github.com/mozilla/source-map/pull/31 and\n * https://github.com/mozilla/source-map/issues/30\n *\n * @param String aStr\n */\nfunction toSetString(aStr) {\n  if (isProtoString(aStr)) {\n    return '$' + aStr;\n  }\n\n  return aStr;\n}\nexports.toSetString = supportsNullProto ? identity : toSetString;\n\nfunction fromSetString(aStr) {\n  if (isProtoString(aStr)) {\n    return aStr.slice(1);\n  }\n\n  return aStr;\n}\nexports.fromSetString = supportsNullProto ? identity : fromSetString;\n\nfunction isProtoString(s) {\n  if (!s) {\n    return false;\n  }\n\n  var length = s.length;\n\n  if (length < 9 /* \"__proto__\".length */) {\n    return false;\n  }\n\n  if (s.charCodeAt(length - 1) !== 95  /* '_' */ ||\n      s.charCodeAt(length - 2) !== 95  /* '_' */ ||\n      s.charCodeAt(length - 3) !== 111 /* 'o' */ ||\n      s.charCodeAt(length - 4) !== 116 /* 't' */ ||\n      s.charCodeAt(length - 5) !== 111 /* 'o' */ ||\n      s.charCodeAt(length - 6) !== 114 /* 'r' */ ||\n      s.charCodeAt(length - 7) !== 112 /* 'p' */ ||\n      s.charCodeAt(length - 8) !== 95  /* '_' */ ||\n      s.charCodeAt(length - 9) !== 95  /* '_' */) {\n    return false;\n  }\n\n  for (var i = length - 10; i >= 0; i--) {\n    if (s.charCodeAt(i) !== 36 /* '$' */) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Comparator between two mappings where the original positions are compared.\n *\n * Optionally pass in `true` as `onlyCompareGenerated` to consider two\n * mappings with the same original source/line/column, but different generated\n * line and column the same. Useful when searching for a mapping with a\n * stubbed out mapping.\n */\nfunction compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {\n  var cmp = mappingA.source - mappingB.source;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalLine - mappingB.originalLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalColumn - mappingB.originalColumn;\n  if (cmp !== 0 || onlyCompareOriginal) {\n    return cmp;\n  }\n\n  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.generatedLine - mappingB.generatedLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  return mappingA.name - mappingB.name;\n}\nexports.compareByOriginalPositions = compareByOriginalPositions;\n\n/**\n * Comparator between two mappings with deflated source and name indices where\n * the generated positions are compared.\n *\n * Optionally pass in `true` as `onlyCompareGenerated` to consider two\n * mappings with the same generated line and column, but different\n * source/name/original line and column the same. Useful when searching for a\n * mapping with a stubbed out mapping.\n */\nfunction compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {\n  var cmp = mappingA.generatedLine - mappingB.generatedLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n  if (cmp !== 0 || onlyCompareGenerated) {\n    return cmp;\n  }\n\n  cmp = mappingA.source - mappingB.source;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalLine - mappingB.originalLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalColumn - mappingB.originalColumn;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  return mappingA.name - mappingB.name;\n}\nexports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;\n\nfunction strcmp(aStr1, aStr2) {\n  if (aStr1 === aStr2) {\n    return 0;\n  }\n\n  if (aStr1 > aStr2) {\n    return 1;\n  }\n\n  return -1;\n}\n\n/**\n * Comparator between two mappings with inflated source and name strings where\n * the generated positions are compared.\n */\nfunction compareByGeneratedPositionsInflated(mappingA, mappingB) {\n  var cmp = mappingA.generatedLine - mappingB.generatedLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = strcmp(mappingA.source, mappingB.source);\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalLine - mappingB.originalLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalColumn - mappingB.originalColumn;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  return strcmp(mappingA.name, mappingB.name);\n}\nexports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/util.js\n// module id = 4\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar util = require('./util');\nvar has = Object.prototype.hasOwnProperty;\nvar hasNativeMap = typeof Map !== \"undefined\";\n\n/**\n * A data structure which is a combination of an array and a set. Adding a new\n * member is O(1), testing for membership is O(1), and finding the index of an\n * element is O(1). Removing elements from the set is not supported. Only\n * strings are supported for membership.\n */\nfunction ArraySet() {\n  this._array = [];\n  this._set = hasNativeMap ? new Map() : Object.create(null);\n}\n\n/**\n * Static method for creating ArraySet instances from an existing array.\n */\nArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {\n  var set = new ArraySet();\n  for (var i = 0, len = aArray.length; i < len; i++) {\n    set.add(aArray[i], aAllowDuplicates);\n  }\n  return set;\n};\n\n/**\n * Return how many unique items are in this ArraySet. If duplicates have been\n * added, than those do not count towards the size.\n *\n * @returns Number\n */\nArraySet.prototype.size = function ArraySet_size() {\n  return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;\n};\n\n/**\n * Add the given string to this set.\n *\n * @param String aStr\n */\nArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {\n  var sStr = hasNativeMap ? aStr : util.toSetString(aStr);\n  var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);\n  var idx = this._array.length;\n  if (!isDuplicate || aAllowDuplicates) {\n    this._array.push(aStr);\n  }\n  if (!isDuplicate) {\n    if (hasNativeMap) {\n      this._set.set(aStr, idx);\n    } else {\n      this._set[sStr] = idx;\n    }\n  }\n};\n\n/**\n * Is the given string a member of this set?\n *\n * @param String aStr\n */\nArraySet.prototype.has = function ArraySet_has(aStr) {\n  if (hasNativeMap) {\n    return this._set.has(aStr);\n  } else {\n    var sStr = util.toSetString(aStr);\n    return has.call(this._set, sStr);\n  }\n};\n\n/**\n * What is the index of the given string in the array?\n *\n * @param String aStr\n */\nArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {\n  if (hasNativeMap) {\n    var idx = this._set.get(aStr);\n    if (idx >= 0) {\n        return idx;\n    }\n  } else {\n    var sStr = util.toSetString(aStr);\n    if (has.call(this._set, sStr)) {\n      return this._set[sStr];\n    }\n  }\n\n  throw new Error('\"' + aStr + '\" is not in the set.');\n};\n\n/**\n * What is the element at the given index?\n *\n * @param Number aIdx\n */\nArraySet.prototype.at = function ArraySet_at(aIdx) {\n  if (aIdx >= 0 && aIdx < this._array.length) {\n    return this._array[aIdx];\n  }\n  throw new Error('No element indexed by ' + aIdx);\n};\n\n/**\n * Returns the array representation of this set (which has the proper indices\n * indicated by indexOf). Note that this is a copy of the internal array used\n * for storing the members so that no one can mess with internal state.\n */\nArraySet.prototype.toArray = function ArraySet_toArray() {\n  return this._array.slice();\n};\n\nexports.ArraySet = ArraySet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/array-set.js\n// module id = 5\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2014 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar util = require('./util');\n\n/**\n * Determine whether mappingB is after mappingA with respect to generated\n * position.\n */\nfunction generatedPositionAfter(mappingA, mappingB) {\n  // Optimized for most common case\n  var lineA = mappingA.generatedLine;\n  var lineB = mappingB.generatedLine;\n  var columnA = mappingA.generatedColumn;\n  var columnB = mappingB.generatedColumn;\n  return lineB > lineA || lineB == lineA && columnB >= columnA ||\n         util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;\n}\n\n/**\n * A data structure to provide a sorted view of accumulated mappings in a\n * performance conscious manner. It trades a neglibable overhead in general\n * case for a large speedup in case of mappings being added in order.\n */\nfunction MappingList() {\n  this._array = [];\n  this._sorted = true;\n  // Serves as infimum\n  this._last = {generatedLine: -1, generatedColumn: 0};\n}\n\n/**\n * Iterate through internal items. This method takes the same arguments that\n * `Array.prototype.forEach` takes.\n *\n * NOTE: The order of the mappings is NOT guaranteed.\n */\nMappingList.prototype.unsortedForEach =\n  function MappingList_forEach(aCallback, aThisArg) {\n    this._array.forEach(aCallback, aThisArg);\n  };\n\n/**\n * Add the given source mapping.\n *\n * @param Object aMapping\n */\nMappingList.prototype.add = function MappingList_add(aMapping) {\n  if (generatedPositionAfter(this._last, aMapping)) {\n    this._last = aMapping;\n    this._array.push(aMapping);\n  } else {\n    this._sorted = false;\n    this._array.push(aMapping);\n  }\n};\n\n/**\n * Returns the flat, sorted array of mappings. The mappings are sorted by\n * generated position.\n *\n * WARNING: This method returns internal data without copying, for\n * performance. The return value must NOT be mutated, and should be treated as\n * an immutable borrow. If you want to take ownership, you must make your own\n * copy.\n */\nMappingList.prototype.toArray = function MappingList_toArray() {\n  if (!this._sorted) {\n    this._array.sort(util.compareByGeneratedPositionsInflated);\n    this._sorted = true;\n  }\n  return this._array;\n};\n\nexports.MappingList = MappingList;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/mapping-list.js\n// module id = 6\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar util = require('./util');\nvar binarySearch = require('./binary-search');\nvar ArraySet = require('./array-set').ArraySet;\nvar base64VLQ = require('./base64-vlq');\nvar quickSort = require('./quick-sort').quickSort;\n\nfunction SourceMapConsumer(aSourceMap) {\n  var sourceMap = aSourceMap;\n  if (typeof aSourceMap === 'string') {\n    sourceMap = JSON.parse(aSourceMap.replace(/^\\)\\]\\}'/, ''));\n  }\n\n  return sourceMap.sections != null\n    ? new IndexedSourceMapConsumer(sourceMap)\n    : new BasicSourceMapConsumer(sourceMap);\n}\n\nSourceMapConsumer.fromSourceMap = function(aSourceMap) {\n  return BasicSourceMapConsumer.fromSourceMap(aSourceMap);\n}\n\n/**\n * The version of the source mapping spec that we are consuming.\n */\nSourceMapConsumer.prototype._version = 3;\n\n// `__generatedMappings` and `__originalMappings` are arrays that hold the\n// parsed mapping coordinates from the source map's \"mappings\" attribute. They\n// are lazily instantiated, accessed via the `_generatedMappings` and\n// `_originalMappings` getters respectively, and we only parse the mappings\n// and create these arrays once queried for a source location. We jump through\n// these hoops because there can be many thousands of mappings, and parsing\n// them is expensive, so we only want to do it if we must.\n//\n// Each object in the arrays is of the form:\n//\n//     {\n//       generatedLine: The line number in the generated code,\n//       generatedColumn: The column number in the generated code,\n//       source: The path to the original source file that generated this\n//               chunk of code,\n//       originalLine: The line number in the original source that\n//                     corresponds to this chunk of generated code,\n//       originalColumn: The column number in the original source that\n//                       corresponds to this chunk of generated code,\n//       name: The name of the original symbol which generated this chunk of\n//             code.\n//     }\n//\n// All properties except for `generatedLine` and `generatedColumn` can be\n// `null`.\n//\n// `_generatedMappings` is ordered by the generated positions.\n//\n// `_originalMappings` is ordered by the original positions.\n\nSourceMapConsumer.prototype.__generatedMappings = null;\nObject.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {\n  get: function () {\n    if (!this.__generatedMappings) {\n      this._parseMappings(this._mappings, this.sourceRoot);\n    }\n\n    return this.__generatedMappings;\n  }\n});\n\nSourceMapConsumer.prototype.__originalMappings = null;\nObject.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {\n  get: function () {\n    if (!this.__originalMappings) {\n      this._parseMappings(this._mappings, this.sourceRoot);\n    }\n\n    return this.__originalMappings;\n  }\n});\n\nSourceMapConsumer.prototype._charIsMappingSeparator =\n  function SourceMapConsumer_charIsMappingSeparator(aStr, index) {\n    var c = aStr.charAt(index);\n    return c === \";\" || c === \",\";\n  };\n\n/**\n * Parse the mappings in a string in to a data structure which we can easily\n * query (the ordered arrays in the `this.__generatedMappings` and\n * `this.__originalMappings` properties).\n */\nSourceMapConsumer.prototype._parseMappings =\n  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n    throw new Error(\"Subclasses must implement _parseMappings\");\n  };\n\nSourceMapConsumer.GENERATED_ORDER = 1;\nSourceMapConsumer.ORIGINAL_ORDER = 2;\n\nSourceMapConsumer.GREATEST_LOWER_BOUND = 1;\nSourceMapConsumer.LEAST_UPPER_BOUND = 2;\n\n/**\n * Iterate over each mapping between an original source/line/column and a\n * generated line/column in this source map.\n *\n * @param Function aCallback\n *        The function that is called with each mapping.\n * @param Object aContext\n *        Optional. If specified, this object will be the value of `this` every\n *        time that `aCallback` is called.\n * @param aOrder\n *        Either `SourceMapConsumer.GENERATED_ORDER` or\n *        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to\n *        iterate over the mappings sorted by the generated file's line/column\n *        order or the original's source/line/column order, respectively. Defaults to\n *        `SourceMapConsumer.GENERATED_ORDER`.\n */\nSourceMapConsumer.prototype.eachMapping =\n  function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {\n    var context = aContext || null;\n    var order = aOrder || SourceMapConsumer.GENERATED_ORDER;\n\n    var mappings;\n    switch (order) {\n    case SourceMapConsumer.GENERATED_ORDER:\n      mappings = this._generatedMappings;\n      break;\n    case SourceMapConsumer.ORIGINAL_ORDER:\n      mappings = this._originalMappings;\n      break;\n    default:\n      throw new Error(\"Unknown order of iteration.\");\n    }\n\n    var sourceRoot = this.sourceRoot;\n    mappings.map(function (mapping) {\n      var source = mapping.source === null ? null : this._sources.at(mapping.source);\n      if (source != null && sourceRoot != null) {\n        source = util.join(sourceRoot, source);\n      }\n      return {\n        source: source,\n        generatedLine: mapping.generatedLine,\n        generatedColumn: mapping.generatedColumn,\n        originalLine: mapping.originalLine,\n        originalColumn: mapping.originalColumn,\n        name: mapping.name === null ? null : this._names.at(mapping.name)\n      };\n    }, this).forEach(aCallback, context);\n  };\n\n/**\n * Returns all generated line and column information for the original source,\n * line, and column provided. If no column is provided, returns all mappings\n * corresponding to a either the line we are searching for or the next\n * closest line that has any mappings. Otherwise, returns all mappings\n * corresponding to the given line and either the column we are searching for\n * or the next closest column that has any offsets.\n *\n * The only argument is an object with the following properties:\n *\n *   - source: The filename of the original source.\n *   - line: The line number in the original source.\n *   - column: Optional. the column number in the original source.\n *\n * and an array of objects is returned, each with the following properties:\n *\n *   - line: The line number in the generated source, or null.\n *   - column: The column number in the generated source, or null.\n */\nSourceMapConsumer.prototype.allGeneratedPositionsFor =\n  function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {\n    var line = util.getArg(aArgs, 'line');\n\n    // When there is no exact match, BasicSourceMapConsumer.prototype._findMapping\n    // returns the index of the closest mapping less than the needle. By\n    // setting needle.originalColumn to 0, we thus find the last mapping for\n    // the given line, provided such a mapping exists.\n    var needle = {\n      source: util.getArg(aArgs, 'source'),\n      originalLine: line,\n      originalColumn: util.getArg(aArgs, 'column', 0)\n    };\n\n    if (this.sourceRoot != null) {\n      needle.source = util.relative(this.sourceRoot, needle.source);\n    }\n    if (!this._sources.has(needle.source)) {\n      return [];\n    }\n    needle.source = this._sources.indexOf(needle.source);\n\n    var mappings = [];\n\n    var index = this._findMapping(needle,\n                                  this._originalMappings,\n                                  \"originalLine\",\n                                  \"originalColumn\",\n                                  util.compareByOriginalPositions,\n                                  binarySearch.LEAST_UPPER_BOUND);\n    if (index >= 0) {\n      var mapping = this._originalMappings[index];\n\n      if (aArgs.column === undefined) {\n        var originalLine = mapping.originalLine;\n\n        // Iterate until either we run out of mappings, or we run into\n        // a mapping for a different line than the one we found. Since\n        // mappings are sorted, this is guaranteed to find all mappings for\n        // the line we found.\n        while (mapping && mapping.originalLine === originalLine) {\n          mappings.push({\n            line: util.getArg(mapping, 'generatedLine', null),\n            column: util.getArg(mapping, 'generatedColumn', null),\n            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n          });\n\n          mapping = this._originalMappings[++index];\n        }\n      } else {\n        var originalColumn = mapping.originalColumn;\n\n        // Iterate until either we run out of mappings, or we run into\n        // a mapping for a different line than the one we were searching for.\n        // Since mappings are sorted, this is guaranteed to find all mappings for\n        // the line we are searching for.\n        while (mapping &&\n               mapping.originalLine === line &&\n               mapping.originalColumn == originalColumn) {\n          mappings.push({\n            line: util.getArg(mapping, 'generatedLine', null),\n            column: util.getArg(mapping, 'generatedColumn', null),\n            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n          });\n\n          mapping = this._originalMappings[++index];\n        }\n      }\n    }\n\n    return mappings;\n  };\n\nexports.SourceMapConsumer = SourceMapConsumer;\n\n/**\n * A BasicSourceMapConsumer instance represents a parsed source map which we can\n * query for information about the original file positions by giving it a file\n * position in the generated source.\n *\n * The only parameter is the raw source map (either as a JSON string, or\n * already parsed to an object). According to the spec, source maps have the\n * following attributes:\n *\n *   - version: Which version of the source map spec this map is following.\n *   - sources: An array of URLs to the original source files.\n *   - names: An array of identifiers which can be referrenced by individual mappings.\n *   - sourceRoot: Optional. The URL root from which all sources are relative.\n *   - sourcesContent: Optional. An array of contents of the original source files.\n *   - mappings: A string of base64 VLQs which contain the actual mappings.\n *   - file: Optional. The generated file this source map is associated with.\n *\n * Here is an example source map, taken from the source map spec[0]:\n *\n *     {\n *       version : 3,\n *       file: \"out.js\",\n *       sourceRoot : \"\",\n *       sources: [\"foo.js\", \"bar.js\"],\n *       names: [\"src\", \"maps\", \"are\", \"fun\"],\n *       mappings: \"AA,AB;;ABCDE;\"\n *     }\n *\n * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#\n */\nfunction BasicSourceMapConsumer(aSourceMap) {\n  var sourceMap = aSourceMap;\n  if (typeof aSourceMap === 'string') {\n    sourceMap = JSON.parse(aSourceMap.replace(/^\\)\\]\\}'/, ''));\n  }\n\n  var version = util.getArg(sourceMap, 'version');\n  var sources = util.getArg(sourceMap, 'sources');\n  // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which\n  // requires the array) to play nice here.\n  var names = util.getArg(sourceMap, 'names', []);\n  var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);\n  var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);\n  var mappings = util.getArg(sourceMap, 'mappings');\n  var file = util.getArg(sourceMap, 'file', null);\n\n  // Once again, Sass deviates from the spec and supplies the version as a\n  // string rather than a number, so we use loose equality checking here.\n  if (version != this._version) {\n    throw new Error('Unsupported version: ' + version);\n  }\n\n  sources = sources\n    .map(String)\n    // Some source maps produce relative source paths like \"./foo.js\" instead of\n    // \"foo.js\".  Normalize these first so that future comparisons will succeed.\n    // See bugzil.la/1090768.\n    .map(util.normalize)\n    // Always ensure that absolute sources are internally stored relative to\n    // the source root, if the source root is absolute. Not doing this would\n    // be particularly problematic when the source root is a prefix of the\n    // source (valid, but why??). See github issue #199 and bugzil.la/1188982.\n    .map(function (source) {\n      return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source)\n        ? util.relative(sourceRoot, source)\n        : source;\n    });\n\n  // Pass `true` below to allow duplicate names and sources. While source maps\n  // are intended to be compressed and deduplicated, the TypeScript compiler\n  // sometimes generates source maps with duplicates in them. See Github issue\n  // #72 and bugzil.la/889492.\n  this._names = ArraySet.fromArray(names.map(String), true);\n  this._sources = ArraySet.fromArray(sources, true);\n\n  this.sourceRoot = sourceRoot;\n  this.sourcesContent = sourcesContent;\n  this._mappings = mappings;\n  this.file = file;\n}\n\nBasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);\nBasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;\n\n/**\n * Create a BasicSourceMapConsumer from a SourceMapGenerator.\n *\n * @param SourceMapGenerator aSourceMap\n *        The source map that will be consumed.\n * @returns BasicSourceMapConsumer\n */\nBasicSourceMapConsumer.fromSourceMap =\n  function SourceMapConsumer_fromSourceMap(aSourceMap) {\n    var smc = Object.create(BasicSourceMapConsumer.prototype);\n\n    var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);\n    var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);\n    smc.sourceRoot = aSourceMap._sourceRoot;\n    smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),\n                                                            smc.sourceRoot);\n    smc.file = aSourceMap._file;\n\n    // Because we are modifying the entries (by converting string sources and\n    // names to indices into the sources and names ArraySets), we have to make\n    // a copy of the entry or else bad things happen. Shared mutable state\n    // strikes again! See github issue #191.\n\n    var generatedMappings = aSourceMap._mappings.toArray().slice();\n    var destGeneratedMappings = smc.__generatedMappings = [];\n    var destOriginalMappings = smc.__originalMappings = [];\n\n    for (var i = 0, length = generatedMappings.length; i < length; i++) {\n      var srcMapping = generatedMappings[i];\n      var destMapping = new Mapping;\n      destMapping.generatedLine = srcMapping.generatedLine;\n      destMapping.generatedColumn = srcMapping.generatedColumn;\n\n      if (srcMapping.source) {\n        destMapping.source = sources.indexOf(srcMapping.source);\n        destMapping.originalLine = srcMapping.originalLine;\n        destMapping.originalColumn = srcMapping.originalColumn;\n\n        if (srcMapping.name) {\n          destMapping.name = names.indexOf(srcMapping.name);\n        }\n\n        destOriginalMappings.push(destMapping);\n      }\n\n      destGeneratedMappings.push(destMapping);\n    }\n\n    quickSort(smc.__originalMappings, util.compareByOriginalPositions);\n\n    return smc;\n  };\n\n/**\n * The version of the source mapping spec that we are consuming.\n */\nBasicSourceMapConsumer.prototype._version = 3;\n\n/**\n * The list of original sources.\n */\nObject.defineProperty(BasicSourceMapConsumer.prototype, 'sources', {\n  get: function () {\n    return this._sources.toArray().map(function (s) {\n      return this.sourceRoot != null ? util.join(this.sourceRoot, s) : s;\n    }, this);\n  }\n});\n\n/**\n * Provide the JIT with a nice shape / hidden class.\n */\nfunction Mapping() {\n  this.generatedLine = 0;\n  this.generatedColumn = 0;\n  this.source = null;\n  this.originalLine = null;\n  this.originalColumn = null;\n  this.name = null;\n}\n\n/**\n * Parse the mappings in a string in to a data structure which we can easily\n * query (the ordered arrays in the `this.__generatedMappings` and\n * `this.__originalMappings` properties).\n */\nBasicSourceMapConsumer.prototype._parseMappings =\n  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n    var generatedLine = 1;\n    var previousGeneratedColumn = 0;\n    var previousOriginalLine = 0;\n    var previousOriginalColumn = 0;\n    var previousSource = 0;\n    var previousName = 0;\n    var length = aStr.length;\n    var index = 0;\n    var cachedSegments = {};\n    var temp = {};\n    var originalMappings = [];\n    var generatedMappings = [];\n    var mapping, str, segment, end, value;\n\n    while (index < length) {\n      if (aStr.charAt(index) === ';') {\n        generatedLine++;\n        index++;\n        previousGeneratedColumn = 0;\n      }\n      else if (aStr.charAt(index) === ',') {\n        index++;\n      }\n      else {\n        mapping = new Mapping();\n        mapping.generatedLine = generatedLine;\n\n        // Because each offset is encoded relative to the previous one,\n        // many segments often have the same encoding. We can exploit this\n        // fact by caching the parsed variable length fields of each segment,\n        // allowing us to avoid a second parse if we encounter the same\n        // segment again.\n        for (end = index; end < length; end++) {\n          if (this._charIsMappingSeparator(aStr, end)) {\n            break;\n          }\n        }\n        str = aStr.slice(index, end);\n\n        segment = cachedSegments[str];\n        if (segment) {\n          index += str.length;\n        } else {\n          segment = [];\n          while (index < end) {\n            base64VLQ.decode(aStr, index, temp);\n            value = temp.value;\n            index = temp.rest;\n            segment.push(value);\n          }\n\n          if (segment.length === 2) {\n            throw new Error('Found a source, but no line and column');\n          }\n\n          if (segment.length === 3) {\n            throw new Error('Found a source and line, but no column');\n          }\n\n          cachedSegments[str] = segment;\n        }\n\n        // Generated column.\n        mapping.generatedColumn = previousGeneratedColumn + segment[0];\n        previousGeneratedColumn = mapping.generatedColumn;\n\n        if (segment.length > 1) {\n          // Original source.\n          mapping.source = previousSource + segment[1];\n          previousSource += segment[1];\n\n          // Original line.\n          mapping.originalLine = previousOriginalLine + segment[2];\n          previousOriginalLine = mapping.originalLine;\n          // Lines are stored 0-based\n          mapping.originalLine += 1;\n\n          // Original column.\n          mapping.originalColumn = previousOriginalColumn + segment[3];\n          previousOriginalColumn = mapping.originalColumn;\n\n          if (segment.length > 4) {\n            // Original name.\n            mapping.name = previousName + segment[4];\n            previousName += segment[4];\n          }\n        }\n\n        generatedMappings.push(mapping);\n        if (typeof mapping.originalLine === 'number') {\n          originalMappings.push(mapping);\n        }\n      }\n    }\n\n    quickSort(generatedMappings, util.compareByGeneratedPositionsDeflated);\n    this.__generatedMappings = generatedMappings;\n\n    quickSort(originalMappings, util.compareByOriginalPositions);\n    this.__originalMappings = originalMappings;\n  };\n\n/**\n * Find the mapping that best matches the hypothetical \"needle\" mapping that\n * we are searching for in the given \"haystack\" of mappings.\n */\nBasicSourceMapConsumer.prototype._findMapping =\n  function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,\n                                         aColumnName, aComparator, aBias) {\n    // To return the position we are searching for, we must first find the\n    // mapping for the given position and then return the opposite position it\n    // points to. Because the mappings are sorted, we can use binary search to\n    // find the best mapping.\n\n    if (aNeedle[aLineName] <= 0) {\n      throw new TypeError('Line must be greater than or equal to 1, got '\n                          + aNeedle[aLineName]);\n    }\n    if (aNeedle[aColumnName] < 0) {\n      throw new TypeError('Column must be greater than or equal to 0, got '\n                          + aNeedle[aColumnName]);\n    }\n\n    return binarySearch.search(aNeedle, aMappings, aComparator, aBias);\n  };\n\n/**\n * Compute the last column for each generated mapping. The last column is\n * inclusive.\n */\nBasicSourceMapConsumer.prototype.computeColumnSpans =\n  function SourceMapConsumer_computeColumnSpans() {\n    for (var index = 0; index < this._generatedMappings.length; ++index) {\n      var mapping = this._generatedMappings[index];\n\n      // Mappings do not contain a field for the last generated columnt. We\n      // can come up with an optimistic estimate, however, by assuming that\n      // mappings are contiguous (i.e. given two consecutive mappings, the\n      // first mapping ends where the second one starts).\n      if (index + 1 < this._generatedMappings.length) {\n        var nextMapping = this._generatedMappings[index + 1];\n\n        if (mapping.generatedLine === nextMapping.generatedLine) {\n          mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;\n          continue;\n        }\n      }\n\n      // The last mapping for each line spans the entire line.\n      mapping.lastGeneratedColumn = Infinity;\n    }\n  };\n\n/**\n * Returns the original source, line, and column information for the generated\n * source's line and column positions provided. The only argument is an object\n * with the following properties:\n *\n *   - line: The line number in the generated source.\n *   - column: The column number in the generated source.\n *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or\n *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the\n *     closest element that is smaller than or greater than the one we are\n *     searching for, respectively, if the exact element cannot be found.\n *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.\n *\n * and an object is returned with the following properties:\n *\n *   - source: The original source file, or null.\n *   - line: The line number in the original source, or null.\n *   - column: The column number in the original source, or null.\n *   - name: The original identifier, or null.\n */\nBasicSourceMapConsumer.prototype.originalPositionFor =\n  function SourceMapConsumer_originalPositionFor(aArgs) {\n    var needle = {\n      generatedLine: util.getArg(aArgs, 'line'),\n      generatedColumn: util.getArg(aArgs, 'column')\n    };\n\n    var index = this._findMapping(\n      needle,\n      this._generatedMappings,\n      \"generatedLine\",\n      \"generatedColumn\",\n      util.compareByGeneratedPositionsDeflated,\n      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)\n    );\n\n    if (index >= 0) {\n      var mapping = this._generatedMappings[index];\n\n      if (mapping.generatedLine === needle.generatedLine) {\n        var source = util.getArg(mapping, 'source', null);\n        if (source !== null) {\n          source = this._sources.at(source);\n          if (this.sourceRoot != null) {\n            source = util.join(this.sourceRoot, source);\n          }\n        }\n        var name = util.getArg(mapping, 'name', null);\n        if (name !== null) {\n          name = this._names.at(name);\n        }\n        return {\n          source: source,\n          line: util.getArg(mapping, 'originalLine', null),\n          column: util.getArg(mapping, 'originalColumn', null),\n          name: name\n        };\n      }\n    }\n\n    return {\n      source: null,\n      line: null,\n      column: null,\n      name: null\n    };\n  };\n\n/**\n * Return true if we have the source content for every source in the source\n * map, false otherwise.\n */\nBasicSourceMapConsumer.prototype.hasContentsOfAllSources =\n  function BasicSourceMapConsumer_hasContentsOfAllSources() {\n    if (!this.sourcesContent) {\n      return false;\n    }\n    return this.sourcesContent.length >= this._sources.size() &&\n      !this.sourcesContent.some(function (sc) { return sc == null; });\n  };\n\n/**\n * Returns the original source content. The only argument is the url of the\n * original source file. Returns null if no original source content is\n * available.\n */\nBasicSourceMapConsumer.prototype.sourceContentFor =\n  function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {\n    if (!this.sourcesContent) {\n      return null;\n    }\n\n    if (this.sourceRoot != null) {\n      aSource = util.relative(this.sourceRoot, aSource);\n    }\n\n    if (this._sources.has(aSource)) {\n      return this.sourcesContent[this._sources.indexOf(aSource)];\n    }\n\n    var url;\n    if (this.sourceRoot != null\n        && (url = util.urlParse(this.sourceRoot))) {\n      // XXX: file:// URIs and absolute paths lead to unexpected behavior for\n      // many users. We can help them out when they expect file:// URIs to\n      // behave like it would if they were running a local HTTP server. See\n      // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.\n      var fileUriAbsPath = aSource.replace(/^file:\\/\\//, \"\");\n      if (url.scheme == \"file\"\n          && this._sources.has(fileUriAbsPath)) {\n        return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]\n      }\n\n      if ((!url.path || url.path == \"/\")\n          && this._sources.has(\"/\" + aSource)) {\n        return this.sourcesContent[this._sources.indexOf(\"/\" + aSource)];\n      }\n    }\n\n    // This function is used recursively from\n    // IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we\n    // don't want to throw if we can't find the source - we just want to\n    // return null, so we provide a flag to exit gracefully.\n    if (nullOnMissing) {\n      return null;\n    }\n    else {\n      throw new Error('\"' + aSource + '\" is not in the SourceMap.');\n    }\n  };\n\n/**\n * Returns the generated line and column information for the original source,\n * line, and column positions provided. The only argument is an object with\n * the following properties:\n *\n *   - source: The filename of the original source.\n *   - line: The line number in the original source.\n *   - column: The column number in the original source.\n *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or\n *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the\n *     closest element that is smaller than or greater than the one we are\n *     searching for, respectively, if the exact element cannot be found.\n *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.\n *\n * and an object is returned with the following properties:\n *\n *   - line: The line number in the generated source, or null.\n *   - column: The column number in the generated source, or null.\n */\nBasicSourceMapConsumer.prototype.generatedPositionFor =\n  function SourceMapConsumer_generatedPositionFor(aArgs) {\n    var source = util.getArg(aArgs, 'source');\n    if (this.sourceRoot != null) {\n      source = util.relative(this.sourceRoot, source);\n    }\n    if (!this._sources.has(source)) {\n      return {\n        line: null,\n        column: null,\n        lastColumn: null\n      };\n    }\n    source = this._sources.indexOf(source);\n\n    var needle = {\n      source: source,\n      originalLine: util.getArg(aArgs, 'line'),\n      originalColumn: util.getArg(aArgs, 'column')\n    };\n\n    var index = this._findMapping(\n      needle,\n      this._originalMappings,\n      \"originalLine\",\n      \"originalColumn\",\n      util.compareByOriginalPositions,\n      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)\n    );\n\n    if (index >= 0) {\n      var mapping = this._originalMappings[index];\n\n      if (mapping.source === needle.source) {\n        return {\n          line: util.getArg(mapping, 'generatedLine', null),\n          column: util.getArg(mapping, 'generatedColumn', null),\n          lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n        };\n      }\n    }\n\n    return {\n      line: null,\n      column: null,\n      lastColumn: null\n    };\n  };\n\nexports.BasicSourceMapConsumer = BasicSourceMapConsumer;\n\n/**\n * An IndexedSourceMapConsumer instance represents a parsed source map which\n * we can query for information. It differs from BasicSourceMapConsumer in\n * that it takes \"indexed\" source maps (i.e. ones with a \"sections\" field) as\n * input.\n *\n * The only parameter is a raw source map (either as a JSON string, or already\n * parsed to an object). According to the spec for indexed source maps, they\n * have the following attributes:\n *\n *   - version: Which version of the source map spec this map is following.\n *   - file: Optional. The generated file this source map is associated with.\n *   - sections: A list of section definitions.\n *\n * Each value under the \"sections\" field has two fields:\n *   - offset: The offset into the original specified at which this section\n *       begins to apply, defined as an object with a \"line\" and \"column\"\n *       field.\n *   - map: A source map definition. This source map could also be indexed,\n *       but doesn't have to be.\n *\n * Instead of the \"map\" field, it's also possible to have a \"url\" field\n * specifying a URL to retrieve a source map from, but that's currently\n * unsupported.\n *\n * Here's an example source map, taken from the source map spec[0], but\n * modified to omit a section which uses the \"url\" field.\n *\n *  {\n *    version : 3,\n *    file: \"app.js\",\n *    sections: [{\n *      offset: {line:100, column:10},\n *      map: {\n *        version : 3,\n *        file: \"section.js\",\n *        sources: [\"foo.js\", \"bar.js\"],\n *        names: [\"src\", \"maps\", \"are\", \"fun\"],\n *        mappings: \"AAAA,E;;ABCDE;\"\n *      }\n *    }],\n *  }\n *\n * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt\n */\nfunction IndexedSourceMapConsumer(aSourceMap) {\n  var sourceMap = aSourceMap;\n  if (typeof aSourceMap === 'string') {\n    sourceMap = JSON.parse(aSourceMap.replace(/^\\)\\]\\}'/, ''));\n  }\n\n  var version = util.getArg(sourceMap, 'version');\n  var sections = util.getArg(sourceMap, 'sections');\n\n  if (version != this._version) {\n    throw new Error('Unsupported version: ' + version);\n  }\n\n  this._sources = new ArraySet();\n  this._names = new ArraySet();\n\n  var lastOffset = {\n    line: -1,\n    column: 0\n  };\n  this._sections = sections.map(function (s) {\n    if (s.url) {\n      // The url field will require support for asynchronicity.\n      // See https://github.com/mozilla/source-map/issues/16\n      throw new Error('Support for url field in sections not implemented.');\n    }\n    var offset = util.getArg(s, 'offset');\n    var offsetLine = util.getArg(offset, 'line');\n    var offsetColumn = util.getArg(offset, 'column');\n\n    if (offsetLine < lastOffset.line ||\n        (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {\n      throw new Error('Section offsets must be ordered and non-overlapping.');\n    }\n    lastOffset = offset;\n\n    return {\n      generatedOffset: {\n        // The offset fields are 0-based, but we use 1-based indices when\n        // encoding/decoding from VLQ.\n        generatedLine: offsetLine + 1,\n        generatedColumn: offsetColumn + 1\n      },\n      consumer: new SourceMapConsumer(util.getArg(s, 'map'))\n    }\n  });\n}\n\nIndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);\nIndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;\n\n/**\n * The version of the source mapping spec that we are consuming.\n */\nIndexedSourceMapConsumer.prototype._version = 3;\n\n/**\n * The list of original sources.\n */\nObject.defineProperty(IndexedSourceMapConsumer.prototype, 'sources', {\n  get: function () {\n    var sources = [];\n    for (var i = 0; i < this._sections.length; i++) {\n      for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {\n        sources.push(this._sections[i].consumer.sources[j]);\n      }\n    }\n    return sources;\n  }\n});\n\n/**\n * Returns the original source, line, and column information for the generated\n * source's line and column positions provided. The only argument is an object\n * with the following properties:\n *\n *   - line: The line number in the generated source.\n *   - column: The column number in the generated source.\n *\n * and an object is returned with the following properties:\n *\n *   - source: The original source file, or null.\n *   - line: The line number in the original source, or null.\n *   - column: The column number in the original source, or null.\n *   - name: The original identifier, or null.\n */\nIndexedSourceMapConsumer.prototype.originalPositionFor =\n  function IndexedSourceMapConsumer_originalPositionFor(aArgs) {\n    var needle = {\n      generatedLine: util.getArg(aArgs, 'line'),\n      generatedColumn: util.getArg(aArgs, 'column')\n    };\n\n    // Find the section containing the generated position we're trying to map\n    // to an original position.\n    var sectionIndex = binarySearch.search(needle, this._sections,\n      function(needle, section) {\n        var cmp = needle.generatedLine - section.generatedOffset.generatedLine;\n        if (cmp) {\n          return cmp;\n        }\n\n        return (needle.generatedColumn -\n                section.generatedOffset.generatedColumn);\n      });\n    var section = this._sections[sectionIndex];\n\n    if (!section) {\n      return {\n        source: null,\n        line: null,\n        column: null,\n        name: null\n      };\n    }\n\n    return section.consumer.originalPositionFor({\n      line: needle.generatedLine -\n        (section.generatedOffset.generatedLine - 1),\n      column: needle.generatedColumn -\n        (section.generatedOffset.generatedLine === needle.generatedLine\n         ? section.generatedOffset.generatedColumn - 1\n         : 0),\n      bias: aArgs.bias\n    });\n  };\n\n/**\n * Return true if we have the source content for every source in the source\n * map, false otherwise.\n */\nIndexedSourceMapConsumer.prototype.hasContentsOfAllSources =\n  function IndexedSourceMapConsumer_hasContentsOfAllSources() {\n    return this._sections.every(function (s) {\n      return s.consumer.hasContentsOfAllSources();\n    });\n  };\n\n/**\n * Returns the original source content. The only argument is the url of the\n * original source file. Returns null if no original source content is\n * available.\n */\nIndexedSourceMapConsumer.prototype.sourceContentFor =\n  function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {\n    for (var i = 0; i < this._sections.length; i++) {\n      var section = this._sections[i];\n\n      var content = section.consumer.sourceContentFor(aSource, true);\n      if (content) {\n        return content;\n      }\n    }\n    if (nullOnMissing) {\n      return null;\n    }\n    else {\n      throw new Error('\"' + aSource + '\" is not in the SourceMap.');\n    }\n  };\n\n/**\n * Returns the generated line and column information for the original source,\n * line, and column positions provided. The only argument is an object with\n * the following properties:\n *\n *   - source: The filename of the original source.\n *   - line: The line number in the original source.\n *   - column: The column number in the original source.\n *\n * and an object is returned with the following properties:\n *\n *   - line: The line number in the generated source, or null.\n *   - column: The column number in the generated source, or null.\n */\nIndexedSourceMapConsumer.prototype.generatedPositionFor =\n  function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {\n    for (var i = 0; i < this._sections.length; i++) {\n      var section = this._sections[i];\n\n      // Only consider this section if the requested source is in the list of\n      // sources of the consumer.\n      if (section.consumer.sources.indexOf(util.getArg(aArgs, 'source')) === -1) {\n        continue;\n      }\n      var generatedPosition = section.consumer.generatedPositionFor(aArgs);\n      if (generatedPosition) {\n        var ret = {\n          line: generatedPosition.line +\n            (section.generatedOffset.generatedLine - 1),\n          column: generatedPosition.column +\n            (section.generatedOffset.generatedLine === generatedPosition.line\n             ? section.generatedOffset.generatedColumn - 1\n             : 0)\n        };\n        return ret;\n      }\n    }\n\n    return {\n      line: null,\n      column: null\n    };\n  };\n\n/**\n * Parse the mappings in a string in to a data structure which we can easily\n * query (the ordered arrays in the `this.__generatedMappings` and\n * `this.__originalMappings` properties).\n */\nIndexedSourceMapConsumer.prototype._parseMappings =\n  function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n    this.__generatedMappings = [];\n    this.__originalMappings = [];\n    for (var i = 0; i < this._sections.length; i++) {\n      var section = this._sections[i];\n      var sectionMappings = section.consumer._generatedMappings;\n      for (var j = 0; j < sectionMappings.length; j++) {\n        var mapping = sectionMappings[j];\n\n        var source = section.consumer._sources.at(mapping.source);\n        if (section.consumer.sourceRoot !== null) {\n          source = util.join(section.consumer.sourceRoot, source);\n        }\n        this._sources.add(source);\n        source = this._sources.indexOf(source);\n\n        var name = section.consumer._names.at(mapping.name);\n        this._names.add(name);\n        name = this._names.indexOf(name);\n\n        // The mappings coming from the consumer for the section have\n        // generated positions relative to the start of the section, so we\n        // need to offset them to be relative to the start of the concatenated\n        // generated file.\n        var adjustedMapping = {\n          source: source,\n          generatedLine: mapping.generatedLine +\n            (section.generatedOffset.generatedLine - 1),\n          generatedColumn: mapping.generatedColumn +\n            (section.generatedOffset.generatedLine === mapping.generatedLine\n            ? section.generatedOffset.generatedColumn - 1\n            : 0),\n          originalLine: mapping.originalLine,\n          originalColumn: mapping.originalColumn,\n          name: name\n        };\n\n        this.__generatedMappings.push(adjustedMapping);\n        if (typeof adjustedMapping.originalLine === 'number') {\n          this.__originalMappings.push(adjustedMapping);\n        }\n      }\n    }\n\n    quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);\n    quickSort(this.__originalMappings, util.compareByOriginalPositions);\n  };\n\nexports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/source-map-consumer.js\n// module id = 7\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nexports.GREATEST_LOWER_BOUND = 1;\nexports.LEAST_UPPER_BOUND = 2;\n\n/**\n * Recursive implementation of binary search.\n *\n * @param aLow Indices here and lower do not contain the needle.\n * @param aHigh Indices here and higher do not contain the needle.\n * @param aNeedle The element being searched for.\n * @param aHaystack The non-empty array being searched.\n * @param aCompare Function which takes two elements and returns -1, 0, or 1.\n * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or\n *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the\n *     closest element that is smaller than or greater than the one we are\n *     searching for, respectively, if the exact element cannot be found.\n */\nfunction recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {\n  // This function terminates when one of the following is true:\n  //\n  //   1. We find the exact element we are looking for.\n  //\n  //   2. We did not find the exact element, but we can return the index of\n  //      the next-closest element.\n  //\n  //   3. We did not find the exact element, and there is no next-closest\n  //      element than the one we are searching for, so we return -1.\n  var mid = Math.floor((aHigh - aLow) / 2) + aLow;\n  var cmp = aCompare(aNeedle, aHaystack[mid], true);\n  if (cmp === 0) {\n    // Found the element we are looking for.\n    return mid;\n  }\n  else if (cmp > 0) {\n    // Our needle is greater than aHaystack[mid].\n    if (aHigh - mid > 1) {\n      // The element is in the upper half.\n      return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);\n    }\n\n    // The exact needle element was not found in this haystack. Determine if\n    // we are in termination case (3) or (2) and return the appropriate thing.\n    if (aBias == exports.LEAST_UPPER_BOUND) {\n      return aHigh < aHaystack.length ? aHigh : -1;\n    } else {\n      return mid;\n    }\n  }\n  else {\n    // Our needle is less than aHaystack[mid].\n    if (mid - aLow > 1) {\n      // The element is in the lower half.\n      return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);\n    }\n\n    // we are in termination case (3) or (2) and return the appropriate thing.\n    if (aBias == exports.LEAST_UPPER_BOUND) {\n      return mid;\n    } else {\n      return aLow < 0 ? -1 : aLow;\n    }\n  }\n}\n\n/**\n * This is an implementation of binary search which will always try and return\n * the index of the closest element if there is no exact hit. This is because\n * mappings between original and generated line/col pairs are single points,\n * and there is an implicit region between each of them, so a miss just means\n * that you aren't on the very start of a region.\n *\n * @param aNeedle The element you are looking for.\n * @param aHaystack The array that is being searched.\n * @param aCompare A function which takes the needle and an element in the\n *     array and returns -1, 0, or 1 depending on whether the needle is less\n *     than, equal to, or greater than the element, respectively.\n * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or\n *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the\n *     closest element that is smaller than or greater than the one we are\n *     searching for, respectively, if the exact element cannot be found.\n *     Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.\n */\nexports.search = function search(aNeedle, aHaystack, aCompare, aBias) {\n  if (aHaystack.length === 0) {\n    return -1;\n  }\n\n  var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack,\n                              aCompare, aBias || exports.GREATEST_LOWER_BOUND);\n  if (index < 0) {\n    return -1;\n  }\n\n  // We have found either the exact element, or the next-closest element than\n  // the one we are searching for. However, there may be more than one such\n  // element. Make sure we always return the smallest of these.\n  while (index - 1 >= 0) {\n    if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {\n      break;\n    }\n    --index;\n  }\n\n  return index;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/binary-search.js\n// module id = 8\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\n// It turns out that some (most?) JavaScript engines don't self-host\n// `Array.prototype.sort`. This makes sense because C++ will likely remain\n// faster than JS when doing raw CPU-intensive sorting. However, when using a\n// custom comparator function, calling back and forth between the VM's C++ and\n// JIT'd JS is rather slow *and* loses JIT type information, resulting in\n// worse generated code for the comparator function than would be optimal. In\n// fact, when sorting with a comparator, these costs outweigh the benefits of\n// sorting in C++. By using our own JS-implemented Quick Sort (below), we get\n// a ~3500ms mean speed-up in `bench/bench.html`.\n\n/**\n * Swap the elements indexed by `x` and `y` in the array `ary`.\n *\n * @param {Array} ary\n *        The array.\n * @param {Number} x\n *        The index of the first item.\n * @param {Number} y\n *        The index of the second item.\n */\nfunction swap(ary, x, y) {\n  var temp = ary[x];\n  ary[x] = ary[y];\n  ary[y] = temp;\n}\n\n/**\n * Returns a random integer within the range `low .. high` inclusive.\n *\n * @param {Number} low\n *        The lower bound on the range.\n * @param {Number} high\n *        The upper bound on the range.\n */\nfunction randomIntInRange(low, high) {\n  return Math.round(low + (Math.random() * (high - low)));\n}\n\n/**\n * The Quick Sort algorithm.\n *\n * @param {Array} ary\n *        An array to sort.\n * @param {function} comparator\n *        Function to use to compare two items.\n * @param {Number} p\n *        Start index of the array\n * @param {Number} r\n *        End index of the array\n */\nfunction doQuickSort(ary, comparator, p, r) {\n  // If our lower bound is less than our upper bound, we (1) partition the\n  // array into two pieces and (2) recurse on each half. If it is not, this is\n  // the empty array and our base case.\n\n  if (p < r) {\n    // (1) Partitioning.\n    //\n    // The partitioning chooses a pivot between `p` and `r` and moves all\n    // elements that are less than or equal to the pivot to the before it, and\n    // all the elements that are greater than it after it. The effect is that\n    // once partition is done, the pivot is in the exact place it will be when\n    // the array is put in sorted order, and it will not need to be moved\n    // again. This runs in O(n) time.\n\n    // Always choose a random pivot so that an input array which is reverse\n    // sorted does not cause O(n^2) running time.\n    var pivotIndex = randomIntInRange(p, r);\n    var i = p - 1;\n\n    swap(ary, pivotIndex, r);\n    var pivot = ary[r];\n\n    // Immediately after `j` is incremented in this loop, the following hold\n    // true:\n    //\n    //   * Every element in `ary[p .. i]` is less than or equal to the pivot.\n    //\n    //   * Every element in `ary[i+1 .. j-1]` is greater than the pivot.\n    for (var j = p; j < r; j++) {\n      if (comparator(ary[j], pivot) <= 0) {\n        i += 1;\n        swap(ary, i, j);\n      }\n    }\n\n    swap(ary, i + 1, j);\n    var q = i + 1;\n\n    // (2) Recurse on each half.\n\n    doQuickSort(ary, comparator, p, q - 1);\n    doQuickSort(ary, comparator, q + 1, r);\n  }\n}\n\n/**\n * Sort the given array in-place with the given comparator function.\n *\n * @param {Array} ary\n *        An array to sort.\n * @param {function} comparator\n *        Function to use to compare two items.\n */\nexports.quickSort = function (ary, comparator) {\n  doQuickSort(ary, comparator, 0, ary.length - 1);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/quick-sort.js\n// module id = 9\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar SourceMapGenerator = require('./source-map-generator').SourceMapGenerator;\nvar util = require('./util');\n\n// Matches a Windows-style `\\r\\n` newline or a `\\n` newline used by all other\n// operating systems these days (capturing the result).\nvar REGEX_NEWLINE = /(\\r?\\n)/;\n\n// Newline character code for charCodeAt() comparisons\nvar NEWLINE_CODE = 10;\n\n// Private symbol for identifying `SourceNode`s when multiple versions of\n// the source-map library are loaded. This MUST NOT CHANGE across\n// versions!\nvar isSourceNode = \"$$$isSourceNode$$$\";\n\n/**\n * SourceNodes provide a way to abstract over interpolating/concatenating\n * snippets of generated JavaScript source code while maintaining the line and\n * column information associated with the original source code.\n *\n * @param aLine The original line number.\n * @param aColumn The original column number.\n * @param aSource The original source's filename.\n * @param aChunks Optional. An array of strings which are snippets of\n *        generated JS, or other SourceNodes.\n * @param aName The original identifier.\n */\nfunction SourceNode(aLine, aColumn, aSource, aChunks, aName) {\n  this.children = [];\n  this.sourceContents = {};\n  this.line = aLine == null ? null : aLine;\n  this.column = aColumn == null ? null : aColumn;\n  this.source = aSource == null ? null : aSource;\n  this.name = aName == null ? null : aName;\n  this[isSourceNode] = true;\n  if (aChunks != null) this.add(aChunks);\n}\n\n/**\n * Creates a SourceNode from generated code and a SourceMapConsumer.\n *\n * @param aGeneratedCode The generated code\n * @param aSourceMapConsumer The SourceMap for the generated code\n * @param aRelativePath Optional. The path that relative sources in the\n *        SourceMapConsumer should be relative to.\n */\nSourceNode.fromStringWithSourceMap =\n  function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {\n    // The SourceNode we want to fill with the generated code\n    // and the SourceMap\n    var node = new SourceNode();\n\n    // All even indices of this array are one line of the generated code,\n    // while all odd indices are the newlines between two adjacent lines\n    // (since `REGEX_NEWLINE` captures its match).\n    // Processed fragments are accessed by calling `shiftNextLine`.\n    var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);\n    var remainingLinesIndex = 0;\n    var shiftNextLine = function() {\n      var lineContents = getNextLine();\n      // The last line of a file might not have a newline.\n      var newLine = getNextLine() || \"\";\n      return lineContents + newLine;\n\n      function getNextLine() {\n        return remainingLinesIndex < remainingLines.length ?\n            remainingLines[remainingLinesIndex++] : undefined;\n      }\n    };\n\n    // We need to remember the position of \"remainingLines\"\n    var lastGeneratedLine = 1, lastGeneratedColumn = 0;\n\n    // The generate SourceNodes we need a code range.\n    // To extract it current and last mapping is used.\n    // Here we store the last mapping.\n    var lastMapping = null;\n\n    aSourceMapConsumer.eachMapping(function (mapping) {\n      if (lastMapping !== null) {\n        // We add the code from \"lastMapping\" to \"mapping\":\n        // First check if there is a new line in between.\n        if (lastGeneratedLine < mapping.generatedLine) {\n          // Associate first line with \"lastMapping\"\n          addMappingWithCode(lastMapping, shiftNextLine());\n          lastGeneratedLine++;\n          lastGeneratedColumn = 0;\n          // The remaining code is added without mapping\n        } else {\n          // There is no new line in between.\n          // Associate the code between \"lastGeneratedColumn\" and\n          // \"mapping.generatedColumn\" with \"lastMapping\"\n          var nextLine = remainingLines[remainingLinesIndex];\n          var code = nextLine.substr(0, mapping.generatedColumn -\n                                        lastGeneratedColumn);\n          remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn -\n                                              lastGeneratedColumn);\n          lastGeneratedColumn = mapping.generatedColumn;\n          addMappingWithCode(lastMapping, code);\n          // No more remaining code, continue\n          lastMapping = mapping;\n          return;\n        }\n      }\n      // We add the generated code until the first mapping\n      // to the SourceNode without any mapping.\n      // Each line is added as separate string.\n      while (lastGeneratedLine < mapping.generatedLine) {\n        node.add(shiftNextLine());\n        lastGeneratedLine++;\n      }\n      if (lastGeneratedColumn < mapping.generatedColumn) {\n        var nextLine = remainingLines[remainingLinesIndex];\n        node.add(nextLine.substr(0, mapping.generatedColumn));\n        remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);\n        lastGeneratedColumn = mapping.generatedColumn;\n      }\n      lastMapping = mapping;\n    }, this);\n    // We have processed all mappings.\n    if (remainingLinesIndex < remainingLines.length) {\n      if (lastMapping) {\n        // Associate the remaining code in the current line with \"lastMapping\"\n        addMappingWithCode(lastMapping, shiftNextLine());\n      }\n      // and add the remaining lines without any mapping\n      node.add(remainingLines.splice(remainingLinesIndex).join(\"\"));\n    }\n\n    // Copy sourcesContent into SourceNode\n    aSourceMapConsumer.sources.forEach(function (sourceFile) {\n      var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n      if (content != null) {\n        if (aRelativePath != null) {\n          sourceFile = util.join(aRelativePath, sourceFile);\n        }\n        node.setSourceContent(sourceFile, content);\n      }\n    });\n\n    return node;\n\n    function addMappingWithCode(mapping, code) {\n      if (mapping === null || mapping.source === undefined) {\n        node.add(code);\n      } else {\n        var source = aRelativePath\n          ? util.join(aRelativePath, mapping.source)\n          : mapping.source;\n        node.add(new SourceNode(mapping.originalLine,\n                                mapping.originalColumn,\n                                source,\n                                code,\n                                mapping.name));\n      }\n    }\n  };\n\n/**\n * Add a chunk of generated JS to this source node.\n *\n * @param aChunk A string snippet of generated JS code, another instance of\n *        SourceNode, or an array where each member is one of those things.\n */\nSourceNode.prototype.add = function SourceNode_add(aChunk) {\n  if (Array.isArray(aChunk)) {\n    aChunk.forEach(function (chunk) {\n      this.add(chunk);\n    }, this);\n  }\n  else if (aChunk[isSourceNode] || typeof aChunk === \"string\") {\n    if (aChunk) {\n      this.children.push(aChunk);\n    }\n  }\n  else {\n    throw new TypeError(\n      \"Expected a SourceNode, string, or an array of SourceNodes and strings. Got \" + aChunk\n    );\n  }\n  return this;\n};\n\n/**\n * Add a chunk of generated JS to the beginning of this source node.\n *\n * @param aChunk A string snippet of generated JS code, another instance of\n *        SourceNode, or an array where each member is one of those things.\n */\nSourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {\n  if (Array.isArray(aChunk)) {\n    for (var i = aChunk.length-1; i >= 0; i--) {\n      this.prepend(aChunk[i]);\n    }\n  }\n  else if (aChunk[isSourceNode] || typeof aChunk === \"string\") {\n    this.children.unshift(aChunk);\n  }\n  else {\n    throw new TypeError(\n      \"Expected a SourceNode, string, or an array of SourceNodes and strings. Got \" + aChunk\n    );\n  }\n  return this;\n};\n\n/**\n * Walk over the tree of JS snippets in this node and its children. The\n * walking function is called once for each snippet of JS and is passed that\n * snippet and the its original associated source's line/column location.\n *\n * @param aFn The traversal function.\n */\nSourceNode.prototype.walk = function SourceNode_walk(aFn) {\n  var chunk;\n  for (var i = 0, len = this.children.length; i < len; i++) {\n    chunk = this.children[i];\n    if (chunk[isSourceNode]) {\n      chunk.walk(aFn);\n    }\n    else {\n      if (chunk !== '') {\n        aFn(chunk, { source: this.source,\n                     line: this.line,\n                     column: this.column,\n                     name: this.name });\n      }\n    }\n  }\n};\n\n/**\n * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between\n * each of `this.children`.\n *\n * @param aSep The separator.\n */\nSourceNode.prototype.join = function SourceNode_join(aSep) {\n  var newChildren;\n  var i;\n  var len = this.children.length;\n  if (len > 0) {\n    newChildren = [];\n    for (i = 0; i < len-1; i++) {\n      newChildren.push(this.children[i]);\n      newChildren.push(aSep);\n    }\n    newChildren.push(this.children[i]);\n    this.children = newChildren;\n  }\n  return this;\n};\n\n/**\n * Call String.prototype.replace on the very right-most source snippet. Useful\n * for trimming whitespace from the end of a source node, etc.\n *\n * @param aPattern The pattern to replace.\n * @param aReplacement The thing to replace the pattern with.\n */\nSourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {\n  var lastChild = this.children[this.children.length - 1];\n  if (lastChild[isSourceNode]) {\n    lastChild.replaceRight(aPattern, aReplacement);\n  }\n  else if (typeof lastChild === 'string') {\n    this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);\n  }\n  else {\n    this.children.push(''.replace(aPattern, aReplacement));\n  }\n  return this;\n};\n\n/**\n * Set the source content for a source file. This will be added to the SourceMapGenerator\n * in the sourcesContent field.\n *\n * @param aSourceFile The filename of the source file\n * @param aSourceContent The content of the source file\n */\nSourceNode.prototype.setSourceContent =\n  function SourceNode_setSourceContent(aSourceFile, aSourceContent) {\n    this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;\n  };\n\n/**\n * Walk over the tree of SourceNodes. The walking function is called for each\n * source file content and is passed the filename and source content.\n *\n * @param aFn The traversal function.\n */\nSourceNode.prototype.walkSourceContents =\n  function SourceNode_walkSourceContents(aFn) {\n    for (var i = 0, len = this.children.length; i < len; i++) {\n      if (this.children[i][isSourceNode]) {\n        this.children[i].walkSourceContents(aFn);\n      }\n    }\n\n    var sources = Object.keys(this.sourceContents);\n    for (var i = 0, len = sources.length; i < len; i++) {\n      aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);\n    }\n  };\n\n/**\n * Return the string representation of this source node. Walks over the tree\n * and concatenates all the various snippets together to one string.\n */\nSourceNode.prototype.toString = function SourceNode_toString() {\n  var str = \"\";\n  this.walk(function (chunk) {\n    str += chunk;\n  });\n  return str;\n};\n\n/**\n * Returns the string representation of this source node along with a source\n * map.\n */\nSourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {\n  var generated = {\n    code: \"\",\n    line: 1,\n    column: 0\n  };\n  var map = new SourceMapGenerator(aArgs);\n  var sourceMappingActive = false;\n  var lastOriginalSource = null;\n  var lastOriginalLine = null;\n  var lastOriginalColumn = null;\n  var lastOriginalName = null;\n  this.walk(function (chunk, original) {\n    generated.code += chunk;\n    if (original.source !== null\n        && original.line !== null\n        && original.column !== null) {\n      if(lastOriginalSource !== original.source\n         || lastOriginalLine !== original.line\n         || lastOriginalColumn !== original.column\n         || lastOriginalName !== original.name) {\n        map.addMapping({\n          source: original.source,\n          original: {\n            line: original.line,\n            column: original.column\n          },\n          generated: {\n            line: generated.line,\n            column: generated.column\n          },\n          name: original.name\n        });\n      }\n      lastOriginalSource = original.source;\n      lastOriginalLine = original.line;\n      lastOriginalColumn = original.column;\n      lastOriginalName = original.name;\n      sourceMappingActive = true;\n    } else if (sourceMappingActive) {\n      map.addMapping({\n        generated: {\n          line: generated.line,\n          column: generated.column\n        }\n      });\n      lastOriginalSource = null;\n      sourceMappingActive = false;\n    }\n    for (var idx = 0, length = chunk.length; idx < length; idx++) {\n      if (chunk.charCodeAt(idx) === NEWLINE_CODE) {\n        generated.line++;\n        generated.column = 0;\n        // Mappings end at eol\n        if (idx + 1 === length) {\n          lastOriginalSource = null;\n          sourceMappingActive = false;\n        } else if (sourceMappingActive) {\n          map.addMapping({\n            source: original.source,\n            original: {\n              line: original.line,\n              column: original.column\n            },\n            generated: {\n              line: generated.line,\n              column: generated.column\n            },\n            name: original.name\n          });\n        }\n      } else {\n        generated.column++;\n      }\n    }\n  });\n  this.walkSourceContents(function (sourceFile, sourceContent) {\n    map.setSourceContent(sourceFile, sourceContent);\n  });\n\n  return { code: generated.code, map: map };\n};\n\nexports.SourceNode = SourceNode;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/source-node.js\n// module id = 10\n// module chunks = 0"],"sourceRoot":""}
\ No newline at end of file
diff --git a/node_modules/@babel/core/node_modules/source-map/lib/array-set.js b/node_modules/@babel/core/node_modules/source-map/lib/array-set.js
new file mode 100644
index 00000000..fbd5c81c
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/source-map/lib/array-set.js
@@ -0,0 +1,121 @@
+/* -*- 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 = require('./util');
+var has = Object.prototype.hasOwnProperty;
+var hasNativeMap = typeof Map !== "undefined";
+
+/**
+ * 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 = hasNativeMap ? new Map() : 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 hasNativeMap ? this._set.size : 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 = hasNativeMap ? aStr : util.toSetString(aStr);
+  var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
+  var idx = this._array.length;
+  if (!isDuplicate || aAllowDuplicates) {
+    this._array.push(aStr);
+  }
+  if (!isDuplicate) {
+    if (hasNativeMap) {
+      this._set.set(aStr, idx);
+    } else {
+      this._set[sStr] = idx;
+    }
+  }
+};
+
+/**
+ * Is the given string a member of this set?
+ *
+ * @param String aStr
+ */
+ArraySet.prototype.has = function ArraySet_has(aStr) {
+  if (hasNativeMap) {
+    return this._set.has(aStr);
+  } else {
+    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) {
+  if (hasNativeMap) {
+    var idx = this._set.get(aStr);
+    if (idx >= 0) {
+        return idx;
+    }
+  } else {
+    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;
diff --git a/node_modules/@babel/core/node_modules/source-map/lib/base64-vlq.js b/node_modules/@babel/core/node_modules/source-map/lib/base64-vlq.js
new file mode 100644
index 00000000..612b4040
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/source-map/lib/base64-vlq.js
@@ -0,0 +1,140 @@
+/* -*- 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 = require('./base64');
+
+// 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;
+};
diff --git a/node_modules/@babel/core/node_modules/source-map/lib/base64.js b/node_modules/@babel/core/node_modules/source-map/lib/base64.js
new file mode 100644
index 00000000..8aa86b30
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/source-map/lib/base64.js
@@ -0,0 +1,67 @@
+/* -*- 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;
+};
diff --git a/node_modules/@babel/core/node_modules/source-map/lib/binary-search.js b/node_modules/@babel/core/node_modules/source-map/lib/binary-search.js
new file mode 100644
index 00000000..010ac941
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/source-map/lib/binary-search.js
@@ -0,0 +1,111 @@
+/* -*- 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;
+};
diff --git a/node_modules/@babel/core/node_modules/source-map/lib/mapping-list.js b/node_modules/@babel/core/node_modules/source-map/lib/mapping-list.js
new file mode 100644
index 00000000..06d1274a
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/source-map/lib/mapping-list.js
@@ -0,0 +1,79 @@
+/* -*- 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 = require('./util');
+
+/**
+ * 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;
diff --git a/node_modules/@babel/core/node_modules/source-map/lib/quick-sort.js b/node_modules/@babel/core/node_modules/source-map/lib/quick-sort.js
new file mode 100644
index 00000000..6a7caadb
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/source-map/lib/quick-sort.js
@@ -0,0 +1,114 @@
+/* -*- 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);
+};
diff --git a/node_modules/@babel/core/node_modules/source-map/lib/source-map-consumer.js b/node_modules/@babel/core/node_modules/source-map/lib/source-map-consumer.js
new file mode 100644
index 00000000..6abcc280
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/source-map/lib/source-map-consumer.js
@@ -0,0 +1,1082 @@
+/* -*- 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 = require('./util');
+var binarySearch = require('./binary-search');
+var ArraySet = require('./array-set').ArraySet;
+var base64VLQ = require('./base64-vlq');
+var quickSort = require('./quick-sort').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;
diff --git a/node_modules/@babel/core/node_modules/source-map/lib/source-map-generator.js b/node_modules/@babel/core/node_modules/source-map/lib/source-map-generator.js
new file mode 100644
index 00000000..aff1e7fb
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/source-map/lib/source-map-generator.js
@@ -0,0 +1,416 @@
+/* -*- 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 = require('./base64-vlq');
+var util = require('./util');
+var ArraySet = require('./array-set').ArraySet;
+var MappingList = require('./mapping-list').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) {
+    // When aOriginal is truthy but has empty values for .line and .column,
+    // it is most likely a programmer error. In this case we throw a very
+    // specific error message to try to guide them the right way.
+    // For example: https://github.com/Polymer/polymer-bundler/pull/519
+    if (aOriginal && typeof aOriginal.line !== 'number' && typeof aOriginal.column !== 'number') {
+        throw new Error(
+            'original.line and original.column are not numbers -- you probably meant to omit ' +
+            'the original mapping entirely and only map the generated position. If so, pass ' +
+            'null for the original mapping instead of an object with empty or null values.'
+        );
+    }
+
+    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;
diff --git a/node_modules/@babel/core/node_modules/source-map/lib/source-node.js b/node_modules/@babel/core/node_modules/source-map/lib/source-node.js
new file mode 100644
index 00000000..d196a53f
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/source-map/lib/source-node.js
@@ -0,0 +1,413 @@
+/* -*- 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 = require('./source-map-generator').SourceMapGenerator;
+var util = require('./util');
+
+// 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 accessed by calling `shiftNextLine`.
+    var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
+    var remainingLinesIndex = 0;
+    var shiftNextLine = function() {
+      var lineContents = getNextLine();
+      // The last line of a file might not have a newline.
+      var newLine = getNextLine() || "";
+      return lineContents + newLine;
+
+      function getNextLine() {
+        return remainingLinesIndex < remainingLines.length ?
+            remainingLines[remainingLinesIndex++] : undefined;
+      }
+    };
+
+    // 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[remainingLinesIndex];
+          var code = nextLine.substr(0, mapping.generatedColumn -
+                                        lastGeneratedColumn);
+          remainingLines[remainingLinesIndex] = 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[remainingLinesIndex];
+        node.add(nextLine.substr(0, mapping.generatedColumn));
+        remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
+        lastGeneratedColumn = mapping.generatedColumn;
+      }
+      lastMapping = mapping;
+    }, this);
+    // We have processed all mappings.
+    if (remainingLinesIndex < remainingLines.length) {
+      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.splice(remainingLinesIndex).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) {
+        node.add(code);
+      } else {
+        var source = aRelativePath
+          ? util.join(aRelativePath, mapping.source)
+          : mapping.source;
+        node.add(new SourceNode(mapping.originalLine,
+                                mapping.originalColumn,
+                                source,
+                                code,
+                                mapping.name));
+      }
+    }
+  };
+
+/**
+ * Add a chunk of generated JS to this source node.
+ *
+ * @param aChunk A string snippet of generated JS code, another instance of
+ *        SourceNode, or an array where each member is one of those things.
+ */
+SourceNode.prototype.add = function SourceNode_add(aChunk) {
+  if (Array.isArray(aChunk)) {
+    aChunk.forEach(function (chunk) {
+      this.add(chunk);
+    }, this);
+  }
+  else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+    if (aChunk) {
+      this.children.push(aChunk);
+    }
+  }
+  else {
+    throw new TypeError(
+      "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+    );
+  }
+  return this;
+};
+
+/**
+ * Add a chunk of generated JS to the beginning of this source node.
+ *
+ * @param aChunk A string snippet of generated JS code, another instance of
+ *        SourceNode, or an array where each member is one of those things.
+ */
+SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
+  if (Array.isArray(aChunk)) {
+    for (var i = aChunk.length-1; i >= 0; i--) {
+      this.prepend(aChunk[i]);
+    }
+  }
+  else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+    this.children.unshift(aChunk);
+  }
+  else {
+    throw new TypeError(
+      "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+    );
+  }
+  return this;
+};
+
+/**
+ * Walk over the tree of JS snippets in this node and its children. The
+ * walking function is called once for each snippet of JS and is passed that
+ * snippet and the its original associated source's line/column location.
+ *
+ * @param aFn The traversal function.
+ */
+SourceNode.prototype.walk = function SourceNode_walk(aFn) {
+  var chunk;
+  for (var i = 0, len = this.children.length; i < len; i++) {
+    chunk = this.children[i];
+    if (chunk[isSourceNode]) {
+      chunk.walk(aFn);
+    }
+    else {
+      if (chunk !== '') {
+        aFn(chunk, { source: this.source,
+                     line: this.line,
+                     column: this.column,
+                     name: this.name });
+      }
+    }
+  }
+};
+
+/**
+ * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
+ * each of `this.children`.
+ *
+ * @param aSep The separator.
+ */
+SourceNode.prototype.join = function SourceNode_join(aSep) {
+  var newChildren;
+  var i;
+  var len = this.children.length;
+  if (len > 0) {
+    newChildren = [];
+    for (i = 0; i < len-1; i++) {
+      newChildren.push(this.children[i]);
+      newChildren.push(aSep);
+    }
+    newChildren.push(this.children[i]);
+    this.children = newChildren;
+  }
+  return this;
+};
+
+/**
+ * Call String.prototype.replace on the very right-most source snippet. Useful
+ * for trimming whitespace from the end of a source node, etc.
+ *
+ * @param aPattern The pattern to replace.
+ * @param aReplacement The thing to replace the pattern with.
+ */
+SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
+  var lastChild = this.children[this.children.length - 1];
+  if (lastChild[isSourceNode]) {
+    lastChild.replaceRight(aPattern, aReplacement);
+  }
+  else if (typeof lastChild === 'string') {
+    this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
+  }
+  else {
+    this.children.push(''.replace(aPattern, aReplacement));
+  }
+  return this;
+};
+
+/**
+ * Set the source content for a source file. This will be added to the SourceMapGenerator
+ * in the sourcesContent field.
+ *
+ * @param aSourceFile The filename of the source file
+ * @param aSourceContent The content of the source file
+ */
+SourceNode.prototype.setSourceContent =
+  function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
+    this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
+  };
+
+/**
+ * Walk over the tree of SourceNodes. The walking function is called for each
+ * source file content and is passed the filename and source content.
+ *
+ * @param aFn The traversal function.
+ */
+SourceNode.prototype.walkSourceContents =
+  function SourceNode_walkSourceContents(aFn) {
+    for (var i = 0, len = this.children.length; i < len; i++) {
+      if (this.children[i][isSourceNode]) {
+        this.children[i].walkSourceContents(aFn);
+      }
+    }
+
+    var sources = Object.keys(this.sourceContents);
+    for (var i = 0, len = sources.length; i < len; i++) {
+      aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
+    }
+  };
+
+/**
+ * Return the string representation of this source node. Walks over the tree
+ * and concatenates all the various snippets together to one string.
+ */
+SourceNode.prototype.toString = function SourceNode_toString() {
+  var str = "";
+  this.walk(function (chunk) {
+    str += chunk;
+  });
+  return str;
+};
+
+/**
+ * Returns the string representation of this source node along with a source
+ * map.
+ */
+SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
+  var generated = {
+    code: "",
+    line: 1,
+    column: 0
+  };
+  var map = new SourceMapGenerator(aArgs);
+  var sourceMappingActive = false;
+  var lastOriginalSource = null;
+  var lastOriginalLine = null;
+  var lastOriginalColumn = null;
+  var lastOriginalName = null;
+  this.walk(function (chunk, original) {
+    generated.code += chunk;
+    if (original.source !== null
+        && original.line !== null
+        && original.column !== null) {
+      if(lastOriginalSource !== original.source
+         || lastOriginalLine !== original.line
+         || lastOriginalColumn !== original.column
+         || lastOriginalName !== original.name) {
+        map.addMapping({
+          source: original.source,
+          original: {
+            line: original.line,
+            column: original.column
+          },
+          generated: {
+            line: generated.line,
+            column: generated.column
+          },
+          name: original.name
+        });
+      }
+      lastOriginalSource = original.source;
+      lastOriginalLine = original.line;
+      lastOriginalColumn = original.column;
+      lastOriginalName = original.name;
+      sourceMappingActive = true;
+    } else if (sourceMappingActive) {
+      map.addMapping({
+        generated: {
+          line: generated.line,
+          column: generated.column
+        }
+      });
+      lastOriginalSource = null;
+      sourceMappingActive = false;
+    }
+    for (var idx = 0, length = chunk.length; idx < length; idx++) {
+      if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
+        generated.line++;
+        generated.column = 0;
+        // Mappings end at eol
+        if (idx + 1 === length) {
+          lastOriginalSource = null;
+          sourceMappingActive = false;
+        } else if (sourceMappingActive) {
+          map.addMapping({
+            source: original.source,
+            original: {
+              line: original.line,
+              column: original.column
+            },
+            generated: {
+              line: generated.line,
+              column: generated.column
+            },
+            name: original.name
+          });
+        }
+      } else {
+        generated.column++;
+      }
+    }
+  });
+  this.walkSourceContents(function (sourceFile, sourceContent) {
+    map.setSourceContent(sourceFile, sourceContent);
+  });
+
+  return { code: generated.code, map: map };
+};
+
+exports.SourceNode = SourceNode;
diff --git a/node_modules/@babel/core/node_modules/source-map/lib/util.js b/node_modules/@babel/core/node_modules/source-map/lib/util.js
new file mode 100644
index 00000000..44e0e452
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/source-map/lib/util.js
@@ -0,0 +1,417 @@
+/* -*- 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 consecutive 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;
diff --git a/node_modules/@babel/core/node_modules/source-map/package.json b/node_modules/@babel/core/node_modules/source-map/package.json
new file mode 100644
index 00000000..048e3ae8
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/source-map/package.json
@@ -0,0 +1,72 @@
+{
+  "name": "source-map",
+  "description": "Generates and consumes source maps",
+  "version": "0.5.7",
+  "homepage": "https://github.com/mozilla/source-map",
+  "author": "Nick Fitzgerald <nfitzgerald@mozilla.com>",
+  "contributors": [
+    "Tobias Koppers <tobias.koppers@googlemail.com>",
+    "Duncan Beevers <duncan@dweebd.com>",
+    "Stephen Crane <scrane@mozilla.com>",
+    "Ryan Seddon <seddon.ryan@gmail.com>",
+    "Miles Elam <miles.elam@deem.com>",
+    "Mihai Bazon <mihai.bazon@gmail.com>",
+    "Michael Ficarra <github.public.email@michael.ficarra.me>",
+    "Todd Wolfson <todd@twolfson.com>",
+    "Alexander Solovyov <alexander@solovyov.net>",
+    "Felix Gnass <fgnass@gmail.com>",
+    "Conrad Irwin <conrad.irwin@gmail.com>",
+    "usrbincc <usrbincc@yahoo.com>",
+    "David Glasser <glasser@davidglasser.net>",
+    "Chase Douglas <chase@newrelic.com>",
+    "Evan Wallace <evan.exe@gmail.com>",
+    "Heather Arthur <fayearthur@gmail.com>",
+    "Hugh Kennedy <hughskennedy@gmail.com>",
+    "David Glasser <glasser@davidglasser.net>",
+    "Simon Lydell <simon.lydell@gmail.com>",
+    "Jmeas Smith <jellyes2@gmail.com>",
+    "Michael Z Goddard <mzgoddard@gmail.com>",
+    "azu <azu@users.noreply.github.com>",
+    "John Gozde <john@gozde.ca>",
+    "Adam Kirkton <akirkton@truefitinnovation.com>",
+    "Chris Montgomery <christopher.montgomery@dowjones.com>",
+    "J. Ryan Stinnett <jryans@gmail.com>",
+    "Jack Herrington <jherrington@walmartlabs.com>",
+    "Chris Truter <jeffpalentine@gmail.com>",
+    "Daniel Espeset <daniel@danielespeset.com>",
+    "Jamie Wong <jamie.lf.wong@gmail.com>",
+    "Eddy Bruël <ejpbruel@mozilla.com>",
+    "Hawken Rives <hawkrives@gmail.com>",
+    "Gilad Peleg <giladp007@gmail.com>",
+    "djchie <djchie.dev@gmail.com>",
+    "Gary Ye <garysye@gmail.com>",
+    "Nicolas Lalevée <nicolas.lalevee@hibnet.org>"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/mozilla/source-map.git"
+  },
+  "main": "./source-map.js",
+  "files": [
+    "source-map.js",
+    "lib/",
+    "dist/source-map.debug.js",
+    "dist/source-map.js",
+    "dist/source-map.min.js",
+    "dist/source-map.min.js.map"
+  ],
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "license": "BSD-3-Clause",
+  "scripts": {
+    "test": "npm run build && node test/run-tests.js",
+    "build": "webpack --color",
+    "toc": "doctoc --title '## Table of Contents' README.md && doctoc --title '## Table of Contents' CONTRIBUTING.md"
+  },
+  "devDependencies": {
+    "doctoc": "^0.15.0",
+    "webpack": "^1.12.0"
+  },
+  "typings": "source-map"
+}
diff --git a/node_modules/@babel/core/node_modules/source-map/source-map.js b/node_modules/@babel/core/node_modules/source-map/source-map.js
new file mode 100644
index 00000000..bc88fe82
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/source-map/source-map.js
@@ -0,0 +1,8 @@
+/*
+ * 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 = require('./lib/source-map-generator').SourceMapGenerator;
+exports.SourceMapConsumer = require('./lib/source-map-consumer').SourceMapConsumer;
+exports.SourceNode = require('./lib/source-node').SourceNode;
diff --git a/node_modules/@babel/core/package.json b/node_modules/@babel/core/package.json
new file mode 100644
index 00000000..10b801eb
--- /dev/null
+++ b/node_modules/@babel/core/package.json
@@ -0,0 +1,51 @@
+{
+  "name": "@babel/core",
+  "version": "7.0.0-beta.47",
+  "description": "Babel compiler core.",
+  "main": "lib/index.js",
+  "author": "Sebastian McKenzie <sebmck@gmail.com>",
+  "homepage": "https://babeljs.io/",
+  "license": "MIT",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-core",
+  "keywords": [
+    "6to5",
+    "babel",
+    "classes",
+    "const",
+    "es6",
+    "harmony",
+    "let",
+    "modules",
+    "transpile",
+    "transpiler",
+    "var",
+    "babel-core",
+    "compiler"
+  ],
+  "browser": {
+    "./lib/config/files/index.js": "./lib/config/files/index-browser.js",
+    "./lib/transform-file.js": "./lib/transform-file-browser.js",
+    "./lib/transform-file-sync.js": "./lib/transform-file-sync-browser.js"
+  },
+  "dependencies": {
+    "@babel/code-frame": "7.0.0-beta.47",
+    "@babel/generator": "7.0.0-beta.47",
+    "@babel/helpers": "7.0.0-beta.47",
+    "@babel/template": "7.0.0-beta.47",
+    "@babel/traverse": "7.0.0-beta.47",
+    "@babel/types": "7.0.0-beta.47",
+    "babylon": "7.0.0-beta.47",
+    "convert-source-map": "^1.1.0",
+    "debug": "^3.1.0",
+    "json5": "^0.5.0",
+    "lodash": "^4.17.5",
+    "micromatch": "^2.3.11",
+    "resolve": "^1.3.2",
+    "semver": "^5.4.1",
+    "source-map": "^0.5.0"
+  },
+  "devDependencies": {
+    "@babel/helper-transform-fixture-test-runner": "7.0.0-beta.47",
+    "@babel/register": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/generator/README.md b/node_modules/@babel/generator/README.md
new file mode 100644
index 00000000..44725b60
--- /dev/null
+++ b/node_modules/@babel/generator/README.md
@@ -0,0 +1,78 @@
+# @babel/generator
+
+> Turns a [Babylon AST](https://github.com/babel/babel/blob/master/packages/babylon/ast/spec.md) into code.
+
+## Install
+
+```sh
+npm install --save-dev @babel/generator
+```
+
+## Usage
+
+```js
+import {parse} from 'babylon';
+import generate from '@babel/generator';
+
+const code = 'class Example {}';
+const ast = parse(code);
+
+const output = generate(ast, { /* options */ }, code);
+```
+
+## Options
+
+Options for formatting output:
+
+name                   | type     | default         | description
+-----------------------|----------|-----------------|--------------------------------------------------------------------------
+auxiliaryCommentBefore | string   |                 | Optional string to add as a block comment at the start of the output file
+auxiliaryCommentAfter  | string   |                 | Optional string to add as a block comment at the end of the output file
+shouldPrintComment     | function | `opts.comments` | Function that takes a comment (as a string) and returns `true` if the comment should be included in the output.  By default, comments are included if `opts.comments` is `true` or if `opts.minifed` is `false` and the comment contains `@preserve` or `@license`
+retainLines            | boolean  | `false`         | Attempt to use the same line numbers in the output code as in the source code (helps preserve stack traces)
+retainFunctionParens   | boolean  | `false`         | Retain parens around function expressions (could be used to change engine parsing behavior)
+comments               | boolean  | `true`          | Should comments be included in output
+compact                | boolean or `'auto'` | `opts.minified` | Set to `true` to avoid adding whitespace for formatting
+minified               | boolean  | `false`         | Should the output be minified
+concise                | boolean  | `false`         | Set to `true` to reduce whitespace (but not as much as `opts.compact`)
+filename               | string   |                 | Used in warning messages
+jsonCompatibleStrings  | boolean  | `false`         | Set to true to run `jsesc` with "json": true to print "\u00A9" vs. "©";
+
+Options for source maps:
+
+name                   | type     | default         | description
+-----------------------|----------|-----------------|--------------------------------------------------------------------------
+sourceMaps             | boolean  | `false`         | Enable generating source maps
+sourceRoot             | string   |                 | A root for all relative URLs in the source map
+sourceFileName         | string   |                 | The filename for the source code (i.e. the code in the `code` argument).  This will only be used if `code` is a string.
+
+## AST from Multiple Sources
+
+In most cases, Babel does a 1:1 transformation of input-file to output-file.  However,
+you may be dealing with AST constructed from multiple sources - JS files, templates, etc.
+If this is the case, and you want the sourcemaps to reflect the correct sources, you'll need
+to pass an object to `generate` as the `code` parameter.  Keys
+should be the source filenames, and values should be the source content.
+
+Here's an example of what that might look like:
+
+```js
+import {parse} from 'babylon';
+import generate from '@babel/generator';
+
+const a = 'var a = 1;';
+const b = 'var b = 2;';
+const astA = parse(a, { sourceFilename: 'a.js' });
+const astB = parse(b, { sourceFilename: 'b.js' });
+const ast = {
+  type: 'Program',
+  body: [].concat(astA.program.body, astB.program.body)
+};
+
+const { code, map } = generate(ast, { sourceMaps: true }, {
+  'a.js': a,
+  'b.js': b
+});
+
+// Sourcemap will point to both a.js and b.js where appropriate.
+```
diff --git a/node_modules/@babel/generator/lib/buffer.js b/node_modules/@babel/generator/lib/buffer.js
new file mode 100644
index 00000000..4dc12b9d
--- /dev/null
+++ b/node_modules/@babel/generator/lib/buffer.js
@@ -0,0 +1,209 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _trimRight() {
+  const data = _interopRequireDefault(require("trim-right"));
+
+  _trimRight = function _trimRight() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const SPACES_RE = /^[ \t]+$/;
+
+class Buffer {
+  constructor(map) {
+    this._map = null;
+    this._buf = [];
+    this._last = "";
+    this._queue = [];
+    this._position = {
+      line: 1,
+      column: 0
+    };
+    this._sourcePosition = {
+      identifierName: null,
+      line: null,
+      column: null,
+      filename: null
+    };
+    this._map = map;
+  }
+
+  get() {
+    this._flush();
+
+    const map = this._map;
+    const result = {
+      code: (0, _trimRight().default)(this._buf.join("")),
+      map: null,
+      rawMappings: map && map.getRawMappings()
+    };
+
+    if (map) {
+      Object.defineProperty(result, "map", {
+        configurable: true,
+        enumerable: true,
+
+        get() {
+          return this.map = map.get();
+        },
+
+        set(value) {
+          Object.defineProperty(this, "map", {
+            value,
+            writable: true
+          });
+        }
+
+      });
+    }
+
+    return result;
+  }
+
+  append(str) {
+    this._flush();
+
+    const _this$_sourcePosition = this._sourcePosition,
+          line = _this$_sourcePosition.line,
+          column = _this$_sourcePosition.column,
+          filename = _this$_sourcePosition.filename,
+          identifierName = _this$_sourcePosition.identifierName;
+
+    this._append(str, line, column, identifierName, filename);
+  }
+
+  queue(str) {
+    if (str === "\n") {
+      while (this._queue.length > 0 && SPACES_RE.test(this._queue[0][0])) {
+        this._queue.shift();
+      }
+    }
+
+    const _this$_sourcePosition2 = this._sourcePosition,
+          line = _this$_sourcePosition2.line,
+          column = _this$_sourcePosition2.column,
+          filename = _this$_sourcePosition2.filename,
+          identifierName = _this$_sourcePosition2.identifierName;
+
+    this._queue.unshift([str, line, column, identifierName, filename]);
+  }
+
+  _flush() {
+    let item;
+
+    while (item = this._queue.pop()) this._append(...item);
+  }
+
+  _append(str, line, column, identifierName, filename) {
+    if (this._map && str[0] !== "\n") {
+      this._map.mark(this._position.line, this._position.column, line, column, identifierName, filename);
+    }
+
+    this._buf.push(str);
+
+    this._last = str[str.length - 1];
+
+    for (let i = 0; i < str.length; i++) {
+      if (str[i] === "\n") {
+        this._position.line++;
+        this._position.column = 0;
+      } else {
+        this._position.column++;
+      }
+    }
+  }
+
+  removeTrailingNewline() {
+    if (this._queue.length > 0 && this._queue[0][0] === "\n") {
+      this._queue.shift();
+    }
+  }
+
+  removeLastSemicolon() {
+    if (this._queue.length > 0 && this._queue[0][0] === ";") {
+      this._queue.shift();
+    }
+  }
+
+  endsWith(suffix) {
+    if (suffix.length === 1) {
+      let last;
+
+      if (this._queue.length > 0) {
+        const str = this._queue[0][0];
+        last = str[str.length - 1];
+      } else {
+        last = this._last;
+      }
+
+      return last === suffix;
+    }
+
+    const end = this._last + this._queue.reduce((acc, item) => item[0] + acc, "");
+
+    if (suffix.length <= end.length) {
+      return end.slice(-suffix.length) === suffix;
+    }
+
+    return false;
+  }
+
+  hasContent() {
+    return this._queue.length > 0 || !!this._last;
+  }
+
+  source(prop, loc) {
+    if (prop && !loc) return;
+    const pos = loc ? loc[prop] : null;
+    this._sourcePosition.identifierName = loc && loc.identifierName || null;
+    this._sourcePosition.line = pos ? pos.line : null;
+    this._sourcePosition.column = pos ? pos.column : null;
+    this._sourcePosition.filename = loc && loc.filename || null;
+  }
+
+  withSource(prop, loc, cb) {
+    if (!this._map) return cb();
+    const originalLine = this._sourcePosition.line;
+    const originalColumn = this._sourcePosition.column;
+    const originalFilename = this._sourcePosition.filename;
+    const originalIdentifierName = this._sourcePosition.identifierName;
+    this.source(prop, loc);
+    cb();
+    this._sourcePosition.line = originalLine;
+    this._sourcePosition.column = originalColumn;
+    this._sourcePosition.filename = originalFilename;
+    this._sourcePosition.identifierName = originalIdentifierName;
+  }
+
+  getCurrentColumn() {
+    const extra = this._queue.reduce((acc, item) => item[0] + acc, "");
+
+    const lastIndex = extra.lastIndexOf("\n");
+    return lastIndex === -1 ? this._position.column + extra.length : extra.length - 1 - lastIndex;
+  }
+
+  getCurrentLine() {
+    const extra = this._queue.reduce((acc, item) => item[0] + acc, "");
+
+    let count = 0;
+
+    for (let i = 0; i < extra.length; i++) {
+      if (extra[i] === "\n") count++;
+    }
+
+    return this._position.line + count;
+  }
+
+}
+
+exports.default = Buffer;
\ No newline at end of file
diff --git a/node_modules/@babel/generator/lib/generators/base.js b/node_modules/@babel/generator/lib/generators/base.js
new file mode 100644
index 00000000..9e3a8c9c
--- /dev/null
+++ b/node_modules/@babel/generator/lib/generators/base.js
@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.File = File;
+exports.Program = Program;
+exports.BlockStatement = BlockStatement;
+exports.Noop = Noop;
+exports.Directive = Directive;
+Object.defineProperty(exports, "DirectiveLiteral", {
+  enumerable: true,
+  get: function get() {
+    return _types.StringLiteral;
+  }
+});
+
+var _types = require("./types");
+
+function File(node) {
+  this.print(node.program, node);
+}
+
+function Program(node) {
+  this.printInnerComments(node, false);
+  this.printSequence(node.directives, node);
+  if (node.directives && node.directives.length) this.newline();
+  this.printSequence(node.body, node);
+}
+
+function BlockStatement(node) {
+  this.token("{");
+  this.printInnerComments(node);
+  const hasDirectives = node.directives && node.directives.length;
+
+  if (node.body.length || hasDirectives) {
+    this.newline();
+    this.printSequence(node.directives, node, {
+      indent: true
+    });
+    if (hasDirectives) this.newline();
+    this.printSequence(node.body, node, {
+      indent: true
+    });
+    this.removeTrailingNewline();
+    this.source("end", node.loc);
+    if (!this.endsWith("\n")) this.newline();
+    this.rightBrace();
+  } else {
+    this.source("end", node.loc);
+    this.token("}");
+  }
+}
+
+function Noop() {}
+
+function Directive(node) {
+  this.print(node.value, node);
+  this.semicolon();
+}
\ No newline at end of file
diff --git a/node_modules/@babel/generator/lib/generators/classes.js b/node_modules/@babel/generator/lib/generators/classes.js
new file mode 100644
index 00000000..a6d006c2
--- /dev/null
+++ b/node_modules/@babel/generator/lib/generators/classes.js
@@ -0,0 +1,181 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ClassExpression = exports.ClassDeclaration = ClassDeclaration;
+exports.ClassBody = ClassBody;
+exports.ClassProperty = ClassProperty;
+exports.ClassPrivateProperty = ClassPrivateProperty;
+exports.ClassMethod = ClassMethod;
+exports._classMethodHead = _classMethodHead;
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function ClassDeclaration(node, parent) {
+  if (!t().isExportDefaultDeclaration(parent) && !t().isExportNamedDeclaration(parent)) {
+    this.printJoin(node.decorators, node);
+  }
+
+  if (node.declare) {
+    this.word("declare");
+    this.space();
+  }
+
+  if (node.abstract) {
+    this.word("abstract");
+    this.space();
+  }
+
+  this.word("class");
+
+  if (node.id) {
+    this.space();
+    this.print(node.id, node);
+  }
+
+  this.print(node.typeParameters, node);
+
+  if (node.superClass) {
+    this.space();
+    this.word("extends");
+    this.space();
+    this.print(node.superClass, node);
+    this.print(node.superTypeParameters, node);
+  }
+
+  if (node.implements) {
+    this.space();
+    this.word("implements");
+    this.space();
+    this.printList(node.implements, node);
+  }
+
+  this.space();
+  this.print(node.body, node);
+}
+
+function ClassBody(node) {
+  this.token("{");
+  this.printInnerComments(node);
+
+  if (node.body.length === 0) {
+    this.token("}");
+  } else {
+    this.newline();
+    this.indent();
+    this.printSequence(node.body, node);
+    this.dedent();
+    if (!this.endsWith("\n")) this.newline();
+    this.rightBrace();
+  }
+}
+
+function ClassProperty(node) {
+  this.printJoin(node.decorators, node);
+
+  if (node.accessibility) {
+    this.word(node.accessibility);
+    this.space();
+  }
+
+  if (node.static) {
+    this.word("static");
+    this.space();
+  }
+
+  if (node.abstract) {
+    this.word("abstract");
+    this.space();
+  }
+
+  if (node.readonly) {
+    this.word("readonly");
+    this.space();
+  }
+
+  if (node.computed) {
+    this.token("[");
+    this.print(node.key, node);
+    this.token("]");
+  } else {
+    this._variance(node);
+
+    this.print(node.key, node);
+  }
+
+  if (node.optional) {
+    this.token("?");
+  }
+
+  if (node.definite) {
+    this.token("!");
+  }
+
+  this.print(node.typeAnnotation, node);
+
+  if (node.value) {
+    this.space();
+    this.token("=");
+    this.space();
+    this.print(node.value, node);
+  }
+
+  this.semicolon();
+}
+
+function ClassPrivateProperty(node) {
+  if (node.static) {
+    this.word("static");
+    this.space();
+  }
+
+  this.print(node.key, node);
+
+  if (node.value) {
+    this.space();
+    this.token("=");
+    this.space();
+    this.print(node.value, node);
+  }
+
+  this.semicolon();
+}
+
+function ClassMethod(node) {
+  this._classMethodHead(node);
+
+  this.space();
+  this.print(node.body, node);
+}
+
+function _classMethodHead(node) {
+  this.printJoin(node.decorators, node);
+
+  if (node.accessibility) {
+    this.word(node.accessibility);
+    this.space();
+  }
+
+  if (node.abstract) {
+    this.word("abstract");
+    this.space();
+  }
+
+  if (node.static) {
+    this.word("static");
+    this.space();
+  }
+
+  this._methodHead(node);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/generator/lib/generators/expressions.js b/node_modules/@babel/generator/lib/generators/expressions.js
new file mode 100644
index 00000000..bab9a75f
--- /dev/null
+++ b/node_modules/@babel/generator/lib/generators/expressions.js
@@ -0,0 +1,289 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UnaryExpression = UnaryExpression;
+exports.DoExpression = DoExpression;
+exports.ParenthesizedExpression = ParenthesizedExpression;
+exports.UpdateExpression = UpdateExpression;
+exports.ConditionalExpression = ConditionalExpression;
+exports.NewExpression = NewExpression;
+exports.SequenceExpression = SequenceExpression;
+exports.ThisExpression = ThisExpression;
+exports.Super = Super;
+exports.Decorator = Decorator;
+exports.OptionalMemberExpression = OptionalMemberExpression;
+exports.OptionalCallExpression = OptionalCallExpression;
+exports.CallExpression = CallExpression;
+exports.Import = Import;
+exports.EmptyStatement = EmptyStatement;
+exports.ExpressionStatement = ExpressionStatement;
+exports.AssignmentPattern = AssignmentPattern;
+exports.LogicalExpression = exports.BinaryExpression = exports.AssignmentExpression = AssignmentExpression;
+exports.BindExpression = BindExpression;
+exports.MemberExpression = MemberExpression;
+exports.MetaProperty = MetaProperty;
+exports.PrivateName = PrivateName;
+exports.AwaitExpression = exports.YieldExpression = void 0;
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+var n = _interopRequireWildcard(require("../node"));
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function UnaryExpression(node) {
+  if (node.operator === "void" || node.operator === "delete" || node.operator === "typeof") {
+    this.word(node.operator);
+    this.space();
+  } else {
+    this.token(node.operator);
+  }
+
+  this.print(node.argument, node);
+}
+
+function DoExpression(node) {
+  this.word("do");
+  this.space();
+  this.print(node.body, node);
+}
+
+function ParenthesizedExpression(node) {
+  this.token("(");
+  this.print(node.expression, node);
+  this.token(")");
+}
+
+function UpdateExpression(node) {
+  if (node.prefix) {
+    this.token(node.operator);
+    this.print(node.argument, node);
+  } else {
+    this.startTerminatorless(true);
+    this.print(node.argument, node);
+    this.endTerminatorless();
+    this.token(node.operator);
+  }
+}
+
+function ConditionalExpression(node) {
+  this.print(node.test, node);
+  this.space();
+  this.token("?");
+  this.space();
+  this.print(node.consequent, node);
+  this.space();
+  this.token(":");
+  this.space();
+  this.print(node.alternate, node);
+}
+
+function NewExpression(node, parent) {
+  this.word("new");
+  this.space();
+  this.print(node.callee, node);
+
+  if (this.format.minified && node.arguments.length === 0 && !node.optional && !t().isCallExpression(parent, {
+    callee: node
+  }) && !t().isMemberExpression(parent) && !t().isNewExpression(parent)) {
+    return;
+  }
+
+  this.print(node.typeParameters, node);
+
+  if (node.optional) {
+    this.token("?.");
+  }
+
+  this.token("(");
+  this.printList(node.arguments, node);
+  this.token(")");
+}
+
+function SequenceExpression(node) {
+  this.printList(node.expressions, node);
+}
+
+function ThisExpression() {
+  this.word("this");
+}
+
+function Super() {
+  this.word("super");
+}
+
+function Decorator(node) {
+  this.token("@");
+  this.print(node.callee, node);
+  this.newline();
+}
+
+function OptionalMemberExpression(node) {
+  this.print(node.object, node);
+
+  if (!node.computed && t().isMemberExpression(node.property)) {
+    throw new TypeError("Got a MemberExpression for MemberExpression property");
+  }
+
+  let computed = node.computed;
+
+  if (t().isLiteral(node.property) && typeof node.property.value === "number") {
+    computed = true;
+  }
+
+  if (node.optional) {
+    this.token("?.");
+  }
+
+  if (computed) {
+    this.token("[");
+    this.print(node.property, node);
+    this.token("]");
+  } else {
+    if (!node.optional) {
+      this.token(".");
+    }
+
+    this.print(node.property, node);
+  }
+}
+
+function OptionalCallExpression(node) {
+  this.print(node.callee, node);
+  this.print(node.typeParameters, node);
+
+  if (node.optional) {
+    this.token("?.");
+  }
+
+  this.token("(");
+  this.printList(node.arguments, node);
+  this.token(")");
+}
+
+function CallExpression(node) {
+  this.print(node.callee, node);
+  this.print(node.typeParameters, node);
+  this.token("(");
+  this.printList(node.arguments, node);
+  this.token(")");
+}
+
+function Import() {
+  this.word("import");
+}
+
+function buildYieldAwait(keyword) {
+  return function (node) {
+    this.word(keyword);
+
+    if (node.delegate) {
+      this.token("*");
+    }
+
+    if (node.argument) {
+      this.space();
+      const terminatorState = this.startTerminatorless();
+      this.print(node.argument, node);
+      this.endTerminatorless(terminatorState);
+    }
+  };
+}
+
+const YieldExpression = buildYieldAwait("yield");
+exports.YieldExpression = YieldExpression;
+const AwaitExpression = buildYieldAwait("await");
+exports.AwaitExpression = AwaitExpression;
+
+function EmptyStatement() {
+  this.semicolon(true);
+}
+
+function ExpressionStatement(node) {
+  this.print(node.expression, node);
+  this.semicolon();
+}
+
+function AssignmentPattern(node) {
+  this.print(node.left, node);
+  if (node.left.optional) this.token("?");
+  this.print(node.left.typeAnnotation, node);
+  this.space();
+  this.token("=");
+  this.space();
+  this.print(node.right, node);
+}
+
+function AssignmentExpression(node, parent) {
+  const parens = this.inForStatementInitCounter && node.operator === "in" && !n.needsParens(node, parent);
+
+  if (parens) {
+    this.token("(");
+  }
+
+  this.print(node.left, node);
+  this.space();
+
+  if (node.operator === "in" || node.operator === "instanceof") {
+    this.word(node.operator);
+  } else {
+    this.token(node.operator);
+  }
+
+  this.space();
+  this.print(node.right, node);
+
+  if (parens) {
+    this.token(")");
+  }
+}
+
+function BindExpression(node) {
+  this.print(node.object, node);
+  this.token("::");
+  this.print(node.callee, node);
+}
+
+function MemberExpression(node) {
+  this.print(node.object, node);
+
+  if (!node.computed && t().isMemberExpression(node.property)) {
+    throw new TypeError("Got a MemberExpression for MemberExpression property");
+  }
+
+  let computed = node.computed;
+
+  if (t().isLiteral(node.property) && typeof node.property.value === "number") {
+    computed = true;
+  }
+
+  if (computed) {
+    this.token("[");
+    this.print(node.property, node);
+    this.token("]");
+  } else {
+    this.token(".");
+    this.print(node.property, node);
+  }
+}
+
+function MetaProperty(node) {
+  this.print(node.meta, node);
+  this.token(".");
+  this.print(node.property, node);
+}
+
+function PrivateName(node) {
+  this.token("#");
+  this.print(node.id, node);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/generator/lib/generators/flow.js b/node_modules/@babel/generator/lib/generators/flow.js
new file mode 100644
index 00000000..62cffd27
--- /dev/null
+++ b/node_modules/@babel/generator/lib/generators/flow.js
@@ -0,0 +1,586 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AnyTypeAnnotation = AnyTypeAnnotation;
+exports.ArrayTypeAnnotation = ArrayTypeAnnotation;
+exports.BooleanTypeAnnotation = BooleanTypeAnnotation;
+exports.BooleanLiteralTypeAnnotation = BooleanLiteralTypeAnnotation;
+exports.NullLiteralTypeAnnotation = NullLiteralTypeAnnotation;
+exports.DeclareClass = DeclareClass;
+exports.DeclareFunction = DeclareFunction;
+exports.InferredPredicate = InferredPredicate;
+exports.DeclaredPredicate = DeclaredPredicate;
+exports.DeclareInterface = DeclareInterface;
+exports.DeclareModule = DeclareModule;
+exports.DeclareModuleExports = DeclareModuleExports;
+exports.DeclareTypeAlias = DeclareTypeAlias;
+exports.DeclareOpaqueType = DeclareOpaqueType;
+exports.DeclareVariable = DeclareVariable;
+exports.DeclareExportDeclaration = DeclareExportDeclaration;
+exports.DeclareExportAllDeclaration = DeclareExportAllDeclaration;
+exports.ExistsTypeAnnotation = ExistsTypeAnnotation;
+exports.FunctionTypeAnnotation = FunctionTypeAnnotation;
+exports.FunctionTypeParam = FunctionTypeParam;
+exports.GenericTypeAnnotation = exports.ClassImplements = exports.InterfaceExtends = InterfaceExtends;
+exports._interfaceish = _interfaceish;
+exports._variance = _variance;
+exports.InterfaceDeclaration = InterfaceDeclaration;
+exports.IntersectionTypeAnnotation = IntersectionTypeAnnotation;
+exports.MixedTypeAnnotation = MixedTypeAnnotation;
+exports.EmptyTypeAnnotation = EmptyTypeAnnotation;
+exports.NullableTypeAnnotation = NullableTypeAnnotation;
+exports.NumberTypeAnnotation = NumberTypeAnnotation;
+exports.StringTypeAnnotation = StringTypeAnnotation;
+exports.ThisTypeAnnotation = ThisTypeAnnotation;
+exports.TupleTypeAnnotation = TupleTypeAnnotation;
+exports.TypeofTypeAnnotation = TypeofTypeAnnotation;
+exports.TypeAlias = TypeAlias;
+exports.TypeAnnotation = TypeAnnotation;
+exports.TypeParameterDeclaration = exports.TypeParameterInstantiation = TypeParameterInstantiation;
+exports.TypeParameter = TypeParameter;
+exports.OpaqueType = OpaqueType;
+exports.ObjectTypeAnnotation = ObjectTypeAnnotation;
+exports.ObjectTypeCallProperty = ObjectTypeCallProperty;
+exports.ObjectTypeIndexer = ObjectTypeIndexer;
+exports.ObjectTypeProperty = ObjectTypeProperty;
+exports.ObjectTypeSpreadProperty = ObjectTypeSpreadProperty;
+exports.QualifiedTypeIdentifier = QualifiedTypeIdentifier;
+exports.UnionTypeAnnotation = UnionTypeAnnotation;
+exports.TypeCastExpression = TypeCastExpression;
+exports.Variance = Variance;
+exports.VoidTypeAnnotation = VoidTypeAnnotation;
+Object.defineProperty(exports, "NumberLiteralTypeAnnotation", {
+  enumerable: true,
+  get: function get() {
+    return _types2.NumericLiteral;
+  }
+});
+Object.defineProperty(exports, "StringLiteralTypeAnnotation", {
+  enumerable: true,
+  get: function get() {
+    return _types2.StringLiteral;
+  }
+});
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+var _modules = require("./modules");
+
+var _types2 = require("./types");
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function AnyTypeAnnotation() {
+  this.word("any");
+}
+
+function ArrayTypeAnnotation(node) {
+  this.print(node.elementType, node);
+  this.token("[");
+  this.token("]");
+}
+
+function BooleanTypeAnnotation() {
+  this.word("boolean");
+}
+
+function BooleanLiteralTypeAnnotation(node) {
+  this.word(node.value ? "true" : "false");
+}
+
+function NullLiteralTypeAnnotation() {
+  this.word("null");
+}
+
+function DeclareClass(node, parent) {
+  if (!t().isDeclareExportDeclaration(parent)) {
+    this.word("declare");
+    this.space();
+  }
+
+  this.word("class");
+  this.space();
+
+  this._interfaceish(node);
+}
+
+function DeclareFunction(node, parent) {
+  if (!t().isDeclareExportDeclaration(parent)) {
+    this.word("declare");
+    this.space();
+  }
+
+  this.word("function");
+  this.space();
+  this.print(node.id, node);
+  this.print(node.id.typeAnnotation.typeAnnotation, node);
+
+  if (node.predicate) {
+    this.space();
+    this.print(node.predicate, node);
+  }
+
+  this.semicolon();
+}
+
+function InferredPredicate() {
+  this.token("%");
+  this.word("checks");
+}
+
+function DeclaredPredicate(node) {
+  this.token("%");
+  this.word("checks");
+  this.token("(");
+  this.print(node.value, node);
+  this.token(")");
+}
+
+function DeclareInterface(node) {
+  this.word("declare");
+  this.space();
+  this.InterfaceDeclaration(node);
+}
+
+function DeclareModule(node) {
+  this.word("declare");
+  this.space();
+  this.word("module");
+  this.space();
+  this.print(node.id, node);
+  this.space();
+  this.print(node.body, node);
+}
+
+function DeclareModuleExports(node) {
+  this.word("declare");
+  this.space();
+  this.word("module");
+  this.token(".");
+  this.word("exports");
+  this.print(node.typeAnnotation, node);
+}
+
+function DeclareTypeAlias(node) {
+  this.word("declare");
+  this.space();
+  this.TypeAlias(node);
+}
+
+function DeclareOpaqueType(node, parent) {
+  if (!t().isDeclareExportDeclaration(parent)) {
+    this.word("declare");
+    this.space();
+  }
+
+  this.OpaqueType(node);
+}
+
+function DeclareVariable(node, parent) {
+  if (!t().isDeclareExportDeclaration(parent)) {
+    this.word("declare");
+    this.space();
+  }
+
+  this.word("var");
+  this.space();
+  this.print(node.id, node);
+  this.print(node.id.typeAnnotation, node);
+  this.semicolon();
+}
+
+function DeclareExportDeclaration(node) {
+  this.word("declare");
+  this.space();
+  this.word("export");
+  this.space();
+
+  if (node.default) {
+    this.word("default");
+    this.space();
+  }
+
+  FlowExportDeclaration.apply(this, arguments);
+}
+
+function DeclareExportAllDeclaration() {
+  this.word("declare");
+  this.space();
+
+  _modules.ExportAllDeclaration.apply(this, arguments);
+}
+
+function FlowExportDeclaration(node) {
+  if (node.declaration) {
+    const declar = node.declaration;
+    this.print(declar, node);
+    if (!t().isStatement(declar)) this.semicolon();
+  } else {
+    this.token("{");
+
+    if (node.specifiers.length) {
+      this.space();
+      this.printList(node.specifiers, node);
+      this.space();
+    }
+
+    this.token("}");
+
+    if (node.source) {
+      this.space();
+      this.word("from");
+      this.space();
+      this.print(node.source, node);
+    }
+
+    this.semicolon();
+  }
+}
+
+function ExistsTypeAnnotation() {
+  this.token("*");
+}
+
+function FunctionTypeAnnotation(node, parent) {
+  this.print(node.typeParameters, node);
+  this.token("(");
+  this.printList(node.params, node);
+
+  if (node.rest) {
+    if (node.params.length) {
+      this.token(",");
+      this.space();
+    }
+
+    this.token("...");
+    this.print(node.rest, node);
+  }
+
+  this.token(")");
+
+  if (parent.type === "ObjectTypeCallProperty" || parent.type === "DeclareFunction" || parent.type === "ObjectTypeProperty" && parent.method) {
+    this.token(":");
+  } else {
+    this.space();
+    this.token("=>");
+  }
+
+  this.space();
+  this.print(node.returnType, node);
+}
+
+function FunctionTypeParam(node) {
+  this.print(node.name, node);
+  if (node.optional) this.token("?");
+
+  if (node.name) {
+    this.token(":");
+    this.space();
+  }
+
+  this.print(node.typeAnnotation, node);
+}
+
+function InterfaceExtends(node) {
+  this.print(node.id, node);
+  this.print(node.typeParameters, node);
+}
+
+function _interfaceish(node) {
+  this.print(node.id, node);
+  this.print(node.typeParameters, node);
+
+  if (node.extends.length) {
+    this.space();
+    this.word("extends");
+    this.space();
+    this.printList(node.extends, node);
+  }
+
+  if (node.mixins && node.mixins.length) {
+    this.space();
+    this.word("mixins");
+    this.space();
+    this.printList(node.mixins, node);
+  }
+
+  if (node.implements && node.implements.length) {
+    this.space();
+    this.word("implements");
+    this.space();
+    this.printList(node.implements, node);
+  }
+
+  this.space();
+  this.print(node.body, node);
+}
+
+function _variance(node) {
+  if (node.variance) {
+    if (node.variance.kind === "plus") {
+      this.token("+");
+    } else if (node.variance.kind === "minus") {
+      this.token("-");
+    }
+  }
+}
+
+function InterfaceDeclaration(node) {
+  this.word("interface");
+  this.space();
+
+  this._interfaceish(node);
+}
+
+function andSeparator() {
+  this.space();
+  this.token("&");
+  this.space();
+}
+
+function IntersectionTypeAnnotation(node) {
+  this.printJoin(node.types, node, {
+    separator: andSeparator
+  });
+}
+
+function MixedTypeAnnotation() {
+  this.word("mixed");
+}
+
+function EmptyTypeAnnotation() {
+  this.word("empty");
+}
+
+function NullableTypeAnnotation(node) {
+  this.token("?");
+  this.print(node.typeAnnotation, node);
+}
+
+function NumberTypeAnnotation() {
+  this.word("number");
+}
+
+function StringTypeAnnotation() {
+  this.word("string");
+}
+
+function ThisTypeAnnotation() {
+  this.word("this");
+}
+
+function TupleTypeAnnotation(node) {
+  this.token("[");
+  this.printList(node.types, node);
+  this.token("]");
+}
+
+function TypeofTypeAnnotation(node) {
+  this.word("typeof");
+  this.space();
+  this.print(node.argument, node);
+}
+
+function TypeAlias(node) {
+  this.word("type");
+  this.space();
+  this.print(node.id, node);
+  this.print(node.typeParameters, node);
+  this.space();
+  this.token("=");
+  this.space();
+  this.print(node.right, node);
+  this.semicolon();
+}
+
+function TypeAnnotation(node) {
+  this.token(":");
+  this.space();
+  if (node.optional) this.token("?");
+  this.print(node.typeAnnotation, node);
+}
+
+function TypeParameterInstantiation(node) {
+  this.token("<");
+  this.printList(node.params, node, {});
+  this.token(">");
+}
+
+function TypeParameter(node) {
+  this._variance(node);
+
+  this.word(node.name);
+
+  if (node.bound) {
+    this.print(node.bound, node);
+  }
+
+  if (node.default) {
+    this.space();
+    this.token("=");
+    this.space();
+    this.print(node.default, node);
+  }
+}
+
+function OpaqueType(node) {
+  this.word("opaque");
+  this.space();
+  this.word("type");
+  this.space();
+  this.print(node.id, node);
+  this.print(node.typeParameters, node);
+
+  if (node.supertype) {
+    this.token(":");
+    this.space();
+    this.print(node.supertype, node);
+  }
+
+  if (node.impltype) {
+    this.space();
+    this.token("=");
+    this.space();
+    this.print(node.impltype, node);
+  }
+
+  this.semicolon();
+}
+
+function ObjectTypeAnnotation(node) {
+  if (node.exact) {
+    this.token("{|");
+  } else {
+    this.token("{");
+  }
+
+  const props = node.properties.concat(node.callProperties || [], node.indexers || []);
+
+  if (props.length) {
+    this.space();
+    this.printJoin(props, node, {
+      addNewlines(leading) {
+        if (leading && !props[0]) return 1;
+      },
+
+      indent: true,
+      statement: true,
+      iterator: () => {
+        if (props.length !== 1) {
+          this.token(",");
+          this.space();
+        }
+      }
+    });
+    this.space();
+  }
+
+  if (node.exact) {
+    this.token("|}");
+  } else {
+    this.token("}");
+  }
+}
+
+function ObjectTypeCallProperty(node) {
+  if (node.static) {
+    this.word("static");
+    this.space();
+  }
+
+  this.print(node.value, node);
+}
+
+function ObjectTypeIndexer(node) {
+  if (node.static) {
+    this.word("static");
+    this.space();
+  }
+
+  this._variance(node);
+
+  this.token("[");
+
+  if (node.id) {
+    this.print(node.id, node);
+    this.token(":");
+    this.space();
+  }
+
+  this.print(node.key, node);
+  this.token("]");
+  this.token(":");
+  this.space();
+  this.print(node.value, node);
+}
+
+function ObjectTypeProperty(node) {
+  if (node.static) {
+    this.word("static");
+    this.space();
+  }
+
+  this._variance(node);
+
+  this.print(node.key, node);
+  if (node.optional) this.token("?");
+
+  if (!node.method) {
+    this.token(":");
+    this.space();
+  }
+
+  this.print(node.value, node);
+}
+
+function ObjectTypeSpreadProperty(node) {
+  this.token("...");
+  this.print(node.argument, node);
+}
+
+function QualifiedTypeIdentifier(node) {
+  this.print(node.qualification, node);
+  this.token(".");
+  this.print(node.id, node);
+}
+
+function orSeparator() {
+  this.space();
+  this.token("|");
+  this.space();
+}
+
+function UnionTypeAnnotation(node) {
+  this.printJoin(node.types, node, {
+    separator: orSeparator
+  });
+}
+
+function TypeCastExpression(node) {
+  this.token("(");
+  this.print(node.expression, node);
+  this.print(node.typeAnnotation, node);
+  this.token(")");
+}
+
+function Variance(node) {
+  if (node.kind === "plus") {
+    this.token("+");
+  } else {
+    this.token("-");
+  }
+}
+
+function VoidTypeAnnotation() {
+  this.word("void");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/generator/lib/generators/index.js b/node_modules/@babel/generator/lib/generators/index.js
new file mode 100644
index 00000000..a403023e
--- /dev/null
+++ b/node_modules/@babel/generator/lib/generators/index.js
@@ -0,0 +1,137 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _templateLiterals = require("./template-literals");
+
+Object.keys(_templateLiterals).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _templateLiterals[key];
+    }
+  });
+});
+
+var _expressions = require("./expressions");
+
+Object.keys(_expressions).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _expressions[key];
+    }
+  });
+});
+
+var _statements = require("./statements");
+
+Object.keys(_statements).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _statements[key];
+    }
+  });
+});
+
+var _classes = require("./classes");
+
+Object.keys(_classes).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _classes[key];
+    }
+  });
+});
+
+var _methods = require("./methods");
+
+Object.keys(_methods).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _methods[key];
+    }
+  });
+});
+
+var _modules = require("./modules");
+
+Object.keys(_modules).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _modules[key];
+    }
+  });
+});
+
+var _types = require("./types");
+
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _types[key];
+    }
+  });
+});
+
+var _flow = require("./flow");
+
+Object.keys(_flow).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _flow[key];
+    }
+  });
+});
+
+var _base = require("./base");
+
+Object.keys(_base).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _base[key];
+    }
+  });
+});
+
+var _jsx = require("./jsx");
+
+Object.keys(_jsx).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _jsx[key];
+    }
+  });
+});
+
+var _typescript = require("./typescript");
+
+Object.keys(_typescript).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _typescript[key];
+    }
+  });
+});
\ No newline at end of file
diff --git a/node_modules/@babel/generator/lib/generators/jsx.js b/node_modules/@babel/generator/lib/generators/jsx.js
new file mode 100644
index 00000000..1063619d
--- /dev/null
+++ b/node_modules/@babel/generator/lib/generators/jsx.js
@@ -0,0 +1,148 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.JSXAttribute = JSXAttribute;
+exports.JSXIdentifier = JSXIdentifier;
+exports.JSXNamespacedName = JSXNamespacedName;
+exports.JSXMemberExpression = JSXMemberExpression;
+exports.JSXSpreadAttribute = JSXSpreadAttribute;
+exports.JSXExpressionContainer = JSXExpressionContainer;
+exports.JSXSpreadChild = JSXSpreadChild;
+exports.JSXText = JSXText;
+exports.JSXElement = JSXElement;
+exports.JSXOpeningElement = JSXOpeningElement;
+exports.JSXClosingElement = JSXClosingElement;
+exports.JSXEmptyExpression = JSXEmptyExpression;
+exports.JSXFragment = JSXFragment;
+exports.JSXOpeningFragment = JSXOpeningFragment;
+exports.JSXClosingFragment = JSXClosingFragment;
+
+function JSXAttribute(node) {
+  this.print(node.name, node);
+
+  if (node.value) {
+    this.token("=");
+    this.print(node.value, node);
+  }
+}
+
+function JSXIdentifier(node) {
+  this.word(node.name);
+}
+
+function JSXNamespacedName(node) {
+  this.print(node.namespace, node);
+  this.token(":");
+  this.print(node.name, node);
+}
+
+function JSXMemberExpression(node) {
+  this.print(node.object, node);
+  this.token(".");
+  this.print(node.property, node);
+}
+
+function JSXSpreadAttribute(node) {
+  this.token("{");
+  this.token("...");
+  this.print(node.argument, node);
+  this.token("}");
+}
+
+function JSXExpressionContainer(node) {
+  this.token("{");
+  this.print(node.expression, node);
+  this.token("}");
+}
+
+function JSXSpreadChild(node) {
+  this.token("{");
+  this.token("...");
+  this.print(node.expression, node);
+  this.token("}");
+}
+
+function JSXText(node) {
+  const raw = this.getPossibleRaw(node);
+
+  if (raw != null) {
+    this.token(raw);
+  } else {
+    this.token(node.value);
+  }
+}
+
+function JSXElement(node) {
+  const open = node.openingElement;
+  this.print(open, node);
+  if (open.selfClosing) return;
+  this.indent();
+  var _arr = node.children;
+
+  for (var _i = 0; _i < _arr.length; _i++) {
+    const child = _arr[_i];
+    this.print(child, node);
+  }
+
+  this.dedent();
+  this.print(node.closingElement, node);
+}
+
+function spaceSeparator() {
+  this.space();
+}
+
+function JSXOpeningElement(node) {
+  this.token("<");
+  this.print(node.name, node);
+
+  if (node.attributes.length > 0) {
+    this.space();
+    this.printJoin(node.attributes, node, {
+      separator: spaceSeparator
+    });
+  }
+
+  if (node.selfClosing) {
+    this.space();
+    this.token("/>");
+  } else {
+    this.token(">");
+  }
+}
+
+function JSXClosingElement(node) {
+  this.token("</");
+  this.print(node.name, node);
+  this.token(">");
+}
+
+function JSXEmptyExpression(node) {
+  this.printInnerComments(node);
+}
+
+function JSXFragment(node) {
+  this.print(node.openingFragment, node);
+  this.indent();
+  var _arr2 = node.children;
+
+  for (var _i2 = 0; _i2 < _arr2.length; _i2++) {
+    const child = _arr2[_i2];
+    this.print(child, node);
+  }
+
+  this.dedent();
+  this.print(node.closingFragment, node);
+}
+
+function JSXOpeningFragment() {
+  this.token("<");
+  this.token(">");
+}
+
+function JSXClosingFragment() {
+  this.token("</");
+  this.token(">");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/generator/lib/generators/methods.js b/node_modules/@babel/generator/lib/generators/methods.js
new file mode 100644
index 00000000..1edbdcbb
--- /dev/null
+++ b/node_modules/@babel/generator/lib/generators/methods.js
@@ -0,0 +1,151 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._params = _params;
+exports._parameters = _parameters;
+exports._param = _param;
+exports._methodHead = _methodHead;
+exports._predicate = _predicate;
+exports._functionHead = _functionHead;
+exports.FunctionDeclaration = exports.FunctionExpression = FunctionExpression;
+exports.ArrowFunctionExpression = ArrowFunctionExpression;
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _params(node) {
+  this.print(node.typeParameters, node);
+  this.token("(");
+
+  this._parameters(node.params, node);
+
+  this.token(")");
+  this.print(node.returnType, node);
+}
+
+function _parameters(parameters, parent) {
+  for (let i = 0; i < parameters.length; i++) {
+    this._param(parameters[i], parent);
+
+    if (i < parameters.length - 1) {
+      this.token(",");
+      this.space();
+    }
+  }
+}
+
+function _param(parameter, parent) {
+  this.printJoin(parameter.decorators, parameter);
+  this.print(parameter, parent);
+  if (parameter.optional) this.token("?");
+  this.print(parameter.typeAnnotation, parameter);
+}
+
+function _methodHead(node) {
+  const kind = node.kind;
+  const key = node.key;
+
+  if (kind === "get" || kind === "set") {
+    this.word(kind);
+    this.space();
+  }
+
+  if (node.async) {
+    this.word("async");
+    this.space();
+  }
+
+  if (kind === "method" || kind === "init") {
+    if (node.generator) {
+      this.token("*");
+    }
+  }
+
+  if (node.computed) {
+    this.token("[");
+    this.print(key, node);
+    this.token("]");
+  } else {
+    this.print(key, node);
+  }
+
+  if (node.optional) {
+    this.token("?");
+  }
+
+  this._params(node);
+}
+
+function _predicate(node) {
+  if (node.predicate) {
+    if (!node.returnType) {
+      this.token(":");
+    }
+
+    this.space();
+    this.print(node.predicate, node);
+  }
+}
+
+function _functionHead(node) {
+  if (node.async) {
+    this.word("async");
+    this.space();
+  }
+
+  this.word("function");
+  if (node.generator) this.token("*");
+  this.space();
+
+  if (node.id) {
+    this.print(node.id, node);
+  }
+
+  this._params(node);
+
+  this._predicate(node);
+}
+
+function FunctionExpression(node) {
+  this._functionHead(node);
+
+  this.space();
+  this.print(node.body, node);
+}
+
+function ArrowFunctionExpression(node) {
+  if (node.async) {
+    this.word("async");
+    this.space();
+  }
+
+  const firstParam = node.params[0];
+
+  if (node.params.length === 1 && t().isIdentifier(firstParam) && !hasTypes(node, firstParam)) {
+    this.print(firstParam, node);
+  } else {
+    this._params(node);
+  }
+
+  this._predicate(node);
+
+  this.space();
+  this.token("=>");
+  this.space();
+  this.print(node.body, node);
+}
+
+function hasTypes(node, param) {
+  return node.typeParameters || node.returnType || param.typeAnnotation || param.optional || param.trailingComments;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/generator/lib/generators/modules.js b/node_modules/@babel/generator/lib/generators/modules.js
new file mode 100644
index 00000000..c6dede15
--- /dev/null
+++ b/node_modules/@babel/generator/lib/generators/modules.js
@@ -0,0 +1,214 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ImportSpecifier = ImportSpecifier;
+exports.ImportDefaultSpecifier = ImportDefaultSpecifier;
+exports.ExportDefaultSpecifier = ExportDefaultSpecifier;
+exports.ExportSpecifier = ExportSpecifier;
+exports.ExportNamespaceSpecifier = ExportNamespaceSpecifier;
+exports.ExportAllDeclaration = ExportAllDeclaration;
+exports.ExportNamedDeclaration = ExportNamedDeclaration;
+exports.ExportDefaultDeclaration = ExportDefaultDeclaration;
+exports.ImportDeclaration = ImportDeclaration;
+exports.ImportNamespaceSpecifier = ImportNamespaceSpecifier;
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function ImportSpecifier(node) {
+  if (node.importKind === "type" || node.importKind === "typeof") {
+    this.word(node.importKind);
+    this.space();
+  }
+
+  this.print(node.imported, node);
+
+  if (node.local && node.local.name !== node.imported.name) {
+    this.space();
+    this.word("as");
+    this.space();
+    this.print(node.local, node);
+  }
+}
+
+function ImportDefaultSpecifier(node) {
+  this.print(node.local, node);
+}
+
+function ExportDefaultSpecifier(node) {
+  this.print(node.exported, node);
+}
+
+function ExportSpecifier(node) {
+  this.print(node.local, node);
+
+  if (node.exported && node.local.name !== node.exported.name) {
+    this.space();
+    this.word("as");
+    this.space();
+    this.print(node.exported, node);
+  }
+}
+
+function ExportNamespaceSpecifier(node) {
+  this.token("*");
+  this.space();
+  this.word("as");
+  this.space();
+  this.print(node.exported, node);
+}
+
+function ExportAllDeclaration(node) {
+  this.word("export");
+  this.space();
+
+  if (node.exportKind === "type") {
+    this.word("type");
+    this.space();
+  }
+
+  this.token("*");
+  this.space();
+  this.word("from");
+  this.space();
+  this.print(node.source, node);
+  this.semicolon();
+}
+
+function ExportNamedDeclaration(node) {
+  if (t().isClassDeclaration(node.declaration)) {
+    this.printJoin(node.declaration.decorators, node);
+  }
+
+  this.word("export");
+  this.space();
+  ExportDeclaration.apply(this, arguments);
+}
+
+function ExportDefaultDeclaration(node) {
+  if (t().isClassDeclaration(node.declaration)) {
+    this.printJoin(node.declaration.decorators, node);
+  }
+
+  this.word("export");
+  this.space();
+  this.word("default");
+  this.space();
+  ExportDeclaration.apply(this, arguments);
+}
+
+function ExportDeclaration(node) {
+  if (node.declaration) {
+    const declar = node.declaration;
+    this.print(declar, node);
+    if (!t().isStatement(declar)) this.semicolon();
+  } else {
+    if (node.exportKind === "type") {
+      this.word("type");
+      this.space();
+    }
+
+    const specifiers = node.specifiers.slice(0);
+    let hasSpecial = false;
+
+    while (true) {
+      const first = specifiers[0];
+
+      if (t().isExportDefaultSpecifier(first) || t().isExportNamespaceSpecifier(first)) {
+        hasSpecial = true;
+        this.print(specifiers.shift(), node);
+
+        if (specifiers.length) {
+          this.token(",");
+          this.space();
+        }
+      } else {
+        break;
+      }
+    }
+
+    if (specifiers.length || !specifiers.length && !hasSpecial) {
+      this.token("{");
+
+      if (specifiers.length) {
+        this.space();
+        this.printList(specifiers, node);
+        this.space();
+      }
+
+      this.token("}");
+    }
+
+    if (node.source) {
+      this.space();
+      this.word("from");
+      this.space();
+      this.print(node.source, node);
+    }
+
+    this.semicolon();
+  }
+}
+
+function ImportDeclaration(node) {
+  this.word("import");
+  this.space();
+
+  if (node.importKind === "type" || node.importKind === "typeof") {
+    this.word(node.importKind);
+    this.space();
+  }
+
+  const specifiers = node.specifiers.slice(0);
+
+  if (specifiers && specifiers.length) {
+    while (true) {
+      const first = specifiers[0];
+
+      if (t().isImportDefaultSpecifier(first) || t().isImportNamespaceSpecifier(first)) {
+        this.print(specifiers.shift(), node);
+
+        if (specifiers.length) {
+          this.token(",");
+          this.space();
+        }
+      } else {
+        break;
+      }
+    }
+
+    if (specifiers.length) {
+      this.token("{");
+      this.space();
+      this.printList(specifiers, node);
+      this.space();
+      this.token("}");
+    }
+
+    this.space();
+    this.word("from");
+    this.space();
+  }
+
+  this.print(node.source, node);
+  this.semicolon();
+}
+
+function ImportNamespaceSpecifier(node) {
+  this.token("*");
+  this.space();
+  this.word("as");
+  this.space();
+  this.print(node.local, node);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/generator/lib/generators/statements.js b/node_modules/@babel/generator/lib/generators/statements.js
new file mode 100644
index 00000000..893fdf58
--- /dev/null
+++ b/node_modules/@babel/generator/lib/generators/statements.js
@@ -0,0 +1,323 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WithStatement = WithStatement;
+exports.IfStatement = IfStatement;
+exports.ForStatement = ForStatement;
+exports.WhileStatement = WhileStatement;
+exports.DoWhileStatement = DoWhileStatement;
+exports.LabeledStatement = LabeledStatement;
+exports.TryStatement = TryStatement;
+exports.CatchClause = CatchClause;
+exports.SwitchStatement = SwitchStatement;
+exports.SwitchCase = SwitchCase;
+exports.DebuggerStatement = DebuggerStatement;
+exports.VariableDeclaration = VariableDeclaration;
+exports.VariableDeclarator = VariableDeclarator;
+exports.ThrowStatement = exports.BreakStatement = exports.ReturnStatement = exports.ContinueStatement = exports.ForOfStatement = exports.ForInStatement = void 0;
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function WithStatement(node) {
+  this.word("with");
+  this.space();
+  this.token("(");
+  this.print(node.object, node);
+  this.token(")");
+  this.printBlock(node);
+}
+
+function IfStatement(node) {
+  this.word("if");
+  this.space();
+  this.token("(");
+  this.print(node.test, node);
+  this.token(")");
+  this.space();
+  const needsBlock = node.alternate && t().isIfStatement(getLastStatement(node.consequent));
+
+  if (needsBlock) {
+    this.token("{");
+    this.newline();
+    this.indent();
+  }
+
+  this.printAndIndentOnComments(node.consequent, node);
+
+  if (needsBlock) {
+    this.dedent();
+    this.newline();
+    this.token("}");
+  }
+
+  if (node.alternate) {
+    if (this.endsWith("}")) this.space();
+    this.word("else");
+    this.space();
+    this.printAndIndentOnComments(node.alternate, node);
+  }
+}
+
+function getLastStatement(statement) {
+  if (!t().isStatement(statement.body)) return statement;
+  return getLastStatement(statement.body);
+}
+
+function ForStatement(node) {
+  this.word("for");
+  this.space();
+  this.token("(");
+  this.inForStatementInitCounter++;
+  this.print(node.init, node);
+  this.inForStatementInitCounter--;
+  this.token(";");
+
+  if (node.test) {
+    this.space();
+    this.print(node.test, node);
+  }
+
+  this.token(";");
+
+  if (node.update) {
+    this.space();
+    this.print(node.update, node);
+  }
+
+  this.token(")");
+  this.printBlock(node);
+}
+
+function WhileStatement(node) {
+  this.word("while");
+  this.space();
+  this.token("(");
+  this.print(node.test, node);
+  this.token(")");
+  this.printBlock(node);
+}
+
+const buildForXStatement = function buildForXStatement(op) {
+  return function (node) {
+    this.word("for");
+    this.space();
+
+    if (op === "of" && node.await) {
+      this.word("await");
+      this.space();
+    }
+
+    this.token("(");
+    this.print(node.left, node);
+    this.space();
+    this.word(op);
+    this.space();
+    this.print(node.right, node);
+    this.token(")");
+    this.printBlock(node);
+  };
+};
+
+const ForInStatement = buildForXStatement("in");
+exports.ForInStatement = ForInStatement;
+const ForOfStatement = buildForXStatement("of");
+exports.ForOfStatement = ForOfStatement;
+
+function DoWhileStatement(node) {
+  this.word("do");
+  this.space();
+  this.print(node.body, node);
+  this.space();
+  this.word("while");
+  this.space();
+  this.token("(");
+  this.print(node.test, node);
+  this.token(")");
+  this.semicolon();
+}
+
+function buildLabelStatement(prefix, key = "label") {
+  return function (node) {
+    this.word(prefix);
+    const label = node[key];
+
+    if (label) {
+      this.space();
+      const isLabel = key == "label";
+      const terminatorState = this.startTerminatorless(isLabel);
+      this.print(label, node);
+      this.endTerminatorless(terminatorState);
+    }
+
+    this.semicolon();
+  };
+}
+
+const ContinueStatement = buildLabelStatement("continue");
+exports.ContinueStatement = ContinueStatement;
+const ReturnStatement = buildLabelStatement("return", "argument");
+exports.ReturnStatement = ReturnStatement;
+const BreakStatement = buildLabelStatement("break");
+exports.BreakStatement = BreakStatement;
+const ThrowStatement = buildLabelStatement("throw", "argument");
+exports.ThrowStatement = ThrowStatement;
+
+function LabeledStatement(node) {
+  this.print(node.label, node);
+  this.token(":");
+  this.space();
+  this.print(node.body, node);
+}
+
+function TryStatement(node) {
+  this.word("try");
+  this.space();
+  this.print(node.block, node);
+  this.space();
+
+  if (node.handlers) {
+    this.print(node.handlers[0], node);
+  } else {
+    this.print(node.handler, node);
+  }
+
+  if (node.finalizer) {
+    this.space();
+    this.word("finally");
+    this.space();
+    this.print(node.finalizer, node);
+  }
+}
+
+function CatchClause(node) {
+  this.word("catch");
+  this.space();
+
+  if (node.param) {
+    this.token("(");
+    this.print(node.param, node);
+    this.token(")");
+    this.space();
+  }
+
+  this.print(node.body, node);
+}
+
+function SwitchStatement(node) {
+  this.word("switch");
+  this.space();
+  this.token("(");
+  this.print(node.discriminant, node);
+  this.token(")");
+  this.space();
+  this.token("{");
+  this.printSequence(node.cases, node, {
+    indent: true,
+
+    addNewlines(leading, cas) {
+      if (!leading && node.cases[node.cases.length - 1] === cas) return -1;
+    }
+
+  });
+  this.token("}");
+}
+
+function SwitchCase(node) {
+  if (node.test) {
+    this.word("case");
+    this.space();
+    this.print(node.test, node);
+    this.token(":");
+  } else {
+    this.word("default");
+    this.token(":");
+  }
+
+  if (node.consequent.length) {
+    this.newline();
+    this.printSequence(node.consequent, node, {
+      indent: true
+    });
+  }
+}
+
+function DebuggerStatement() {
+  this.word("debugger");
+  this.semicolon();
+}
+
+function variableDeclarationIndent() {
+  this.token(",");
+  this.newline();
+  if (this.endsWith("\n")) for (let i = 0; i < 4; i++) this.space(true);
+}
+
+function constDeclarationIndent() {
+  this.token(",");
+  this.newline();
+  if (this.endsWith("\n")) for (let i = 0; i < 6; i++) this.space(true);
+}
+
+function VariableDeclaration(node, parent) {
+  if (node.declare) {
+    this.word("declare");
+    this.space();
+  }
+
+  this.word(node.kind);
+  this.space();
+  let hasInits = false;
+
+  if (!t().isFor(parent)) {
+    var _arr = node.declarations;
+
+    for (var _i = 0; _i < _arr.length; _i++) {
+      const declar = _arr[_i];
+
+      if (declar.init) {
+        hasInits = true;
+      }
+    }
+  }
+
+  let separator;
+
+  if (hasInits) {
+    separator = node.kind === "const" ? constDeclarationIndent : variableDeclarationIndent;
+  }
+
+  this.printList(node.declarations, node, {
+    separator
+  });
+
+  if (t().isFor(parent)) {
+    if (parent.left === node || parent.init === node) return;
+  }
+
+  this.semicolon();
+}
+
+function VariableDeclarator(node) {
+  this.print(node.id, node);
+  if (node.definite) this.token("!");
+  this.print(node.id.typeAnnotation, node);
+
+  if (node.init) {
+    this.space();
+    this.token("=");
+    this.space();
+    this.print(node.init, node);
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/generator/lib/generators/template-literals.js b/node_modules/@babel/generator/lib/generators/template-literals.js
new file mode 100644
index 00000000..16f4d9af
--- /dev/null
+++ b/node_modules/@babel/generator/lib/generators/template-literals.js
@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TaggedTemplateExpression = TaggedTemplateExpression;
+exports.TemplateElement = TemplateElement;
+exports.TemplateLiteral = TemplateLiteral;
+
+function TaggedTemplateExpression(node) {
+  this.print(node.tag, node);
+  this.print(node.quasi, node);
+}
+
+function TemplateElement(node, parent) {
+  const isFirst = parent.quasis[0] === node;
+  const isLast = parent.quasis[parent.quasis.length - 1] === node;
+  const value = (isFirst ? "`" : "}") + node.value.raw + (isLast ? "`" : "${");
+  this.token(value);
+}
+
+function TemplateLiteral(node) {
+  const quasis = node.quasis;
+
+  for (let i = 0; i < quasis.length; i++) {
+    this.print(quasis[i], node);
+
+    if (i + 1 < quasis.length) {
+      this.print(node.expressions[i], node);
+    }
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/generator/lib/generators/types.js b/node_modules/@babel/generator/lib/generators/types.js
new file mode 100644
index 00000000..468586d0
--- /dev/null
+++ b/node_modules/@babel/generator/lib/generators/types.js
@@ -0,0 +1,167 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Identifier = Identifier;
+exports.SpreadElement = exports.RestElement = RestElement;
+exports.ObjectPattern = exports.ObjectExpression = ObjectExpression;
+exports.ObjectMethod = ObjectMethod;
+exports.ObjectProperty = ObjectProperty;
+exports.ArrayPattern = exports.ArrayExpression = ArrayExpression;
+exports.RegExpLiteral = RegExpLiteral;
+exports.BooleanLiteral = BooleanLiteral;
+exports.NullLiteral = NullLiteral;
+exports.NumericLiteral = NumericLiteral;
+exports.StringLiteral = StringLiteral;
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _jsesc() {
+  const data = _interopRequireDefault(require("jsesc"));
+
+  _jsesc = function _jsesc() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function Identifier(node) {
+  this.word(node.name);
+}
+
+function RestElement(node) {
+  this.token("...");
+  this.print(node.argument, node);
+}
+
+function ObjectExpression(node) {
+  const props = node.properties;
+  this.token("{");
+  this.printInnerComments(node);
+
+  if (props.length) {
+    this.space();
+    this.printList(props, node, {
+      indent: true,
+      statement: true
+    });
+    this.space();
+  }
+
+  this.token("}");
+}
+
+function ObjectMethod(node) {
+  this.printJoin(node.decorators, node);
+
+  this._methodHead(node);
+
+  this.space();
+  this.print(node.body, node);
+}
+
+function ObjectProperty(node) {
+  this.printJoin(node.decorators, node);
+
+  if (node.computed) {
+    this.token("[");
+    this.print(node.key, node);
+    this.token("]");
+  } else {
+    if (t().isAssignmentPattern(node.value) && t().isIdentifier(node.key) && node.key.name === node.value.left.name) {
+      this.print(node.value, node);
+      return;
+    }
+
+    this.print(node.key, node);
+
+    if (node.shorthand && t().isIdentifier(node.key) && t().isIdentifier(node.value) && node.key.name === node.value.name) {
+      return;
+    }
+  }
+
+  this.token(":");
+  this.space();
+  this.print(node.value, node);
+}
+
+function ArrayExpression(node) {
+  const elems = node.elements;
+  const len = elems.length;
+  this.token("[");
+  this.printInnerComments(node);
+
+  for (let i = 0; i < elems.length; i++) {
+    const elem = elems[i];
+
+    if (elem) {
+      if (i > 0) this.space();
+      this.print(elem, node);
+      if (i < len - 1) this.token(",");
+    } else {
+      this.token(",");
+    }
+  }
+
+  this.token("]");
+}
+
+function RegExpLiteral(node) {
+  this.word(`/${node.pattern}/${node.flags}`);
+}
+
+function BooleanLiteral(node) {
+  this.word(node.value ? "true" : "false");
+}
+
+function NullLiteral() {
+  this.word("null");
+}
+
+function NumericLiteral(node) {
+  const raw = this.getPossibleRaw(node);
+  const value = node.value + "";
+
+  if (raw == null) {
+    this.number(value);
+  } else if (this.format.minified) {
+    this.number(raw.length < value.length ? raw : value);
+  } else {
+    this.number(raw);
+  }
+}
+
+function StringLiteral(node) {
+  const raw = this.getPossibleRaw(node);
+
+  if (!this.format.minified && raw != null) {
+    this.token(raw);
+    return;
+  }
+
+  const opts = {
+    quotes: "double",
+    wrap: true
+  };
+
+  if (this.format.jsonCompatibleStrings) {
+    opts.json = true;
+  }
+
+  const val = (0, _jsesc().default)(node.value, opts);
+  return this.token(val);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/generator/lib/generators/typescript.js b/node_modules/@babel/generator/lib/generators/typescript.js
new file mode 100644
index 00000000..7f7725c1
--- /dev/null
+++ b/node_modules/@babel/generator/lib/generators/typescript.js
@@ -0,0 +1,662 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TSTypeAnnotation = TSTypeAnnotation;
+exports.TSTypeParameterDeclaration = exports.TSTypeParameterInstantiation = TSTypeParameterInstantiation;
+exports.TSTypeParameter = TSTypeParameter;
+exports.TSParameterProperty = TSParameterProperty;
+exports.TSDeclareFunction = TSDeclareFunction;
+exports.TSDeclareMethod = TSDeclareMethod;
+exports.TSQualifiedName = TSQualifiedName;
+exports.TSCallSignatureDeclaration = TSCallSignatureDeclaration;
+exports.TSConstructSignatureDeclaration = TSConstructSignatureDeclaration;
+exports.TSPropertySignature = TSPropertySignature;
+exports.tsPrintPropertyOrMethodName = tsPrintPropertyOrMethodName;
+exports.TSMethodSignature = TSMethodSignature;
+exports.TSIndexSignature = TSIndexSignature;
+exports.TSAnyKeyword = TSAnyKeyword;
+exports.TSNumberKeyword = TSNumberKeyword;
+exports.TSObjectKeyword = TSObjectKeyword;
+exports.TSBooleanKeyword = TSBooleanKeyword;
+exports.TSStringKeyword = TSStringKeyword;
+exports.TSSymbolKeyword = TSSymbolKeyword;
+exports.TSVoidKeyword = TSVoidKeyword;
+exports.TSUndefinedKeyword = TSUndefinedKeyword;
+exports.TSNullKeyword = TSNullKeyword;
+exports.TSNeverKeyword = TSNeverKeyword;
+exports.TSThisType = TSThisType;
+exports.TSFunctionType = TSFunctionType;
+exports.TSConstructorType = TSConstructorType;
+exports.tsPrintFunctionOrConstructorType = tsPrintFunctionOrConstructorType;
+exports.TSTypeReference = TSTypeReference;
+exports.TSTypePredicate = TSTypePredicate;
+exports.TSTypeQuery = TSTypeQuery;
+exports.TSTypeLiteral = TSTypeLiteral;
+exports.tsPrintTypeLiteralOrInterfaceBody = tsPrintTypeLiteralOrInterfaceBody;
+exports.tsPrintBraced = tsPrintBraced;
+exports.TSArrayType = TSArrayType;
+exports.TSTupleType = TSTupleType;
+exports.TSUnionType = TSUnionType;
+exports.TSIntersectionType = TSIntersectionType;
+exports.tsPrintUnionOrIntersectionType = tsPrintUnionOrIntersectionType;
+exports.TSConditionalType = TSConditionalType;
+exports.TSInferType = TSInferType;
+exports.TSParenthesizedType = TSParenthesizedType;
+exports.TSTypeOperator = TSTypeOperator;
+exports.TSIndexedAccessType = TSIndexedAccessType;
+exports.TSMappedType = TSMappedType;
+exports.TSLiteralType = TSLiteralType;
+exports.TSExpressionWithTypeArguments = TSExpressionWithTypeArguments;
+exports.TSInterfaceDeclaration = TSInterfaceDeclaration;
+exports.TSInterfaceBody = TSInterfaceBody;
+exports.TSTypeAliasDeclaration = TSTypeAliasDeclaration;
+exports.TSAsExpression = TSAsExpression;
+exports.TSTypeAssertion = TSTypeAssertion;
+exports.TSEnumDeclaration = TSEnumDeclaration;
+exports.TSEnumMember = TSEnumMember;
+exports.TSModuleDeclaration = TSModuleDeclaration;
+exports.TSModuleBlock = TSModuleBlock;
+exports.TSImportEqualsDeclaration = TSImportEqualsDeclaration;
+exports.TSExternalModuleReference = TSExternalModuleReference;
+exports.TSNonNullExpression = TSNonNullExpression;
+exports.TSExportAssignment = TSExportAssignment;
+exports.TSNamespaceExportDeclaration = TSNamespaceExportDeclaration;
+exports.tsPrintSignatureDeclarationBase = tsPrintSignatureDeclarationBase;
+
+function TSTypeAnnotation(node) {
+  this.token(":");
+  this.space();
+  if (node.optional) this.token("?");
+  this.print(node.typeAnnotation, node);
+}
+
+function TSTypeParameterInstantiation(node) {
+  this.token("<");
+  this.printList(node.params, node, {});
+  this.token(">");
+}
+
+function TSTypeParameter(node) {
+  this.word(node.name);
+
+  if (node.constraint) {
+    this.space();
+    this.word("extends");
+    this.space();
+    this.print(node.constraint, node);
+  }
+
+  if (node.default) {
+    this.space();
+    this.token("=");
+    this.space();
+    this.print(node.default, node);
+  }
+}
+
+function TSParameterProperty(node) {
+  if (node.accessibility) {
+    this.word(node.accessibility);
+    this.space();
+  }
+
+  if (node.readonly) {
+    this.word("readonly");
+    this.space();
+  }
+
+  this._param(node.parameter);
+}
+
+function TSDeclareFunction(node) {
+  if (node.declare) {
+    this.word("declare");
+    this.space();
+  }
+
+  this._functionHead(node);
+
+  this.token(";");
+}
+
+function TSDeclareMethod(node) {
+  this._classMethodHead(node);
+
+  this.token(";");
+}
+
+function TSQualifiedName(node) {
+  this.print(node.left, node);
+  this.token(".");
+  this.print(node.right, node);
+}
+
+function TSCallSignatureDeclaration(node) {
+  this.tsPrintSignatureDeclarationBase(node);
+}
+
+function TSConstructSignatureDeclaration(node) {
+  this.word("new");
+  this.space();
+  this.tsPrintSignatureDeclarationBase(node);
+}
+
+function TSPropertySignature(node) {
+  const readonly = node.readonly,
+        initializer = node.initializer;
+
+  if (readonly) {
+    this.word("readonly");
+    this.space();
+  }
+
+  this.tsPrintPropertyOrMethodName(node);
+  this.print(node.typeAnnotation, node);
+
+  if (initializer) {
+    this.space();
+    this.token("=");
+    this.space();
+    this.print(initializer, node);
+  }
+
+  this.token(";");
+}
+
+function tsPrintPropertyOrMethodName(node) {
+  if (node.computed) {
+    this.token("[");
+  }
+
+  this.print(node.key, node);
+
+  if (node.computed) {
+    this.token("]");
+  }
+
+  if (node.optional) {
+    this.token("?");
+  }
+}
+
+function TSMethodSignature(node) {
+  this.tsPrintPropertyOrMethodName(node);
+  this.tsPrintSignatureDeclarationBase(node);
+  this.token(";");
+}
+
+function TSIndexSignature(node) {
+  const readonly = node.readonly;
+
+  if (readonly) {
+    this.word("readonly");
+    this.space();
+  }
+
+  this.token("[");
+
+  this._parameters(node.parameters, node);
+
+  this.token("]");
+  this.print(node.typeAnnotation, node);
+  this.token(";");
+}
+
+function TSAnyKeyword() {
+  this.word("any");
+}
+
+function TSNumberKeyword() {
+  this.word("number");
+}
+
+function TSObjectKeyword() {
+  this.word("object");
+}
+
+function TSBooleanKeyword() {
+  this.word("boolean");
+}
+
+function TSStringKeyword() {
+  this.word("string");
+}
+
+function TSSymbolKeyword() {
+  this.word("symbol");
+}
+
+function TSVoidKeyword() {
+  this.word("void");
+}
+
+function TSUndefinedKeyword() {
+  this.word("undefined");
+}
+
+function TSNullKeyword() {
+  this.word("null");
+}
+
+function TSNeverKeyword() {
+  this.word("never");
+}
+
+function TSThisType() {
+  this.word("this");
+}
+
+function TSFunctionType(node) {
+  this.tsPrintFunctionOrConstructorType(node);
+}
+
+function TSConstructorType(node) {
+  this.word("new");
+  this.space();
+  this.tsPrintFunctionOrConstructorType(node);
+}
+
+function tsPrintFunctionOrConstructorType(node) {
+  const typeParameters = node.typeParameters,
+        parameters = node.parameters;
+  this.print(typeParameters, node);
+  this.token("(");
+
+  this._parameters(parameters, node);
+
+  this.token(")");
+  this.space();
+  this.token("=>");
+  this.space();
+  this.print(node.typeAnnotation.typeAnnotation, node);
+}
+
+function TSTypeReference(node) {
+  this.print(node.typeName, node);
+  this.print(node.typeParameters, node);
+}
+
+function TSTypePredicate(node) {
+  this.print(node.parameterName);
+  this.space();
+  this.word("is");
+  this.space();
+  this.print(node.typeAnnotation.typeAnnotation);
+}
+
+function TSTypeQuery(node) {
+  this.word("typeof");
+  this.space();
+  this.print(node.exprName);
+}
+
+function TSTypeLiteral(node) {
+  this.tsPrintTypeLiteralOrInterfaceBody(node.members, node);
+}
+
+function tsPrintTypeLiteralOrInterfaceBody(members, node) {
+  this.tsPrintBraced(members, node);
+}
+
+function tsPrintBraced(members, node) {
+  this.token("{");
+
+  if (members.length) {
+    this.indent();
+    this.newline();
+
+    for (var _iterator = members, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i >= _iterator.length) break;
+        _ref = _iterator[_i++];
+      } else {
+        _i = _iterator.next();
+        if (_i.done) break;
+        _ref = _i.value;
+      }
+
+      const member = _ref;
+      this.print(member, node);
+      this.newline();
+    }
+
+    this.dedent();
+    this.rightBrace();
+  } else {
+    this.token("}");
+  }
+}
+
+function TSArrayType(node) {
+  this.print(node.elementType);
+  this.token("[]");
+}
+
+function TSTupleType(node) {
+  this.token("[");
+  this.printList(node.elementTypes, node);
+  this.token("]");
+}
+
+function TSUnionType(node) {
+  this.tsPrintUnionOrIntersectionType(node, "|");
+}
+
+function TSIntersectionType(node) {
+  this.tsPrintUnionOrIntersectionType(node, "&");
+}
+
+function tsPrintUnionOrIntersectionType(node, sep) {
+  this.printJoin(node.types, node, {
+    separator() {
+      this.space();
+      this.token(sep);
+      this.space();
+    }
+
+  });
+}
+
+function TSConditionalType(node) {
+  this.print(node.checkType);
+  this.space();
+  this.word("extends");
+  this.space();
+  this.print(node.extendsType);
+  this.space();
+  this.token("?");
+  this.space();
+  this.print(node.trueType);
+  this.space();
+  this.token(":");
+  this.space();
+  this.print(node.falseType);
+}
+
+function TSInferType(node) {
+  this.token("infer");
+  this.space();
+  this.print(node.typeParameter);
+}
+
+function TSParenthesizedType(node) {
+  this.token("(");
+  this.print(node.typeAnnotation, node);
+  this.token(")");
+}
+
+function TSTypeOperator(node) {
+  this.token(node.operator);
+  this.space();
+  this.print(node.typeAnnotation, node);
+}
+
+function TSIndexedAccessType(node) {
+  this.print(node.objectType, node);
+  this.token("[");
+  this.print(node.indexType, node);
+  this.token("]");
+}
+
+function TSMappedType(node) {
+  const readonly = node.readonly,
+        typeParameter = node.typeParameter,
+        optional = node.optional;
+  this.token("{");
+  this.space();
+
+  if (readonly) {
+    tokenIfPlusMinus(this, readonly);
+    this.word("readonly");
+    this.space();
+  }
+
+  this.token("[");
+  this.word(typeParameter.name);
+  this.space();
+  this.word("in");
+  this.space();
+  this.print(typeParameter.constraint, typeParameter);
+  this.token("]");
+
+  if (optional) {
+    tokenIfPlusMinus(this, optional);
+    this.token("?");
+  }
+
+  this.token(":");
+  this.space();
+  this.print(node.typeAnnotation, node);
+  this.space();
+  this.token("}");
+}
+
+function tokenIfPlusMinus(self, tok) {
+  if (tok !== true) {
+    self.token(tok);
+  }
+}
+
+function TSLiteralType(node) {
+  this.print(node.literal, node);
+}
+
+function TSExpressionWithTypeArguments(node) {
+  this.print(node.expression, node);
+  this.print(node.typeParameters, node);
+}
+
+function TSInterfaceDeclaration(node) {
+  const declare = node.declare,
+        id = node.id,
+        typeParameters = node.typeParameters,
+        extendz = node.extends,
+        body = node.body;
+
+  if (declare) {
+    this.word("declare");
+    this.space();
+  }
+
+  this.word("interface");
+  this.space();
+  this.print(id, node);
+  this.print(typeParameters, node);
+
+  if (extendz) {
+    this.space();
+    this.word("extends");
+    this.space();
+    this.printList(extendz, node);
+  }
+
+  this.space();
+  this.print(body, node);
+}
+
+function TSInterfaceBody(node) {
+  this.tsPrintTypeLiteralOrInterfaceBody(node.body, node);
+}
+
+function TSTypeAliasDeclaration(node) {
+  const declare = node.declare,
+        id = node.id,
+        typeParameters = node.typeParameters,
+        typeAnnotation = node.typeAnnotation;
+
+  if (declare) {
+    this.word("declare");
+    this.space();
+  }
+
+  this.word("type");
+  this.space();
+  this.print(id, node);
+  this.print(typeParameters, node);
+  this.space();
+  this.token("=");
+  this.space();
+  this.print(typeAnnotation, node);
+  this.token(";");
+}
+
+function TSAsExpression(node) {
+  const expression = node.expression,
+        typeAnnotation = node.typeAnnotation;
+  this.print(expression, node);
+  this.space();
+  this.word("as");
+  this.space();
+  this.print(typeAnnotation, node);
+}
+
+function TSTypeAssertion(node) {
+  const typeAnnotation = node.typeAnnotation,
+        expression = node.expression;
+  this.token("<");
+  this.print(typeAnnotation, node);
+  this.token(">");
+  this.space();
+  this.print(expression, node);
+}
+
+function TSEnumDeclaration(node) {
+  const declare = node.declare,
+        isConst = node.const,
+        id = node.id,
+        members = node.members;
+
+  if (declare) {
+    this.word("declare");
+    this.space();
+  }
+
+  if (isConst) {
+    this.word("const");
+    this.space();
+  }
+
+  this.word("enum");
+  this.space();
+  this.print(id, node);
+  this.space();
+  this.tsPrintBraced(members, node);
+}
+
+function TSEnumMember(node) {
+  const id = node.id,
+        initializer = node.initializer;
+  this.print(id, node);
+
+  if (initializer) {
+    this.space();
+    this.token("=");
+    this.space();
+    this.print(initializer, node);
+  }
+
+  this.token(",");
+}
+
+function TSModuleDeclaration(node) {
+  const declare = node.declare,
+        id = node.id;
+
+  if (declare) {
+    this.word("declare");
+    this.space();
+  }
+
+  if (!node.global) {
+    this.word(id.type === "Identifier" ? "namespace" : "module");
+    this.space();
+  }
+
+  this.print(id, node);
+
+  if (!node.body) {
+    this.token(";");
+    return;
+  }
+
+  let body = node.body;
+
+  while (body.type === "TSModuleDeclaration") {
+    this.token(".");
+    this.print(body.id, body);
+    body = body.body;
+  }
+
+  this.space();
+  this.print(body, node);
+}
+
+function TSModuleBlock(node) {
+  this.tsPrintBraced(node.body, node);
+}
+
+function TSImportEqualsDeclaration(node) {
+  const isExport = node.isExport,
+        id = node.id,
+        moduleReference = node.moduleReference;
+
+  if (isExport) {
+    this.word("export");
+    this.space();
+  }
+
+  this.word("import");
+  this.space();
+  this.print(id, node);
+  this.space();
+  this.token("=");
+  this.space();
+  this.print(moduleReference, node);
+  this.token(";");
+}
+
+function TSExternalModuleReference(node) {
+  this.token("require(");
+  this.print(node.expression, node);
+  this.token(")");
+}
+
+function TSNonNullExpression(node) {
+  this.print(node.expression, node);
+  this.token("!");
+}
+
+function TSExportAssignment(node) {
+  this.word("export");
+  this.space();
+  this.token("=");
+  this.space();
+  this.print(node.expression, node);
+  this.token(";");
+}
+
+function TSNamespaceExportDeclaration(node) {
+  this.word("export");
+  this.space();
+  this.word("as");
+  this.space();
+  this.word("namespace");
+  this.space();
+  this.print(node.id, node);
+}
+
+function tsPrintSignatureDeclarationBase(node) {
+  const typeParameters = node.typeParameters,
+        parameters = node.parameters;
+  this.print(typeParameters, node);
+  this.token("(");
+
+  this._parameters(parameters, node);
+
+  this.token(")");
+  this.print(node.typeAnnotation, node);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/generator/lib/index.js b/node_modules/@babel/generator/lib/index.js
new file mode 100644
index 00000000..c8c46b6c
--- /dev/null
+++ b/node_modules/@babel/generator/lib/index.js
@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+exports.CodeGenerator = void 0;
+
+var _sourceMap = _interopRequireDefault(require("./source-map"));
+
+var _printer = _interopRequireDefault(require("./printer"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class Generator extends _printer.default {
+  constructor(ast, opts = {}, code) {
+    const format = normalizeOptions(code, opts);
+    const map = opts.sourceMaps ? new _sourceMap.default(opts, code) : null;
+    super(format, map);
+    this.ast = ast;
+  }
+
+  generate() {
+    return super.generate(this.ast);
+  }
+
+}
+
+function normalizeOptions(code, opts) {
+  const format = {
+    auxiliaryCommentBefore: opts.auxiliaryCommentBefore,
+    auxiliaryCommentAfter: opts.auxiliaryCommentAfter,
+    shouldPrintComment: opts.shouldPrintComment,
+    retainLines: opts.retainLines,
+    retainFunctionParens: opts.retainFunctionParens,
+    comments: opts.comments == null || opts.comments,
+    compact: opts.compact,
+    minified: opts.minified,
+    concise: opts.concise,
+    jsonCompatibleStrings: opts.jsonCompatibleStrings,
+    indent: {
+      adjustMultilineComment: true,
+      style: "  ",
+      base: 0
+    }
+  };
+
+  if (format.minified) {
+    format.compact = true;
+
+    format.shouldPrintComment = format.shouldPrintComment || (() => format.comments);
+  } else {
+    format.shouldPrintComment = format.shouldPrintComment || (value => format.comments || value.indexOf("@license") >= 0 || value.indexOf("@preserve") >= 0);
+  }
+
+  if (format.compact === "auto") {
+    format.compact = code.length > 500000;
+
+    if (format.compact) {
+      console.error("[BABEL] Note: The code generator has deoptimised the styling of " + `${opts.filename} as it exceeds the max of ${"500KB"}.`);
+    }
+  }
+
+  if (format.compact) {
+    format.indent.adjustMultilineComment = false;
+  }
+
+  return format;
+}
+
+class CodeGenerator {
+  constructor(ast, opts, code) {
+    this._generator = new Generator(ast, opts, code);
+  }
+
+  generate() {
+    return this._generator.generate();
+  }
+
+}
+
+exports.CodeGenerator = CodeGenerator;
+
+function _default(ast, opts, code) {
+  const gen = new Generator(ast, opts, code);
+  return gen.generate();
+}
\ No newline at end of file
diff --git a/node_modules/@babel/generator/lib/node/index.js b/node_modules/@babel/generator/lib/node/index.js
new file mode 100644
index 00000000..33fe31a5
--- /dev/null
+++ b/node_modules/@babel/generator/lib/node/index.js
@@ -0,0 +1,132 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.needsWhitespace = needsWhitespace;
+exports.needsWhitespaceBefore = needsWhitespaceBefore;
+exports.needsWhitespaceAfter = needsWhitespaceAfter;
+exports.needsParens = needsParens;
+
+var whitespace = _interopRequireWildcard(require("./whitespace"));
+
+var parens = _interopRequireWildcard(require("./parentheses"));
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function expandAliases(obj) {
+  const newObj = {};
+
+  function add(type, func) {
+    const fn = newObj[type];
+    newObj[type] = fn ? function (node, parent, stack) {
+      const result = fn(node, parent, stack);
+      return result == null ? func(node, parent, stack) : result;
+    } : func;
+  }
+
+  var _arr = Object.keys(obj);
+
+  for (var _i = 0; _i < _arr.length; _i++) {
+    const type = _arr[_i];
+    const aliases = t().FLIPPED_ALIAS_KEYS[type];
+
+    if (aliases) {
+      for (var _iterator = aliases, _isArray = Array.isArray(_iterator), _i2 = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+        var _ref;
+
+        if (_isArray) {
+          if (_i2 >= _iterator.length) break;
+          _ref = _iterator[_i2++];
+        } else {
+          _i2 = _iterator.next();
+          if (_i2.done) break;
+          _ref = _i2.value;
+        }
+
+        const alias = _ref;
+        add(alias, obj[type]);
+      }
+    } else {
+      add(type, obj[type]);
+    }
+  }
+
+  return newObj;
+}
+
+const expandedParens = expandAliases(parens);
+const expandedWhitespaceNodes = expandAliases(whitespace.nodes);
+const expandedWhitespaceList = expandAliases(whitespace.list);
+
+function find(obj, node, parent, printStack) {
+  const fn = obj[node.type];
+  return fn ? fn(node, parent, printStack) : null;
+}
+
+function isOrHasCallExpression(node) {
+  if (t().isCallExpression(node)) {
+    return true;
+  }
+
+  if (t().isMemberExpression(node)) {
+    return isOrHasCallExpression(node.object) || !node.computed && isOrHasCallExpression(node.property);
+  } else {
+    return false;
+  }
+}
+
+function needsWhitespace(node, parent, type) {
+  if (!node) return 0;
+
+  if (t().isExpressionStatement(node)) {
+    node = node.expression;
+  }
+
+  let linesInfo = find(expandedWhitespaceNodes, node, parent);
+
+  if (!linesInfo) {
+    const items = find(expandedWhitespaceList, node, parent);
+
+    if (items) {
+      for (let i = 0; i < items.length; i++) {
+        linesInfo = needsWhitespace(items[i], node, type);
+        if (linesInfo) break;
+      }
+    }
+  }
+
+  if (typeof linesInfo === "object" && linesInfo !== null) {
+    return linesInfo[type] || 0;
+  }
+
+  return 0;
+}
+
+function needsWhitespaceBefore(node, parent) {
+  return needsWhitespace(node, parent, "before");
+}
+
+function needsWhitespaceAfter(node, parent) {
+  return needsWhitespace(node, parent, "after");
+}
+
+function needsParens(node, parent, printStack) {
+  if (!parent) return false;
+
+  if (t().isNewExpression(parent) && parent.callee === node) {
+    if (isOrHasCallExpression(node)) return true;
+  }
+
+  return find(expandedParens, node, parent, printStack);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/generator/lib/node/parentheses.js b/node_modules/@babel/generator/lib/node/parentheses.js
new file mode 100644
index 00000000..88404718
--- /dev/null
+++ b/node_modules/@babel/generator/lib/node/parentheses.js
@@ -0,0 +1,238 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FunctionTypeAnnotation = exports.NullableTypeAnnotation = NullableTypeAnnotation;
+exports.UpdateExpression = UpdateExpression;
+exports.ObjectExpression = ObjectExpression;
+exports.DoExpression = DoExpression;
+exports.Binary = Binary;
+exports.IntersectionTypeAnnotation = exports.UnionTypeAnnotation = UnionTypeAnnotation;
+exports.TSAsExpression = TSAsExpression;
+exports.TSTypeAssertion = TSTypeAssertion;
+exports.BinaryExpression = BinaryExpression;
+exports.SequenceExpression = SequenceExpression;
+exports.AwaitExpression = exports.YieldExpression = YieldExpression;
+exports.ClassExpression = ClassExpression;
+exports.UnaryLike = UnaryLike;
+exports.FunctionExpression = FunctionExpression;
+exports.ArrowFunctionExpression = ArrowFunctionExpression;
+exports.ConditionalExpression = ConditionalExpression;
+exports.AssignmentExpression = AssignmentExpression;
+exports.NewExpression = NewExpression;
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+const PRECEDENCE = {
+  "||": 0,
+  "&&": 1,
+  "|": 2,
+  "^": 3,
+  "&": 4,
+  "==": 5,
+  "===": 5,
+  "!=": 5,
+  "!==": 5,
+  "<": 6,
+  ">": 6,
+  "<=": 6,
+  ">=": 6,
+  in: 6,
+  instanceof: 6,
+  ">>": 7,
+  "<<": 7,
+  ">>>": 7,
+  "+": 8,
+  "-": 8,
+  "*": 9,
+  "/": 9,
+  "%": 9,
+  "**": 10
+};
+
+const isClassExtendsClause = (node, parent) => (t().isClassDeclaration(parent) || t().isClassExpression(parent)) && parent.superClass === node;
+
+function NullableTypeAnnotation(node, parent) {
+  return t().isArrayTypeAnnotation(parent);
+}
+
+function UpdateExpression(node, parent) {
+  return t().isMemberExpression(parent, {
+    object: node
+  }) || t().isCallExpression(parent, {
+    callee: node
+  }) || t().isNewExpression(parent, {
+    callee: node
+  }) || isClassExtendsClause(node, parent);
+}
+
+function ObjectExpression(node, parent, printStack) {
+  return isFirstInStatement(printStack, {
+    considerArrow: true
+  });
+}
+
+function DoExpression(node, parent, printStack) {
+  return isFirstInStatement(printStack);
+}
+
+function Binary(node, parent) {
+  if (node.operator === "**" && t().isBinaryExpression(parent, {
+    operator: "**"
+  })) {
+    return parent.left === node;
+  }
+
+  if (isClassExtendsClause(node, parent)) {
+    return true;
+  }
+
+  if ((t().isCallExpression(parent) || t().isNewExpression(parent)) && parent.callee === node || t().isUnaryLike(parent) || t().isMemberExpression(parent) && parent.object === node || t().isAwaitExpression(parent)) {
+    return true;
+  }
+
+  if (t().isBinary(parent)) {
+    const parentOp = parent.operator;
+    const parentPos = PRECEDENCE[parentOp];
+    const nodeOp = node.operator;
+    const nodePos = PRECEDENCE[nodeOp];
+
+    if (parentPos === nodePos && parent.right === node && !t().isLogicalExpression(parent) || parentPos > nodePos) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function UnionTypeAnnotation(node, parent) {
+  return t().isArrayTypeAnnotation(parent) || t().isNullableTypeAnnotation(parent) || t().isIntersectionTypeAnnotation(parent) || t().isUnionTypeAnnotation(parent);
+}
+
+function TSAsExpression() {
+  return true;
+}
+
+function TSTypeAssertion() {
+  return true;
+}
+
+function BinaryExpression(node, parent) {
+  return node.operator === "in" && (t().isVariableDeclarator(parent) || t().isFor(parent));
+}
+
+function SequenceExpression(node, parent) {
+  if (t().isForStatement(parent) || t().isThrowStatement(parent) || t().isReturnStatement(parent) || t().isIfStatement(parent) && parent.test === node || t().isWhileStatement(parent) && parent.test === node || t().isForInStatement(parent) && parent.right === node || t().isSwitchStatement(parent) && parent.discriminant === node || t().isExpressionStatement(parent) && parent.expression === node) {
+    return false;
+  }
+
+  return true;
+}
+
+function YieldExpression(node, parent) {
+  return t().isBinary(parent) || t().isUnaryLike(parent) || t().isCallExpression(parent) || t().isMemberExpression(parent) || t().isNewExpression(parent) || t().isConditionalExpression(parent) && node === parent.test || isClassExtendsClause(node, parent);
+}
+
+function ClassExpression(node, parent, printStack) {
+  return isFirstInStatement(printStack, {
+    considerDefaultExports: true
+  });
+}
+
+function UnaryLike(node, parent) {
+  return t().isMemberExpression(parent, {
+    object: node
+  }) || t().isCallExpression(parent, {
+    callee: node
+  }) || t().isNewExpression(parent, {
+    callee: node
+  }) || t().isBinaryExpression(parent, {
+    operator: "**",
+    left: node
+  }) || isClassExtendsClause(node, parent);
+}
+
+function FunctionExpression(node, parent, printStack) {
+  return isFirstInStatement(printStack, {
+    considerDefaultExports: true
+  });
+}
+
+function ArrowFunctionExpression(node, parent) {
+  return t().isExportDeclaration(parent) || ConditionalExpression(node, parent);
+}
+
+function ConditionalExpression(node, parent) {
+  if (t().isUnaryLike(parent) || t().isBinary(parent) || t().isConditionalExpression(parent, {
+    test: node
+  }) || t().isAwaitExpression(parent) || t().isTaggedTemplateExpression(parent) || t().isTSTypeAssertion(parent) || t().isTSAsExpression(parent)) {
+    return true;
+  }
+
+  return UnaryLike(node, parent);
+}
+
+function AssignmentExpression(node) {
+  if (t().isObjectPattern(node.left)) {
+    return true;
+  } else {
+    return ConditionalExpression(...arguments);
+  }
+}
+
+function NewExpression(node, parent) {
+  return isClassExtendsClause(node, parent);
+}
+
+function isFirstInStatement(printStack, {
+  considerArrow = false,
+  considerDefaultExports = false
+} = {}) {
+  let i = printStack.length - 1;
+  let node = printStack[i];
+  i--;
+  let parent = printStack[i];
+
+  while (i > 0) {
+    if (t().isExpressionStatement(parent, {
+      expression: node
+    }) || t().isTaggedTemplateExpression(parent) || considerDefaultExports && t().isExportDefaultDeclaration(parent, {
+      declaration: node
+    }) || considerArrow && t().isArrowFunctionExpression(parent, {
+      body: node
+    })) {
+      return true;
+    }
+
+    if (t().isCallExpression(parent, {
+      callee: node
+    }) || t().isSequenceExpression(parent) && parent.expressions[0] === node || t().isMemberExpression(parent, {
+      object: node
+    }) || t().isConditional(parent, {
+      test: node
+    }) || t().isBinary(parent, {
+      left: node
+    }) || t().isAssignmentExpression(parent, {
+      left: node
+    })) {
+      node = parent;
+      i--;
+      parent = printStack[i];
+    } else {
+      return false;
+    }
+  }
+
+  return false;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/generator/lib/node/whitespace.js b/node_modules/@babel/generator/lib/node/whitespace.js
new file mode 100644
index 00000000..c0fdf69b
--- /dev/null
+++ b/node_modules/@babel/generator/lib/node/whitespace.js
@@ -0,0 +1,184 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.list = exports.nodes = void 0;
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function crawl(node, state = {}) {
+  if (t().isMemberExpression(node)) {
+    crawl(node.object, state);
+    if (node.computed) crawl(node.property, state);
+  } else if (t().isBinary(node) || t().isAssignmentExpression(node)) {
+    crawl(node.left, state);
+    crawl(node.right, state);
+  } else if (t().isCallExpression(node)) {
+    state.hasCall = true;
+    crawl(node.callee, state);
+  } else if (t().isFunction(node)) {
+    state.hasFunction = true;
+  } else if (t().isIdentifier(node)) {
+    state.hasHelper = state.hasHelper || isHelper(node.callee);
+  }
+
+  return state;
+}
+
+function isHelper(node) {
+  if (t().isMemberExpression(node)) {
+    return isHelper(node.object) || isHelper(node.property);
+  } else if (t().isIdentifier(node)) {
+    return node.name === "require" || node.name[0] === "_";
+  } else if (t().isCallExpression(node)) {
+    return isHelper(node.callee);
+  } else if (t().isBinary(node) || t().isAssignmentExpression(node)) {
+    return t().isIdentifier(node.left) && isHelper(node.left) || isHelper(node.right);
+  } else {
+    return false;
+  }
+}
+
+function isType(node) {
+  return t().isLiteral(node) || t().isObjectExpression(node) || t().isArrayExpression(node) || t().isIdentifier(node) || t().isMemberExpression(node);
+}
+
+const nodes = {
+  AssignmentExpression(node) {
+    const state = crawl(node.right);
+
+    if (state.hasCall && state.hasHelper || state.hasFunction) {
+      return {
+        before: state.hasFunction,
+        after: true
+      };
+    }
+  },
+
+  SwitchCase(node, parent) {
+    return {
+      before: node.consequent.length || parent.cases[0] === node,
+      after: !node.consequent.length && parent.cases[parent.cases.length - 1] === node
+    };
+  },
+
+  LogicalExpression(node) {
+    if (t().isFunction(node.left) || t().isFunction(node.right)) {
+      return {
+        after: true
+      };
+    }
+  },
+
+  Literal(node) {
+    if (node.value === "use strict") {
+      return {
+        after: true
+      };
+    }
+  },
+
+  CallExpression(node) {
+    if (t().isFunction(node.callee) || isHelper(node)) {
+      return {
+        before: true,
+        after: true
+      };
+    }
+  },
+
+  VariableDeclaration(node) {
+    for (let i = 0; i < node.declarations.length; i++) {
+      const declar = node.declarations[i];
+      let enabled = isHelper(declar.id) && !isType(declar.init);
+
+      if (!enabled) {
+        const state = crawl(declar.init);
+        enabled = isHelper(declar.init) && state.hasCall || state.hasFunction;
+      }
+
+      if (enabled) {
+        return {
+          before: true,
+          after: true
+        };
+      }
+    }
+  },
+
+  IfStatement(node) {
+    if (t().isBlockStatement(node.consequent)) {
+      return {
+        before: true,
+        after: true
+      };
+    }
+  }
+
+};
+exports.nodes = nodes;
+
+nodes.ObjectProperty = nodes.ObjectTypeProperty = nodes.ObjectMethod = function (node, parent) {
+  if (parent.properties[0] === node) {
+    return {
+      before: true
+    };
+  }
+};
+
+nodes.ObjectTypeCallProperty = function (node, parent) {
+  if (parent.callProperties[0] === node && (!parent.properties || !parent.properties.length)) {
+    return {
+      before: true
+    };
+  }
+};
+
+nodes.ObjectTypeIndexer = function (node, parent) {
+  if (parent.indexers[0] === node && (!parent.properties || !parent.properties.length) && (!parent.callProperties || !parent.callProperties.length)) {
+    return {
+      before: true
+    };
+  }
+};
+
+const list = {
+  VariableDeclaration(node) {
+    return node.declarations.map(decl => decl.init);
+  },
+
+  ArrayExpression(node) {
+    return node.elements;
+  },
+
+  ObjectExpression(node) {
+    return node.properties;
+  }
+
+};
+exports.list = list;
+[["Function", true], ["Class", true], ["Loop", true], ["LabeledStatement", true], ["SwitchStatement", true], ["TryStatement", true]].forEach(function ([type, amounts]) {
+  if (typeof amounts === "boolean") {
+    amounts = {
+      after: amounts,
+      before: amounts
+    };
+  }
+
+  [type].concat(t().FLIPPED_ALIAS_KEYS[type] || []).forEach(function (type) {
+    nodes[type] = function () {
+      return amounts;
+    };
+  });
+});
\ No newline at end of file
diff --git a/node_modules/@babel/generator/lib/printer.js b/node_modules/@babel/generator/lib/printer.js
new file mode 100644
index 00000000..dfa3156c
--- /dev/null
+++ b/node_modules/@babel/generator/lib/printer.js
@@ -0,0 +1,508 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _isInteger() {
+  const data = _interopRequireDefault(require("lodash/isInteger"));
+
+  _isInteger = function _isInteger() {
+    return data;
+  };
+
+  return data;
+}
+
+function _repeat() {
+  const data = _interopRequireDefault(require("lodash/repeat"));
+
+  _repeat = function _repeat() {
+    return data;
+  };
+
+  return data;
+}
+
+var _buffer = _interopRequireDefault(require("./buffer"));
+
+var n = _interopRequireWildcard(require("./node"));
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+var generatorFunctions = _interopRequireWildcard(require("./generators"));
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const SCIENTIFIC_NOTATION = /e/i;
+const ZERO_DECIMAL_INTEGER = /\.0+$/;
+const NON_DECIMAL_LITERAL = /^0[box]/;
+
+class Printer {
+  constructor(format, map) {
+    this.inForStatementInitCounter = 0;
+    this._printStack = [];
+    this._indent = 0;
+    this._insideAux = false;
+    this._printedCommentStarts = {};
+    this._parenPushNewlineState = null;
+    this._noLineTerminator = false;
+    this._printAuxAfterOnNextUserNode = false;
+    this._printedComments = new WeakSet();
+    this._endsWithInteger = false;
+    this._endsWithWord = false;
+    this.format = format || {};
+    this._buf = new _buffer.default(map);
+  }
+
+  generate(ast) {
+    this.print(ast);
+
+    this._maybeAddAuxComment();
+
+    return this._buf.get();
+  }
+
+  indent() {
+    if (this.format.compact || this.format.concise) return;
+    this._indent++;
+  }
+
+  dedent() {
+    if (this.format.compact || this.format.concise) return;
+    this._indent--;
+  }
+
+  semicolon(force = false) {
+    this._maybeAddAuxComment();
+
+    this._append(";", !force);
+  }
+
+  rightBrace() {
+    if (this.format.minified) {
+      this._buf.removeLastSemicolon();
+    }
+
+    this.token("}");
+  }
+
+  space(force = false) {
+    if (this.format.compact) return;
+
+    if (this._buf.hasContent() && !this.endsWith(" ") && !this.endsWith("\n") || force) {
+      this._space();
+    }
+  }
+
+  word(str) {
+    if (this._endsWithWord || this.endsWith("/") && str.indexOf("/") === 0) {
+      this._space();
+    }
+
+    this._maybeAddAuxComment();
+
+    this._append(str);
+
+    this._endsWithWord = true;
+  }
+
+  number(str) {
+    this.word(str);
+    this._endsWithInteger = (0, _isInteger().default)(+str) && !NON_DECIMAL_LITERAL.test(str) && !SCIENTIFIC_NOTATION.test(str) && !ZERO_DECIMAL_INTEGER.test(str) && str[str.length - 1] !== ".";
+  }
+
+  token(str) {
+    if (str === "--" && this.endsWith("!") || str[0] === "+" && this.endsWith("+") || str[0] === "-" && this.endsWith("-") || str[0] === "." && this._endsWithInteger) {
+      this._space();
+    }
+
+    this._maybeAddAuxComment();
+
+    this._append(str);
+  }
+
+  newline(i) {
+    if (this.format.retainLines || this.format.compact) return;
+
+    if (this.format.concise) {
+      this.space();
+      return;
+    }
+
+    if (this.endsWith("\n\n")) return;
+    if (typeof i !== "number") i = 1;
+    i = Math.min(2, i);
+    if (this.endsWith("{\n") || this.endsWith(":\n")) i--;
+    if (i <= 0) return;
+
+    for (let j = 0; j < i; j++) {
+      this._newline();
+    }
+  }
+
+  endsWith(str) {
+    return this._buf.endsWith(str);
+  }
+
+  removeTrailingNewline() {
+    this._buf.removeTrailingNewline();
+  }
+
+  source(prop, loc) {
+    this._catchUp(prop, loc);
+
+    this._buf.source(prop, loc);
+  }
+
+  withSource(prop, loc, cb) {
+    this._catchUp(prop, loc);
+
+    this._buf.withSource(prop, loc, cb);
+  }
+
+  _space() {
+    this._append(" ", true);
+  }
+
+  _newline() {
+    this._append("\n", true);
+  }
+
+  _append(str, queue = false) {
+    this._maybeAddParen(str);
+
+    this._maybeIndent(str);
+
+    if (queue) this._buf.queue(str);else this._buf.append(str);
+    this._endsWithWord = false;
+    this._endsWithInteger = false;
+  }
+
+  _maybeIndent(str) {
+    if (this._indent && this.endsWith("\n") && str[0] !== "\n") {
+      this._buf.queue(this._getIndent());
+    }
+  }
+
+  _maybeAddParen(str) {
+    const parenPushNewlineState = this._parenPushNewlineState;
+    if (!parenPushNewlineState) return;
+    this._parenPushNewlineState = null;
+    let i;
+
+    for (i = 0; i < str.length && str[i] === " "; i++) continue;
+
+    if (i === str.length) return;
+    const cha = str[i];
+
+    if (cha !== "\n") {
+      if (cha !== "/") return;
+      if (i + 1 === str.length) return;
+      const chaPost = str[i + 1];
+      if (chaPost !== "/" && chaPost !== "*") return;
+    }
+
+    this.token("(");
+    this.indent();
+    parenPushNewlineState.printed = true;
+  }
+
+  _catchUp(prop, loc) {
+    if (!this.format.retainLines) return;
+    const pos = loc ? loc[prop] : null;
+
+    if (pos && pos.line !== null) {
+      const count = pos.line - this._buf.getCurrentLine();
+
+      for (let i = 0; i < count; i++) {
+        this._newline();
+      }
+    }
+  }
+
+  _getIndent() {
+    return (0, _repeat().default)(this.format.indent.style, this._indent);
+  }
+
+  startTerminatorless(isLabel = false) {
+    if (isLabel) {
+      this._noLineTerminator = true;
+      return null;
+    } else {
+      return this._parenPushNewlineState = {
+        printed: false
+      };
+    }
+  }
+
+  endTerminatorless(state) {
+    this._noLineTerminator = false;
+
+    if (state && state.printed) {
+      this.dedent();
+      this.newline();
+      this.token(")");
+    }
+  }
+
+  print(node, parent) {
+    if (!node) return;
+    const oldConcise = this.format.concise;
+
+    if (node._compact) {
+      this.format.concise = true;
+    }
+
+    const printMethod = this[node.type];
+
+    if (!printMethod) {
+      throw new ReferenceError(`unknown node of type ${JSON.stringify(node.type)} with constructor ${JSON.stringify(node && node.constructor.name)}`);
+    }
+
+    this._printStack.push(node);
+
+    const oldInAux = this._insideAux;
+    this._insideAux = !node.loc;
+
+    this._maybeAddAuxComment(this._insideAux && !oldInAux);
+
+    let needsParens = n.needsParens(node, parent, this._printStack);
+
+    if (this.format.retainFunctionParens && node.type === "FunctionExpression" && node.extra && node.extra.parenthesized) {
+      needsParens = true;
+    }
+
+    if (needsParens) this.token("(");
+
+    this._printLeadingComments(node, parent);
+
+    const loc = t().isProgram(node) || t().isFile(node) ? null : node.loc;
+    this.withSource("start", loc, () => {
+      this[node.type](node, parent);
+    });
+
+    this._printTrailingComments(node, parent);
+
+    if (needsParens) this.token(")");
+
+    this._printStack.pop();
+
+    this.format.concise = oldConcise;
+    this._insideAux = oldInAux;
+  }
+
+  _maybeAddAuxComment(enteredPositionlessNode) {
+    if (enteredPositionlessNode) this._printAuxBeforeComment();
+    if (!this._insideAux) this._printAuxAfterComment();
+  }
+
+  _printAuxBeforeComment() {
+    if (this._printAuxAfterOnNextUserNode) return;
+    this._printAuxAfterOnNextUserNode = true;
+    const comment = this.format.auxiliaryCommentBefore;
+
+    if (comment) {
+      this._printComment({
+        type: "CommentBlock",
+        value: comment
+      });
+    }
+  }
+
+  _printAuxAfterComment() {
+    if (!this._printAuxAfterOnNextUserNode) return;
+    this._printAuxAfterOnNextUserNode = false;
+    const comment = this.format.auxiliaryCommentAfter;
+
+    if (comment) {
+      this._printComment({
+        type: "CommentBlock",
+        value: comment
+      });
+    }
+  }
+
+  getPossibleRaw(node) {
+    const extra = node.extra;
+
+    if (extra && extra.raw != null && extra.rawValue != null && node.value === extra.rawValue) {
+      return extra.raw;
+    }
+  }
+
+  printJoin(nodes, parent, opts = {}) {
+    if (!nodes || !nodes.length) return;
+    if (opts.indent) this.indent();
+    const newlineOpts = {
+      addNewlines: opts.addNewlines
+    };
+
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      if (!node) continue;
+      if (opts.statement) this._printNewline(true, node, parent, newlineOpts);
+      this.print(node, parent);
+
+      if (opts.iterator) {
+        opts.iterator(node, i);
+      }
+
+      if (opts.separator && i < nodes.length - 1) {
+        opts.separator.call(this);
+      }
+
+      if (opts.statement) this._printNewline(false, node, parent, newlineOpts);
+    }
+
+    if (opts.indent) this.dedent();
+  }
+
+  printAndIndentOnComments(node, parent) {
+    const indent = node.leadingComments && node.leadingComments.length > 0;
+    if (indent) this.indent();
+    this.print(node, parent);
+    if (indent) this.dedent();
+  }
+
+  printBlock(parent) {
+    const node = parent.body;
+
+    if (!t().isEmptyStatement(node)) {
+      this.space();
+    }
+
+    this.print(node, parent);
+  }
+
+  _printTrailingComments(node, parent) {
+    this._printComments(this._getComments(false, node, parent));
+  }
+
+  _printLeadingComments(node, parent) {
+    this._printComments(this._getComments(true, node, parent));
+  }
+
+  printInnerComments(node, indent = true) {
+    if (!node.innerComments || !node.innerComments.length) return;
+    if (indent) this.indent();
+
+    this._printComments(node.innerComments);
+
+    if (indent) this.dedent();
+  }
+
+  printSequence(nodes, parent, opts = {}) {
+    opts.statement = true;
+    return this.printJoin(nodes, parent, opts);
+  }
+
+  printList(items, parent, opts = {}) {
+    if (opts.separator == null) {
+      opts.separator = commaSeparator;
+    }
+
+    return this.printJoin(items, parent, opts);
+  }
+
+  _printNewline(leading, node, parent, opts) {
+    if (this.format.retainLines || this.format.compact) return;
+
+    if (this.format.concise) {
+      this.space();
+      return;
+    }
+
+    let lines = 0;
+
+    if (this._buf.hasContent()) {
+      if (!leading) lines++;
+      if (opts.addNewlines) lines += opts.addNewlines(leading, node) || 0;
+      const needs = leading ? n.needsWhitespaceBefore : n.needsWhitespaceAfter;
+      if (needs(node, parent)) lines++;
+    }
+
+    this.newline(lines);
+  }
+
+  _getComments(leading, node) {
+    return node && (leading ? node.leadingComments : node.trailingComments) || [];
+  }
+
+  _printComment(comment) {
+    if (!this.format.shouldPrintComment(comment.value)) return;
+    if (comment.ignore) return;
+    if (this._printedComments.has(comment)) return;
+
+    this._printedComments.add(comment);
+
+    if (comment.start != null) {
+      if (this._printedCommentStarts[comment.start]) return;
+      this._printedCommentStarts[comment.start] = true;
+    }
+
+    const isBlockComment = comment.type === "CommentBlock";
+    this.newline(this._buf.hasContent() && !this._noLineTerminator && isBlockComment ? 1 : 0);
+    if (!this.endsWith("[") && !this.endsWith("{")) this.space();
+    let val = !isBlockComment && !this._noLineTerminator ? `//${comment.value}\n` : `/*${comment.value}*/`;
+
+    if (isBlockComment && this.format.indent.adjustMultilineComment) {
+      const offset = comment.loc && comment.loc.start.column;
+
+      if (offset) {
+        const newlineRegex = new RegExp("\\n\\s{1," + offset + "}", "g");
+        val = val.replace(newlineRegex, "\n");
+      }
+
+      const indentSize = Math.max(this._getIndent().length, this._buf.getCurrentColumn());
+      val = val.replace(/\n(?!$)/g, `\n${(0, _repeat().default)(" ", indentSize)}`);
+    }
+
+    if (this.endsWith("/")) this._space();
+    this.withSource("start", comment.loc, () => {
+      this._append(val);
+    });
+    this.newline(isBlockComment && !this._noLineTerminator ? 1 : 0);
+  }
+
+  _printComments(comments) {
+    if (!comments || !comments.length) return;
+
+    for (var _iterator = comments, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i >= _iterator.length) break;
+        _ref = _iterator[_i++];
+      } else {
+        _i = _iterator.next();
+        if (_i.done) break;
+        _ref = _i.value;
+      }
+
+      const comment = _ref;
+
+      this._printComment(comment);
+    }
+  }
+
+}
+
+exports.default = Printer;
+Object.assign(Printer.prototype, generatorFunctions);
+
+function commaSeparator() {
+  this.token(",");
+  this.space();
+}
\ No newline at end of file
diff --git a/node_modules/@babel/generator/lib/source-map.js b/node_modules/@babel/generator/lib/source-map.js
new file mode 100644
index 00000000..d465fe58
--- /dev/null
+++ b/node_modules/@babel/generator/lib/source-map.js
@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _sourceMap() {
+  const data = _interopRequireDefault(require("source-map"));
+
+  _sourceMap = function _sourceMap() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class SourceMap {
+  constructor(opts, code) {
+    this._cachedMap = null;
+    this._code = code;
+    this._opts = opts;
+    this._rawMappings = [];
+  }
+
+  get() {
+    if (!this._cachedMap) {
+      const map = this._cachedMap = new (_sourceMap().default.SourceMapGenerator)({
+        sourceRoot: this._opts.sourceRoot
+      });
+      const code = this._code;
+
+      if (typeof code === "string") {
+        map.setSourceContent(this._opts.sourceFileName, code);
+      } else if (typeof code === "object") {
+        Object.keys(code).forEach(sourceFileName => {
+          map.setSourceContent(sourceFileName, code[sourceFileName]);
+        });
+      }
+
+      this._rawMappings.forEach(map.addMapping, map);
+    }
+
+    return this._cachedMap.toJSON();
+  }
+
+  getRawMappings() {
+    return this._rawMappings.slice();
+  }
+
+  mark(generatedLine, generatedColumn, line, column, identifierName, filename) {
+    if (this._lastGenLine !== generatedLine && line === null) return;
+
+    if (this._lastGenLine === generatedLine && this._lastSourceLine === line && this._lastSourceColumn === column) {
+      return;
+    }
+
+    this._cachedMap = null;
+    this._lastGenLine = generatedLine;
+    this._lastSourceLine = line;
+    this._lastSourceColumn = column;
+
+    this._rawMappings.push({
+      name: identifierName || undefined,
+      generated: {
+        line: generatedLine,
+        column: generatedColumn
+      },
+      source: line == null ? undefined : filename || this._opts.sourceFileName,
+      original: line == null ? undefined : {
+        line: line,
+        column: column
+      }
+    });
+  }
+
+}
+
+exports.default = SourceMap;
\ No newline at end of file
diff --git a/node_modules/@babel/generator/node_modules/.bin/jsesc b/node_modules/@babel/generator/node_modules/.bin/jsesc
new file mode 120000
index 00000000..7237604c
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/.bin/jsesc
@@ -0,0 +1 @@
+../jsesc/bin/jsesc
\ No newline at end of file
diff --git a/node_modules/@babel/generator/node_modules/jsesc/.bin/jsesc b/node_modules/@babel/generator/node_modules/jsesc/.bin/jsesc
new file mode 120000
index 00000000..a7499062
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/jsesc/.bin/jsesc
@@ -0,0 +1 @@
+../bin/jsesc
\ No newline at end of file
diff --git a/node_modules/@babel/generator/node_modules/jsesc/LICENSE-MIT.txt b/node_modules/@babel/generator/node_modules/jsesc/LICENSE-MIT.txt
new file mode 100644
index 00000000..a41e0a7e
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/jsesc/LICENSE-MIT.txt
@@ -0,0 +1,20 @@
+Copyright Mathias Bynens <https://mathiasbynens.be/>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/@babel/generator/node_modules/jsesc/README.md b/node_modules/@babel/generator/node_modules/jsesc/README.md
new file mode 100644
index 00000000..aae2b13a
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/jsesc/README.md
@@ -0,0 +1,421 @@
+# jsesc [![Build status](https://travis-ci.org/mathiasbynens/jsesc.svg?branch=master)](https://travis-ci.org/mathiasbynens/jsesc) [![Code coverage status](https://coveralls.io/repos/mathiasbynens/jsesc/badge.svg)](https://coveralls.io/r/mathiasbynens/jsesc) [![Dependency status](https://gemnasium.com/mathiasbynens/jsesc.svg)](https://gemnasium.com/mathiasbynens/jsesc)
+
+Given some data, _jsesc_ returns a stringified representation of that data. jsesc is similar to `JSON.stringify()` except:
+
+1. it outputs JavaScript instead of JSON [by default](#json), enabling support for data structures like ES6 maps and sets;
+2. it offers [many options](#api) to customize the output;
+3. its output is ASCII-safe [by default](#minimal), thanks to its use of [escape sequences](https://mathiasbynens.be/notes/javascript-escapes) where needed.
+
+For any input, jsesc generates the shortest possible valid printable-ASCII-only output. [Here’s an online demo.](https://mothereff.in/js-escapes)
+
+jsesc’s output can be used instead of `JSON.stringify`’s to avoid [mojibake](https://en.wikipedia.org/wiki/Mojibake) and other encoding issues, or even to [avoid errors](https://twitter.com/annevk/status/380000829643571200) when passing JSON-formatted data (which may contain U+2028 LINE SEPARATOR, U+2029 PARAGRAPH SEPARATOR, or [lone surrogates](https://esdiscuss.org/topic/code-points-vs-unicode-scalar-values#content-14)) to a JavaScript parser or an UTF-8 encoder.
+
+## Installation
+
+Via [npm](https://www.npmjs.com/):
+
+```bash
+npm install jsesc
+```
+
+In [Node.js](https://nodejs.org/):
+
+```js
+const jsesc = require('jsesc');
+```
+
+## API
+
+### `jsesc(value, options)`
+
+This function takes a value and returns an escaped version of the value where any characters that are not printable ASCII symbols are escaped using the shortest possible (but valid) [escape sequences for use in JavaScript strings](https://mathiasbynens.be/notes/javascript-escapes). The first supported value type is strings:
+
+```js
+jsesc('Ich ♥ Bücher');
+// → 'Ich \\u2665 B\\xFCcher'
+
+jsesc('foo 𝌆 bar');
+// → 'foo \\uD834\\uDF06 bar'
+```
+
+Instead of a string, the `value` can also be an array, an object, a map, a set, or a buffer. In such cases, `jsesc` returns a stringified version of the value where any characters that are not printable ASCII symbols are escaped in the same way.
+
+```js
+// Escaping an array
+jsesc([
+  'Ich ♥ Bücher', 'foo 𝌆 bar'
+]);
+// → '[\'Ich \\u2665 B\\xFCcher\',\'foo \\uD834\\uDF06 bar\']'
+
+// Escaping an object
+jsesc({
+  'Ich ♥ Bücher': 'foo 𝌆 bar'
+});
+// → '{\'Ich \\u2665 B\\xFCcher\':\'foo \\uD834\\uDF06 bar\'}'
+```
+
+The optional `options` argument accepts an object with the following options:
+
+#### `quotes`
+
+The default value for the `quotes` option is `'single'`. This means that any occurrences of `'` in the input string are escaped as `\'`, so that the output can be used in a string literal wrapped in single quotes.
+
+```js
+jsesc('`Lorem` ipsum "dolor" sit \'amet\' etc.');
+// → 'Lorem ipsum "dolor" sit \\\'amet\\\' etc.'
+
+jsesc('`Lorem` ipsum "dolor" sit \'amet\' etc.', {
+  'quotes': 'single'
+});
+// → '`Lorem` ipsum "dolor" sit \\\'amet\\\' etc.'
+// → "`Lorem` ipsum \"dolor\" sit \\'amet\\' etc."
+```
+
+If you want to use the output as part of a string literal wrapped in double quotes, set the `quotes` option to `'double'`.
+
+```js
+jsesc('`Lorem` ipsum "dolor" sit \'amet\' etc.', {
+  'quotes': 'double'
+});
+// → '`Lorem` ipsum \\"dolor\\" sit \'amet\' etc.'
+// → "`Lorem` ipsum \\\"dolor\\\" sit 'amet' etc."
+```
+
+If you want to use the output as part of a template literal (i.e. wrapped in backticks), set the `quotes` option to `'backtick'`.
+
+```js
+jsesc('`Lorem` ipsum "dolor" sit \'amet\' etc.', {
+  'quotes': 'backtick'
+});
+// → '\\`Lorem\\` ipsum "dolor" sit \'amet\' etc.'
+// → "\\`Lorem\\` ipsum \"dolor\" sit 'amet' etc."
+// → `\\\`Lorem\\\` ipsum "dolor" sit 'amet' etc.`
+```
+
+This setting also affects the output for arrays and objects:
+
+```js
+jsesc({ 'Ich ♥ Bücher': 'foo 𝌆 bar' }, {
+  'quotes': 'double'
+});
+// → '{"Ich \\u2665 B\\xFCcher":"foo \\uD834\\uDF06 bar"}'
+
+jsesc([ 'Ich ♥ Bücher', 'foo 𝌆 bar' ], {
+  'quotes': 'double'
+});
+// → '["Ich \\u2665 B\\xFCcher","foo \\uD834\\uDF06 bar"]'
+```
+
+#### `numbers`
+
+The default value for the `numbers` option is `'decimal'`. This means that any numeric values are represented using decimal integer literals. Other valid options are `binary`, `octal`, and `hexadecimal`, which result in binary integer literals, octal integer literals, and hexadecimal integer literals, respectively.
+
+```js
+jsesc(42, {
+  'numbers': 'binary'
+});
+// → '0b101010'
+
+jsesc(42, {
+  'numbers': 'octal'
+});
+// → '0o52'
+
+jsesc(42, {
+  'numbers': 'decimal'
+});
+// → '42'
+
+jsesc(42, {
+  'numbers': 'hexadecimal'
+});
+// → '0x2A'
+```
+
+#### `wrap`
+
+The `wrap` option takes a boolean value (`true` or `false`), and defaults to `false` (disabled). When enabled, the output is a valid JavaScript string literal wrapped in quotes. The type of quotes can be specified through the `quotes` setting.
+
+```js
+jsesc('Lorem ipsum "dolor" sit \'amet\' etc.', {
+  'quotes': 'single',
+  'wrap': true
+});
+// → '\'Lorem ipsum "dolor" sit \\\'amet\\\' etc.\''
+// → "\'Lorem ipsum \"dolor\" sit \\\'amet\\\' etc.\'"
+
+jsesc('Lorem ipsum "dolor" sit \'amet\' etc.', {
+  'quotes': 'double',
+  'wrap': true
+});
+// → '"Lorem ipsum \\"dolor\\" sit \'amet\' etc."'
+// → "\"Lorem ipsum \\\"dolor\\\" sit \'amet\' etc.\""
+```
+
+#### `es6`
+
+The `es6` option takes a boolean value (`true` or `false`), and defaults to `false` (disabled). When enabled, any astral Unicode symbols in the input are escaped using [ECMAScript 6 Unicode code point escape sequences](https://mathiasbynens.be/notes/javascript-escapes#unicode-code-point) instead of using separate escape sequences for each surrogate half. If backwards compatibility with ES5 environments is a concern, don’t enable this setting. If the `json` setting is enabled, the value for the `es6` setting is ignored (as if it was `false`).
+
+```js
+// By default, the `es6` option is disabled:
+jsesc('foo 𝌆 bar 💩 baz');
+// → 'foo \\uD834\\uDF06 bar \\uD83D\\uDCA9 baz'
+
+// To explicitly disable it:
+jsesc('foo 𝌆 bar 💩 baz', {
+  'es6': false
+});
+// → 'foo \\uD834\\uDF06 bar \\uD83D\\uDCA9 baz'
+
+// To enable it:
+jsesc('foo 𝌆 bar 💩 baz', {
+  'es6': true
+});
+// → 'foo \\u{1D306} bar \\u{1F4A9} baz'
+```
+
+#### `escapeEverything`
+
+The `escapeEverything` option takes a boolean value (`true` or `false`), and defaults to `false` (disabled). When enabled, all the symbols in the output are escaped — even printable ASCII symbols.
+
+```js
+jsesc('lolwat"foo\'bar', {
+  'escapeEverything': true
+});
+// → '\\x6C\\x6F\\x6C\\x77\\x61\\x74\\"\\x66\\x6F\\x6F\\\'\\x62\\x61\\x72'
+// → "\\x6C\\x6F\\x6C\\x77\\x61\\x74\\\"\\x66\\x6F\\x6F\\'\\x62\\x61\\x72"
+```
+
+This setting also affects the output for string literals within arrays and objects.
+
+#### `minimal`
+
+The `minimal` option takes a boolean value (`true` or `false`), and defaults to `false` (disabled). When enabled, only a limited set of symbols in the output are escaped:
+
+* U+0000 `\0`
+* U+0008 `\b`
+* U+0009 `\t`
+* U+000A `\n`
+* U+000C `\f`
+* U+000D `\r`
+* U+005C `\\`
+* U+2028 `\u2028`
+* U+2029 `\u2029`
+* whatever symbol is being used for wrapping string literals (based on [the `quotes` option](#quotes))
+
+Note: with this option enabled, jsesc output is no longer guaranteed to be ASCII-safe.
+
+```js
+jsesc('foo\u2029bar\nbaz©qux𝌆flops', {
+  'minimal': false
+});
+// → 'foo\\u2029bar\\nbaz©qux𝌆flops'
+```
+
+#### `isScriptContext`
+
+The `isScriptContext` option takes a boolean value (`true` or `false`), and defaults to `false` (disabled). When enabled, occurrences of [`</script` and `</style`](https://mathiasbynens.be/notes/etago) in the output are escaped as `<\/script` and `<\/style`, and [`<!--`](https://mathiasbynens.be/notes/etago#comment-8) is escaped as `\x3C!--` (or `\u003C!--` when the `json` option is enabled). This setting is useful when jsesc’s output ends up as part of a `<script>` or `<style>` element in an HTML document.
+
+```js
+jsesc('foo</script>bar', {
+  'isScriptContext': true
+});
+// → 'foo<\\/script>bar'
+```
+
+#### `compact`
+
+The `compact` option takes a boolean value (`true` or `false`), and defaults to `true` (enabled). When enabled, the output for arrays and objects is as compact as possible; it’s not formatted nicely.
+
+```js
+jsesc({ 'Ich ♥ Bücher': 'foo 𝌆 bar' }, {
+  'compact': true // this is the default
+});
+// → '{\'Ich \u2665 B\xFCcher\':\'foo \uD834\uDF06 bar\'}'
+
+jsesc({ 'Ich ♥ Bücher': 'foo 𝌆 bar' }, {
+  'compact': false
+});
+// → '{\n\t\'Ich \u2665 B\xFCcher\': \'foo \uD834\uDF06 bar\'\n}'
+
+jsesc([ 'Ich ♥ Bücher', 'foo 𝌆 bar' ], {
+  'compact': false
+});
+// → '[\n\t\'Ich \u2665 B\xFCcher\',\n\t\'foo \uD834\uDF06 bar\'\n]'
+```
+
+This setting has no effect on the output for strings.
+
+#### `indent`
+
+The `indent` option takes a string value, and defaults to `'\t'`. When the `compact` setting is enabled (`true`), the value of the `indent` option is used to format the output for arrays and objects.
+
+```js
+jsesc({ 'Ich ♥ Bücher': 'foo 𝌆 bar' }, {
+  'compact': false,
+  'indent': '\t' // this is the default
+});
+// → '{\n\t\'Ich \u2665 B\xFCcher\': \'foo \uD834\uDF06 bar\'\n}'
+
+jsesc({ 'Ich ♥ Bücher': 'foo 𝌆 bar' }, {
+  'compact': false,
+  'indent': '  '
+});
+// → '{\n  \'Ich \u2665 B\xFCcher\': \'foo \uD834\uDF06 bar\'\n}'
+
+jsesc([ 'Ich ♥ Bücher', 'foo 𝌆 bar' ], {
+  'compact': false,
+  'indent': '  '
+});
+// → '[\n  \'Ich \u2665 B\xFCcher\',\n\  t\'foo \uD834\uDF06 bar\'\n]'
+```
+
+This setting has no effect on the output for strings.
+
+#### `indentLevel`
+
+The `indentLevel` option takes a numeric value, and defaults to `0`. It represents the current indentation level, i.e. the number of times the value of [the `indent` option](#indent) is repeated.
+
+```js
+jsesc(['a', 'b', 'c'], {
+  'compact': false,
+  'indentLevel': 1
+});
+// → '[\n\t\t\'a\',\n\t\t\'b\',\n\t\t\'c\'\n\t]'
+
+jsesc(['a', 'b', 'c'], {
+  'compact': false,
+  'indentLevel': 2
+});
+// → '[\n\t\t\t\'a\',\n\t\t\t\'b\',\n\t\t\t\'c\'\n\t\t]'
+```
+
+#### `json`
+
+The `json` option takes a boolean value (`true` or `false`), and defaults to `false` (disabled). When enabled, the output is valid JSON. [Hexadecimal character escape sequences](https://mathiasbynens.be/notes/javascript-escapes#hexadecimal) and [the `\v` or `\0` escape sequences](https://mathiasbynens.be/notes/javascript-escapes#single) are not used. Setting `json: true` implies `quotes: 'double', wrap: true, es6: false`, although these values can still be overridden if needed — but in such cases, the output won’t be valid JSON anymore.
+
+```js
+jsesc('foo\x00bar\xFF\uFFFDbaz', {
+  'json': true
+});
+// → '"foo\\u0000bar\\u00FF\\uFFFDbaz"'
+
+jsesc({ 'foo\x00bar\xFF\uFFFDbaz': 'foo\x00bar\xFF\uFFFDbaz' }, {
+  'json': true
+});
+// → '{"foo\\u0000bar\\u00FF\\uFFFDbaz":"foo\\u0000bar\\u00FF\\uFFFDbaz"}'
+
+jsesc([ 'foo\x00bar\xFF\uFFFDbaz', 'foo\x00bar\xFF\uFFFDbaz' ], {
+  'json': true
+});
+// → '["foo\\u0000bar\\u00FF\\uFFFDbaz","foo\\u0000bar\\u00FF\\uFFFDbaz"]'
+
+// Values that are acceptable in JSON but aren’t strings, arrays, or object
+// literals can’t be escaped, so they’ll just be preserved:
+jsesc([ 'foo\x00bar', [1, '©', { 'foo': true, 'qux': null }], 42 ], {
+  'json': true
+});
+// → '["foo\\u0000bar",[1,"\\u00A9",{"foo":true,"qux":null}],42]'
+// Values that aren’t allowed in JSON are run through `JSON.stringify()`:
+jsesc([ undefined, -Infinity ], {
+  'json': true
+});
+// → '[null,null]'
+```
+
+**Note:** Using this option on objects or arrays that contain non-string values relies on `JSON.stringify()`. For legacy environments like IE ≤ 7, use [a `JSON` polyfill](http://bestiejs.github.io/json3/).
+
+#### `lowercaseHex`
+
+The `lowercaseHex` option takes a boolean value (`true` or `false`), and defaults to `false` (disabled). When enabled, any alphabetical hexadecimal digits in escape sequences as well as any hexadecimal integer literals (see [the `numbers` option](#numbers)) in the output are in lowercase.
+
+```js
+jsesc('Ich ♥ Bücher', {
+  'lowercaseHex': true
+});
+// → 'Ich \\u2665 B\\xfccher'
+//                    ^^
+
+jsesc(42, {
+  'numbers': 'hexadecimal',
+  'lowercaseHex': true
+});
+// → '0x2a'
+//      ^^
+```
+
+### `jsesc.version`
+
+A string representing the semantic version number.
+
+### Using the `jsesc` binary
+
+To use the `jsesc` binary in your shell, simply install jsesc globally using npm:
+
+```bash
+npm install -g jsesc
+```
+
+After that you’re able to escape strings from the command line:
+
+```bash
+$ jsesc 'föo ♥ bår 𝌆 baz'
+f\xF6o \u2665 b\xE5r \uD834\uDF06 baz
+```
+
+To escape arrays or objects containing string values, use the `-o`/`--object` option:
+
+```bash
+$ jsesc --object '{ "föo": "♥", "bår": "𝌆 baz" }'
+{'f\xF6o':'\u2665','b\xE5r':'\uD834\uDF06 baz'}
+```
+
+To prettify the output in such cases, use the `-p`/`--pretty` option:
+
+```bash
+$ jsesc --pretty '{ "föo": "♥", "bår": "𝌆 baz" }'
+{
+  'f\xF6o': '\u2665',
+  'b\xE5r': '\uD834\uDF06 baz'
+}
+```
+
+For valid JSON output, use the `-j`/`--json` option:
+
+```bash
+$ jsesc --json --pretty '{ "föo": "♥", "bår": "𝌆 baz" }'
+{
+  "f\u00F6o": "\u2665",
+  "b\u00E5r": "\uD834\uDF06 baz"
+}
+```
+
+Read a local JSON file, escape any non-ASCII symbols, and save the result to a new file:
+
+```bash
+$ jsesc --json --object < data-raw.json > data-escaped.json
+```
+
+Or do the same with an online JSON file:
+
+```bash
+$ curl -sL "http://git.io/aorKgQ" | jsesc --json --object > data-escaped.json
+```
+
+See `jsesc --help` for the full list of options.
+
+## Support
+
+As of v2.0.0, jsesc supports Node.js v4+ only.
+
+Older versions (up to jsesc v1.3.0) support Chrome 27, Firefox 3, Safari 4, Opera 10, IE 6, Node.js v6.0.0, Narwhal 0.3.2, RingoJS 0.8-0.11, PhantomJS 1.9.0, and Rhino 1.7RC4. **Note:** Using the `json` option on objects or arrays that contain non-string values relies on `JSON.parse()`. For legacy environments like IE ≤ 7, use [a `JSON` polyfill](https://bestiejs.github.io/json3/).
+
+## Author
+
+| [![twitter/mathias](https://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](https://twitter.com/mathias "Follow @mathias on Twitter") |
+|---|
+| [Mathias Bynens](https://mathiasbynens.be/) |
+
+## License
+
+This library is available under the [MIT](https://mths.be/mit) license.
diff --git a/node_modules/@babel/generator/node_modules/jsesc/bin/jsesc b/node_modules/@babel/generator/node_modules/jsesc/bin/jsesc
new file mode 100755
index 00000000..e9a541db
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/jsesc/bin/jsesc
@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+(function() {
+
+	var fs = require('fs');
+	var stringEscape = require('../jsesc.js');
+	var strings = process.argv.splice(2);
+	var stdin = process.stdin;
+	var data;
+	var timeout;
+	var isObject = false;
+	var options = {};
+	var log = console.log;
+
+	var main = function() {
+		var option = strings[0];
+
+		if (/^(?:-h|--help|undefined)$/.test(option)) {
+			log(
+				'jsesc v%s - https://mths.be/jsesc',
+				stringEscape.version
+			);
+			log([
+				'\nUsage:\n',
+				'\tjsesc [string]',
+				'\tjsesc [-s | --single-quotes] [string]',
+				'\tjsesc [-d | --double-quotes] [string]',
+				'\tjsesc [-w | --wrap] [string]',
+				'\tjsesc [-e | --escape-everything] [string]',
+				'\tjsesc [-t | --escape-etago] [string]',
+				'\tjsesc [-6 | --es6] [string]',
+				'\tjsesc [-l | --lowercase-hex] [string]',
+				'\tjsesc [-j | --json] [string]',
+				'\tjsesc [-o | --object] [stringified_object]', // `JSON.parse()` the argument
+				'\tjsesc [-p | --pretty] [string]', // `compact: false`
+				'\tjsesc [-v | --version]',
+				'\tjsesc [-h | --help]',
+				'\nExamples:\n',
+				'\tjsesc \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\'',
+				'\tjsesc --json \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\'',
+				'\tjsesc --json --escape-everything \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\'',
+				'\tjsesc --double-quotes --wrap \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\'',
+				'\techo \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\' | jsesc'
+			].join('\n'));
+			return process.exit(1);
+		}
+
+		if (/^(?:-v|--version)$/.test(option)) {
+			log('v%s', stringEscape.version);
+			return process.exit(1);
+		}
+
+		strings.forEach(function(string) {
+			// Process options
+			if (/^(?:-s|--single-quotes)$/.test(string)) {
+				options.quotes = 'single';
+				return;
+			}
+			if (/^(?:-d|--double-quotes)$/.test(string)) {
+				options.quotes = 'double';
+				return;
+			}
+			if (/^(?:-w|--wrap)$/.test(string)) {
+				options.wrap = true;
+				return;
+			}
+			if (/^(?:-e|--escape-everything)$/.test(string)) {
+				options.escapeEverything = true;
+				return;
+			}
+			if (/^(?:-t|--escape-etago)$/.test(string)) {
+				options.escapeEtago = true;
+				return;
+			}
+			if (/^(?:-6|--es6)$/.test(string)) {
+				options.es6 = true;
+				return;
+			}
+			if (/^(?:-l|--lowercase-hex)$/.test(string)) {
+				options.lowercaseHex = true;
+				return;
+			}
+			if (/^(?:-j|--json)$/.test(string)) {
+				options.json = true;
+				return;
+			}
+			if (/^(?:-o|--object)$/.test(string)) {
+				isObject = true;
+				return;
+			}
+			if (/^(?:-p|--pretty)$/.test(string)) {
+				isObject = true;
+				options.compact = false;
+				return;
+			}
+
+			// Process string(s)
+			var result;
+			try {
+				if (isObject) {
+					string = JSON.parse(string);
+				}
+				result = stringEscape(string, options);
+				log(result);
+			} catch(error) {
+				log(error.message + '\n');
+				log('Error: failed to escape.');
+				log('If you think this is a bug in jsesc, please report it:');
+				log('https://github.com/mathiasbynens/jsesc/issues/new');
+				log(
+					'\nStack trace using jsesc@%s:\n',
+					stringEscape.version
+				);
+				log(error.stack);
+				return process.exit(1);
+			}
+		});
+		// Return with exit status 0 outside of the `forEach` loop, in case
+		// multiple strings were passed in.
+		return process.exit(0);
+
+	};
+
+	if (stdin.isTTY) {
+		// handle shell arguments
+		main();
+	} else {
+		// Either the script is called from within a non-TTY context,
+		// or `stdin` content is being piped in.
+		if (!process.stdout.isTTY) { // called from a non-TTY context
+			timeout = setTimeout(function() {
+				// if no piped data arrived after a while, handle shell arguments
+				main();
+			}, 250);
+		}
+
+		data = '';
+		stdin.on('data', function(chunk) {
+			clearTimeout(timeout);
+			data += chunk;
+		});
+		stdin.on('end', function() {
+			strings.push(data.trim());
+			main();
+		});
+		stdin.resume();
+	}
+
+}());
diff --git a/node_modules/@babel/generator/node_modules/jsesc/jsesc.js b/node_modules/@babel/generator/node_modules/jsesc/jsesc.js
new file mode 100644
index 00000000..5052af31
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/jsesc/jsesc.js
@@ -0,0 +1,329 @@
+'use strict';
+
+const object = {};
+const hasOwnProperty = object.hasOwnProperty;
+const forOwn = (object, callback) => {
+	for (const key in object) {
+		if (hasOwnProperty.call(object, key)) {
+			callback(key, object[key]);
+		}
+	}
+};
+
+const extend = (destination, source) => {
+	if (!source) {
+		return destination;
+	}
+	forOwn(source, (key, value) => {
+		destination[key] = value;
+	});
+	return destination;
+};
+
+const forEach = (array, callback) => {
+	const length = array.length;
+	let index = -1;
+	while (++index < length) {
+		callback(array[index]);
+	}
+};
+
+const toString = object.toString;
+const isArray = Array.isArray;
+const isBuffer = Buffer.isBuffer;
+const isObject = (value) => {
+	// This is a very simple check, but it’s good enough for what we need.
+	return toString.call(value) == '[object Object]';
+};
+const isString = (value) => {
+	return typeof value == 'string' ||
+		toString.call(value) == '[object String]';
+};
+const isNumber = (value) => {
+	return typeof value == 'number' ||
+		toString.call(value) == '[object Number]';
+};
+const isFunction = (value) => {
+	return typeof value == 'function';
+};
+const isMap = (value) => {
+	return toString.call(value) == '[object Map]';
+};
+const isSet = (value) => {
+	return toString.call(value) == '[object Set]';
+};
+
+/*--------------------------------------------------------------------------*/
+
+// https://mathiasbynens.be/notes/javascript-escapes#single
+const singleEscapes = {
+	'"': '\\"',
+	'\'': '\\\'',
+	'\\': '\\\\',
+	'\b': '\\b',
+	'\f': '\\f',
+	'\n': '\\n',
+	'\r': '\\r',
+	'\t': '\\t'
+	// `\v` is omitted intentionally, because in IE < 9, '\v' == 'v'.
+	// '\v': '\\x0B'
+};
+const regexSingleEscape = /["'\\\b\f\n\r\t]/;
+
+const regexDigit = /[0-9]/;
+const regexWhitelist = /[ !#-&\(-\[\]-~]/;
+
+const jsesc = (argument, options) => {
+	const increaseIndentation = () => {
+		oldIndent = indent;
+		++options.indentLevel;
+		indent = options.indent.repeat(options.indentLevel)
+	};
+	// Handle options
+	const defaults = {
+		'escapeEverything': false,
+		'minimal': false,
+		'isScriptContext': false,
+		'quotes': 'single',
+		'wrap': false,
+		'es6': false,
+		'json': false,
+		'compact': true,
+		'lowercaseHex': false,
+		'numbers': 'decimal',
+		'indent': '\t',
+		'indentLevel': 0,
+		'__inline1__': false,
+		'__inline2__': false
+	};
+	const json = options && options.json;
+	if (json) {
+		defaults.quotes = 'double';
+		defaults.wrap = true;
+	}
+	options = extend(defaults, options);
+	if (
+		options.quotes != 'single' &&
+		options.quotes != 'double' &&
+		options.quotes != 'backtick'
+	) {
+		options.quotes = 'single';
+	}
+	const quote = options.quotes == 'double' ?
+		'"' :
+		(options.quotes == 'backtick' ?
+			'`' :
+			'\''
+		);
+	const compact = options.compact;
+	const lowercaseHex = options.lowercaseHex;
+	let indent = options.indent.repeat(options.indentLevel);
+	let oldIndent = '';
+	const inline1 = options.__inline1__;
+	const inline2 = options.__inline2__;
+	const newLine = compact ? '' : '\n';
+	let result;
+	let isEmpty = true;
+	const useBinNumbers = options.numbers == 'binary';
+	const useOctNumbers = options.numbers == 'octal';
+	const useDecNumbers = options.numbers == 'decimal';
+	const useHexNumbers = options.numbers == 'hexadecimal';
+
+	if (json && argument && isFunction(argument.toJSON)) {
+		argument = argument.toJSON();
+	}
+
+	if (!isString(argument)) {
+		if (isMap(argument)) {
+			if (argument.size == 0) {
+				return 'new Map()';
+			}
+			if (!compact) {
+				options.__inline1__ = true;
+				options.__inline2__ = false;
+			}
+			return 'new Map(' + jsesc(Array.from(argument), options) + ')';
+		}
+		if (isSet(argument)) {
+			if (argument.size == 0) {
+				return 'new Set()';
+			}
+			return 'new Set(' + jsesc(Array.from(argument), options) + ')';
+		}
+		if (isBuffer(argument)) {
+			if (argument.length == 0) {
+				return 'Buffer.from([])';
+			}
+			return 'Buffer.from(' + jsesc(Array.from(argument), options) + ')';
+		}
+		if (isArray(argument)) {
+			result = [];
+			options.wrap = true;
+			if (inline1) {
+				options.__inline1__ = false;
+				options.__inline2__ = true;
+			}
+			if (!inline2) {
+				increaseIndentation();
+			}
+			forEach(argument, (value) => {
+				isEmpty = false;
+				if (inline2) {
+					options.__inline2__ = false;
+				}
+				result.push(
+					(compact || inline2 ? '' : indent) +
+					jsesc(value, options)
+				);
+			});
+			if (isEmpty) {
+				return '[]';
+			}
+			if (inline2) {
+				return '[' + result.join(', ') + ']';
+			}
+			return '[' + newLine + result.join(',' + newLine) + newLine +
+				(compact ? '' : oldIndent) + ']';
+		} else if (isNumber(argument)) {
+			if (json) {
+				// Some number values (e.g. `Infinity`) cannot be represented in JSON.
+				return JSON.stringify(argument);
+			}
+			if (useDecNumbers) {
+				return String(argument);
+			}
+			if (useHexNumbers) {
+				let hexadecimal = argument.toString(16);
+				if (!lowercaseHex) {
+					hexadecimal = hexadecimal.toUpperCase();
+				}
+				return '0x' + hexadecimal;
+			}
+			if (useBinNumbers) {
+				return '0b' + argument.toString(2);
+			}
+			if (useOctNumbers) {
+				return '0o' + argument.toString(8);
+			}
+		} else if (!isObject(argument)) {
+			if (json) {
+				// For some values (e.g. `undefined`, `function` objects),
+				// `JSON.stringify(value)` returns `undefined` (which isn’t valid
+				// JSON) instead of `'null'`.
+				return JSON.stringify(argument) || 'null';
+			}
+			return String(argument);
+		} else { // it’s an object
+			result = [];
+			options.wrap = true;
+			increaseIndentation();
+			forOwn(argument, (key, value) => {
+				isEmpty = false;
+				result.push(
+					(compact ? '' : indent) +
+					jsesc(key, options) + ':' +
+					(compact ? '' : ' ') +
+					jsesc(value, options)
+				);
+			});
+			if (isEmpty) {
+				return '{}';
+			}
+			return '{' + newLine + result.join(',' + newLine) + newLine +
+				(compact ? '' : oldIndent) + '}';
+		}
+	}
+
+	const string = argument;
+	// Loop over each code unit in the string and escape it
+	let index = -1;
+	const length = string.length;
+	result = '';
+	while (++index < length) {
+		const character = string.charAt(index);
+		if (options.es6) {
+			const first = string.charCodeAt(index);
+			if ( // check if it’s the start of a surrogate pair
+				first >= 0xD800 && first <= 0xDBFF && // high surrogate
+				length > index + 1 // there is a next code unit
+			) {
+				const second = string.charCodeAt(index + 1);
+				if (second >= 0xDC00 && second <= 0xDFFF) { // low surrogate
+					// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+					const codePoint = (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
+					let hexadecimal = codePoint.toString(16);
+					if (!lowercaseHex) {
+						hexadecimal = hexadecimal.toUpperCase();
+					}
+					result += '\\u{' + hexadecimal + '}';
+					++index;
+					continue;
+				}
+			}
+		}
+		if (!options.escapeEverything) {
+			if (regexWhitelist.test(character)) {
+				// It’s a printable ASCII character that is not `"`, `'` or `\`,
+				// so don’t escape it.
+				result += character;
+				continue;
+			}
+			if (character == '"') {
+				result += quote == character ? '\\"' : character;
+				continue;
+			}
+			if (character == '`') {
+				result += quote == character ? '\\`' : character;
+				continue;
+			}
+			if (character == '\'') {
+				result += quote == character ? '\\\'' : character;
+				continue;
+			}
+		}
+		if (
+			character == '\0' &&
+			!json &&
+			!regexDigit.test(string.charAt(index + 1))
+		) {
+			result += '\\0';
+			continue;
+		}
+		if (regexSingleEscape.test(character)) {
+			// no need for a `hasOwnProperty` check here
+			result += singleEscapes[character];
+			continue;
+		}
+		const charCode = character.charCodeAt(0);
+		if (options.minimal && charCode != 0x2028 && charCode != 0x2029) {
+			result += character;
+			continue;
+		}
+		let hexadecimal = charCode.toString(16);
+		if (!lowercaseHex) {
+			hexadecimal = hexadecimal.toUpperCase();
+		}
+		const longhand = hexadecimal.length > 2 || json;
+		const escaped = '\\' + (longhand ? 'u' : 'x') +
+			('0000' + hexadecimal).slice(longhand ? -4 : -2);
+		result += escaped;
+		continue;
+	}
+	if (options.wrap) {
+		result = quote + result + quote;
+	}
+	if (quote == '`') {
+		result = result.replace(/\$\{/g, '\\\$\{');
+	}
+	if (options.isScriptContext) {
+		// https://mathiasbynens.be/notes/etago
+		return result
+			.replace(/<\/(script|style)/gi, '<\\/$1')
+			.replace(/<!--/g, json ? '\\u003C!--' : '\\x3C!--');
+	}
+	return result;
+};
+
+jsesc.version = '2.5.1';
+
+module.exports = jsesc;
diff --git a/node_modules/@babel/generator/node_modules/jsesc/man/jsesc.1 b/node_modules/@babel/generator/node_modules/jsesc/man/jsesc.1
new file mode 100644
index 00000000..2655ee7a
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/jsesc/man/jsesc.1
@@ -0,0 +1,94 @@
+.Dd May 13, 2016
+.Dt jsesc 1
+.Sh NAME
+.Nm jsesc
+.Nd escape strings for use in JavaScript string literals
+.Sh SYNOPSIS
+.Nm
+.Op Fl s | -single-quotes Ar string
+.br
+.Op Fl d | -double-quotes Ar string
+.br
+.Op Fl w | -wrap Ar string
+.br
+.Op Fl e | -escape-everything Ar string
+.br
+.Op Fl 6 | -es6 Ar string
+.br
+.Op Fl l | -lowercase-hex Ar string
+.br
+.Op Fl j | -json Ar string
+.br
+.Op Fl p | -object Ar string
+.br
+.Op Fl p | -pretty Ar string
+.br
+.Op Fl v | -version
+.br
+.Op Fl h | -help
+.Sh DESCRIPTION
+.Nm
+escapes strings for use in JavaScript string literals while generating the shortest possible valid ASCII-only output.
+.Sh OPTIONS
+.Bl -ohang -offset
+.It Sy "-s, --single-quotes"
+Escape any occurrences of ' in the input string as \\', so that the output can be used in a JavaScript string literal wrapped in single quotes.
+.It Sy "-d, --double-quotes"
+Escape any occurrences of " in the input string as \\", so that the output can be used in a JavaScript string literal wrapped in double quotes.
+.It Sy "-w, --wrap"
+Make sure the output is a valid JavaScript string literal wrapped in quotes. The type of quotes can be specified using the
+.Ar -s | --single-quotes
+or
+.Ar -d | --double-quotes
+settings.
+.It Sy "-6, --es6"
+Escape any astral Unicode symbols using ECMAScript 6 Unicode code point escape sequences.
+.It Sy "-e, --escape-everything"
+Escape all the symbols in the output, even printable ASCII symbols.
+.It Sy "-j, --json"
+Make sure the output is valid JSON. Hexadecimal character escape sequences and the \\v or \\0 escape sequences will not be used. Setting this flag enables the
+.Ar -d | --double-quotes
+and
+.Ar -w | --wrap
+settings.
+.It Sy "-o, --object"
+Treat the input as a JavaScript object rather than a string. Accepted values are flat arrays containing only string values, and flat objects containing only string values.
+.It Sy "-p, --pretty"
+Pretty-print the output for objects, using whitespace to make it more readable. Setting this flag enables the
+.It Sy "-l, --lowercase-hex"
+Use lowercase for alphabetical hexadecimal digits in escape sequences.
+.Ar -o | --object
+setting.
+.It Sy "-v, --version"
+Print jsesc's version.
+.It Sy "-h, --help"
+Show the help screen.
+.El
+.Sh EXIT STATUS
+The
+.Nm jsesc
+utility exits with one of the following values:
+.Pp
+.Bl -tag -width flag -compact
+.It Li 0
+.Nm
+successfully escaped the given string and printed the result.
+.It Li 1
+.Nm
+wasn't instructed to escape anything (for example, the
+.Ar --help
+flag was set); or, an error occurred.
+.El
+.Sh EXAMPLES
+.Bl -ohang -offset
+.It Sy "jsesc 'foo bar baz'"
+Print an escaped version of the given string.
+.It Sy echo\ 'foo bar baz'\ |\ jsesc
+Print an escaped version of the string that gets piped in.
+.El
+.Sh BUGS
+jsesc's bug tracker is located at <https://github.com/mathiasbynens/jsesc/issues>.
+.Sh AUTHOR
+Mathias Bynens <https://mathiasbynens.be/>
+.Sh WWW
+<https://mths.be/jsesc>
diff --git a/node_modules/@babel/generator/node_modules/jsesc/package.json b/node_modules/@babel/generator/node_modules/jsesc/package.json
new file mode 100644
index 00000000..9164f70e
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/jsesc/package.json
@@ -0,0 +1,54 @@
+{
+  "name": "jsesc",
+  "version": "2.5.1",
+  "description": "Given some data, jsesc returns the shortest possible stringified & ASCII-safe representation of that data.",
+  "homepage": "https://mths.be/jsesc",
+  "engines": {
+    "node": ">=4"
+  },
+  "main": "jsesc.js",
+  "bin": "bin/jsesc",
+  "man": "man/jsesc.1",
+  "keywords": [
+    "buffer",
+    "escape",
+    "javascript",
+    "json",
+    "map",
+    "set",
+    "string",
+    "stringify",
+    "tool"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Mathias Bynens",
+    "url": "https://mathiasbynens.be/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mathiasbynens/jsesc.git"
+  },
+  "bugs": "https://github.com/mathiasbynens/jsesc/issues",
+  "files": [
+    "LICENSE-MIT.txt",
+    "jsesc.js",
+    "bin/",
+    "man/"
+  ],
+  "scripts": {
+    "build": "grunt template",
+    "coveralls": "istanbul cover --verbose --dir 'coverage' 'tests/tests.js' && coveralls < coverage/lcov.info'",
+    "cover": "istanbul cover --report 'html' --verbose --dir 'coverage' 'tests/tests.js'",
+    "test": "mocha tests"
+  },
+  "devDependencies": {
+    "coveralls": "^2.11.6",
+    "grunt": "^0.4.5",
+    "grunt-template": "^0.2.3",
+    "istanbul": "^0.4.2",
+    "mocha": "*",
+    "regenerate": "^1.3.0",
+    "requirejs": "^2.1.22"
+  }
+}
diff --git a/node_modules/@babel/generator/node_modules/source-map/CHANGELOG.md b/node_modules/@babel/generator/node_modules/source-map/CHANGELOG.md
new file mode 100644
index 00000000..3a8c066c
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/source-map/CHANGELOG.md
@@ -0,0 +1,301 @@
+# Change Log
+
+## 0.5.6
+
+* Fix for regression when people were using numbers as names in source maps. See
+  #236.
+
+## 0.5.5
+
+* Fix "regression" of unsupported, implementation behavior that half the world
+  happens to have come to depend on. See #235.
+
+* Fix regression involving function hoisting in SpiderMonkey. See #233.
+
+## 0.5.4
+
+* Large performance improvements to source-map serialization. See #228 and #229.
+
+## 0.5.3
+
+* Do not include unnecessary distribution files. See
+  commit ef7006f8d1647e0a83fdc60f04f5a7ca54886f86.
+
+## 0.5.2
+
+* Include browser distributions of the library in package.json's `files`. See
+  issue #212.
+
+## 0.5.1
+
+* Fix latent bugs in IndexedSourceMapConsumer.prototype._parseMappings. See
+  ff05274becc9e6e1295ed60f3ea090d31d843379.
+
+## 0.5.0
+
+* Node 0.8 is no longer supported.
+
+* Use webpack instead of dryice for bundling.
+
+* Big speedups serializing source maps. See pull request #203.
+
+* Fix a bug with `SourceMapConsumer.prototype.sourceContentFor` and sources that
+  explicitly start with the source root. See issue #199.
+
+## 0.4.4
+
+* Fix an issue where using a `SourceMapGenerator` after having created a
+  `SourceMapConsumer` from it via `SourceMapConsumer.fromSourceMap` failed. See
+  issue #191.
+
+* Fix an issue with where `SourceMapGenerator` would mistakenly consider
+  different mappings as duplicates of each other and avoid generating them. See
+  issue #192.
+
+## 0.4.3
+
+* A very large number of performance improvements, particularly when parsing
+  source maps. Collectively about 75% of time shaved off of the source map
+  parsing benchmark!
+
+* Fix a bug in `SourceMapConsumer.prototype.allGeneratedPositionsFor` and fuzzy
+  searching in the presence of a column option. See issue #177.
+
+* Fix a bug with joining a source and its source root when the source is above
+  the root. See issue #182.
+
+* Add the `SourceMapConsumer.prototype.hasContentsOfAllSources` method to
+  determine when all sources' contents are inlined into the source map. See
+  issue #190.
+
+## 0.4.2
+
+* Add an `.npmignore` file so that the benchmarks aren't pulled down by
+  dependent projects. Issue #169.
+
+* Add an optional `column` argument to
+  `SourceMapConsumer.prototype.allGeneratedPositionsFor` and better handle lines
+  with no mappings. Issues #172 and #173.
+
+## 0.4.1
+
+* Fix accidentally defining a global variable. #170.
+
+## 0.4.0
+
+* The default direction for fuzzy searching was changed back to its original
+  direction. See #164.
+
+* There is now a `bias` option you can supply to `SourceMapConsumer` to control
+  the fuzzy searching direction. See #167.
+
+* About an 8% speed up in parsing source maps. See #159.
+
+* Added a benchmark for parsing and generating source maps.
+
+## 0.3.0
+
+* Change the default direction that searching for positions fuzzes when there is
+  not an exact match. See #154.
+
+* Support for environments using json2.js for JSON serialization. See #156.
+
+## 0.2.0
+
+* Support for consuming "indexed" source maps which do not have any remote
+  sections. See pull request #127. This introduces a minor backwards
+  incompatibility if you are monkey patching `SourceMapConsumer.prototype`
+  methods.
+
+## 0.1.43
+
+* Performance improvements for `SourceMapGenerator` and `SourceNode`. See issue
+  #148 for some discussion and issues #150, #151, and #152 for implementations.
+
+## 0.1.42
+
+* Fix an issue where `SourceNode`s from different versions of the source-map
+  library couldn't be used in conjunction with each other. See issue #142.
+
+## 0.1.41
+
+* Fix a bug with getting the source content of relative sources with a "./"
+  prefix. See issue #145 and [Bug 1090768](bugzil.la/1090768).
+
+* Add the `SourceMapConsumer.prototype.computeColumnSpans` method to compute the
+  column span of each mapping.
+
+* Add the `SourceMapConsumer.prototype.allGeneratedPositionsFor` method to find
+  all generated positions associated with a given original source and line.
+
+## 0.1.40
+
+* Performance improvements for parsing source maps in SourceMapConsumer.
+
+## 0.1.39
+
+* Fix a bug where setting a source's contents to null before any source content
+  had been set before threw a TypeError. See issue #131.
+
+## 0.1.38
+
+* Fix a bug where finding relative paths from an empty path were creating
+  absolute paths. See issue #129.
+
+## 0.1.37
+
+* Fix a bug where if the source root was an empty string, relative source paths
+  would turn into absolute source paths. Issue #124.
+
+## 0.1.36
+
+* Allow the `names` mapping property to be an empty string. Issue #121.
+
+## 0.1.35
+
+* A third optional parameter was added to `SourceNode.fromStringWithSourceMap`
+  to specify a path that relative sources in the second parameter should be
+  relative to. Issue #105.
+
+* If no file property is given to a `SourceMapGenerator`, then the resulting
+  source map will no longer have a `null` file property. The property will
+  simply not exist. Issue #104.
+
+* Fixed a bug where consecutive newlines were ignored in `SourceNode`s.
+  Issue #116.
+
+## 0.1.34
+
+* Make `SourceNode` work with windows style ("\r\n") newlines. Issue #103.
+
+* Fix bug involving source contents and the
+  `SourceMapGenerator.prototype.applySourceMap`. Issue #100.
+
+## 0.1.33
+
+* Fix some edge cases surrounding path joining and URL resolution.
+
+* Add a third parameter for relative path to
+  `SourceMapGenerator.prototype.applySourceMap`.
+
+* Fix issues with mappings and EOLs.
+
+## 0.1.32
+
+* Fixed a bug where SourceMapConsumer couldn't handle negative relative columns
+  (issue 92).
+
+* Fixed test runner to actually report number of failed tests as its process
+  exit code.
+
+* Fixed a typo when reporting bad mappings (issue 87).
+
+## 0.1.31
+
+* Delay parsing the mappings in SourceMapConsumer until queried for a source
+  location.
+
+* Support Sass source maps (which at the time of writing deviate from the spec
+  in small ways) in SourceMapConsumer.
+
+## 0.1.30
+
+* Do not join source root with a source, when the source is a data URI.
+
+* Extend the test runner to allow running single specific test files at a time.
+
+* Performance improvements in `SourceNode.prototype.walk` and
+  `SourceMapConsumer.prototype.eachMapping`.
+
+* Source map browser builds will now work inside Workers.
+
+* Better error messages when attempting to add an invalid mapping to a
+  `SourceMapGenerator`.
+
+## 0.1.29
+
+* Allow duplicate entries in the `names` and `sources` arrays of source maps
+  (usually from TypeScript) we are parsing. Fixes github issue 72.
+
+## 0.1.28
+
+* Skip duplicate mappings when creating source maps from SourceNode; github
+  issue 75.
+
+## 0.1.27
+
+* Don't throw an error when the `file` property is missing in SourceMapConsumer,
+  we don't use it anyway.
+
+## 0.1.26
+
+* Fix SourceNode.fromStringWithSourceMap for empty maps. Fixes github issue 70.
+
+## 0.1.25
+
+* Make compatible with browserify
+
+## 0.1.24
+
+* Fix issue with absolute paths and `file://` URIs. See
+  https://bugzilla.mozilla.org/show_bug.cgi?id=885597
+
+## 0.1.23
+
+* Fix issue with absolute paths and sourcesContent, github issue 64.
+
+## 0.1.22
+
+* Ignore duplicate mappings in SourceMapGenerator. Fixes github issue 21.
+
+## 0.1.21
+
+* Fixed handling of sources that start with a slash so that they are relative to
+  the source root's host.
+
+## 0.1.20
+
+* Fixed github issue #43: absolute URLs aren't joined with the source root
+  anymore.
+
+## 0.1.19
+
+* Using Travis CI to run tests.
+
+## 0.1.18
+
+* Fixed a bug in the handling of sourceRoot.
+
+## 0.1.17
+
+* Added SourceNode.fromStringWithSourceMap.
+
+## 0.1.16
+
+* Added missing documentation.
+
+* Fixed the generating of empty mappings in SourceNode.
+
+## 0.1.15
+
+* Added SourceMapGenerator.applySourceMap.
+
+## 0.1.14
+
+* The sourceRoot is now handled consistently.
+
+## 0.1.13
+
+* Added SourceMapGenerator.fromSourceMap.
+
+## 0.1.12
+
+* SourceNode now generates empty mappings too.
+
+## 0.1.11
+
+* Added name support to SourceNode.
+
+## 0.1.10
+
+* Added sourcesContent support to the customer and generator.
diff --git a/node_modules/@babel/generator/node_modules/source-map/LICENSE b/node_modules/@babel/generator/node_modules/source-map/LICENSE
new file mode 100644
index 00000000..ed1b7cf2
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/source-map/LICENSE
@@ -0,0 +1,28 @@
+
+Copyright (c) 2009-2011, Mozilla Foundation and contributors
+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 names of the Mozilla Foundation nor the names of project
+  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 HOLDER 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.
diff --git a/node_modules/@babel/generator/node_modules/source-map/README.md b/node_modules/@babel/generator/node_modules/source-map/README.md
new file mode 100644
index 00000000..32813394
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/source-map/README.md
@@ -0,0 +1,729 @@
+# Source Map
+
+[![Build Status](https://travis-ci.org/mozilla/source-map.png?branch=master)](https://travis-ci.org/mozilla/source-map)
+
+[![NPM](https://nodei.co/npm/source-map.png?downloads=true&downloadRank=true)](https://www.npmjs.com/package/source-map)
+
+This is a library to generate and consume the source map format
+[described here][format].
+
+[format]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit
+
+## Use with Node
+
+    $ npm install source-map
+
+## Use on the Web
+
+    <script src="https://raw.githubusercontent.com/mozilla/source-map/master/dist/source-map.min.js" defer></script>
+
+--------------------------------------------------------------------------------
+
+<!-- `npm run toc` to regenerate the Table of Contents -->
+
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+## Table of Contents
+
+- [Examples](#examples)
+  - [Consuming a source map](#consuming-a-source-map)
+  - [Generating a source map](#generating-a-source-map)
+    - [With SourceNode (high level API)](#with-sourcenode-high-level-api)
+    - [With SourceMapGenerator (low level API)](#with-sourcemapgenerator-low-level-api)
+- [API](#api)
+  - [SourceMapConsumer](#sourcemapconsumer)
+    - [new SourceMapConsumer(rawSourceMap)](#new-sourcemapconsumerrawsourcemap)
+    - [SourceMapConsumer.prototype.computeColumnSpans()](#sourcemapconsumerprototypecomputecolumnspans)
+    - [SourceMapConsumer.prototype.originalPositionFor(generatedPosition)](#sourcemapconsumerprototypeoriginalpositionforgeneratedposition)
+    - [SourceMapConsumer.prototype.generatedPositionFor(originalPosition)](#sourcemapconsumerprototypegeneratedpositionfororiginalposition)
+    - [SourceMapConsumer.prototype.allGeneratedPositionsFor(originalPosition)](#sourcemapconsumerprototypeallgeneratedpositionsfororiginalposition)
+    - [SourceMapConsumer.prototype.hasContentsOfAllSources()](#sourcemapconsumerprototypehascontentsofallsources)
+    - [SourceMapConsumer.prototype.sourceContentFor(source[, returnNullOnMissing])](#sourcemapconsumerprototypesourcecontentforsource-returnnullonmissing)
+    - [SourceMapConsumer.prototype.eachMapping(callback, context, order)](#sourcemapconsumerprototypeeachmappingcallback-context-order)
+  - [SourceMapGenerator](#sourcemapgenerator)
+    - [new SourceMapGenerator([startOfSourceMap])](#new-sourcemapgeneratorstartofsourcemap)
+    - [SourceMapGenerator.fromSourceMap(sourceMapConsumer)](#sourcemapgeneratorfromsourcemapsourcemapconsumer)
+    - [SourceMapGenerator.prototype.addMapping(mapping)](#sourcemapgeneratorprototypeaddmappingmapping)
+    - [SourceMapGenerator.prototype.setSourceContent(sourceFile, sourceContent)](#sourcemapgeneratorprototypesetsourcecontentsourcefile-sourcecontent)
+    - [SourceMapGenerator.prototype.applySourceMap(sourceMapConsumer[, sourceFile[, sourceMapPath]])](#sourcemapgeneratorprototypeapplysourcemapsourcemapconsumer-sourcefile-sourcemappath)
+    - [SourceMapGenerator.prototype.toString()](#sourcemapgeneratorprototypetostring)
+  - [SourceNode](#sourcenode)
+    - [new SourceNode([line, column, source[, chunk[, name]]])](#new-sourcenodeline-column-source-chunk-name)
+    - [SourceNode.fromStringWithSourceMap(code, sourceMapConsumer[, relativePath])](#sourcenodefromstringwithsourcemapcode-sourcemapconsumer-relativepath)
+    - [SourceNode.prototype.add(chunk)](#sourcenodeprototypeaddchunk)
+    - [SourceNode.prototype.prepend(chunk)](#sourcenodeprototypeprependchunk)
+    - [SourceNode.prototype.setSourceContent(sourceFile, sourceContent)](#sourcenodeprototypesetsourcecontentsourcefile-sourcecontent)
+    - [SourceNode.prototype.walk(fn)](#sourcenodeprototypewalkfn)
+    - [SourceNode.prototype.walkSourceContents(fn)](#sourcenodeprototypewalksourcecontentsfn)
+    - [SourceNode.prototype.join(sep)](#sourcenodeprototypejoinsep)
+    - [SourceNode.prototype.replaceRight(pattern, replacement)](#sourcenodeprototypereplacerightpattern-replacement)
+    - [SourceNode.prototype.toString()](#sourcenodeprototypetostring)
+    - [SourceNode.prototype.toStringWithSourceMap([startOfSourceMap])](#sourcenodeprototypetostringwithsourcemapstartofsourcemap)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+
+## Examples
+
+### Consuming a source map
+
+```js
+var rawSourceMap = {
+  version: 3,
+  file: 'min.js',
+  names: ['bar', 'baz', 'n'],
+  sources: ['one.js', 'two.js'],
+  sourceRoot: 'http://example.com/www/js/',
+  mappings: 'CAAC,IAAI,IAAM,SAAUA,GAClB,OAAOC,IAAID;CCDb,IAAI,IAAM,SAAUE,GAClB,OAAOA'
+};
+
+var smc = new SourceMapConsumer(rawSourceMap);
+
+console.log(smc.sources);
+// [ 'http://example.com/www/js/one.js',
+//   'http://example.com/www/js/two.js' ]
+
+console.log(smc.originalPositionFor({
+  line: 2,
+  column: 28
+}));
+// { source: 'http://example.com/www/js/two.js',
+//   line: 2,
+//   column: 10,
+//   name: 'n' }
+
+console.log(smc.generatedPositionFor({
+  source: 'http://example.com/www/js/two.js',
+  line: 2,
+  column: 10
+}));
+// { line: 2, column: 28 }
+
+smc.eachMapping(function (m) {
+  // ...
+});
+```
+
+### Generating a source map
+
+In depth guide:
+[**Compiling to JavaScript, and Debugging with Source Maps**](https://hacks.mozilla.org/2013/05/compiling-to-javascript-and-debugging-with-source-maps/)
+
+#### With SourceNode (high level API)
+
+```js
+function compile(ast) {
+  switch (ast.type) {
+  case 'BinaryExpression':
+    return new SourceNode(
+      ast.location.line,
+      ast.location.column,
+      ast.location.source,
+      [compile(ast.left), " + ", compile(ast.right)]
+    );
+  case 'Literal':
+    return new SourceNode(
+      ast.location.line,
+      ast.location.column,
+      ast.location.source,
+      String(ast.value)
+    );
+  // ...
+  default:
+    throw new Error("Bad AST");
+  }
+}
+
+var ast = parse("40 + 2", "add.js");
+console.log(compile(ast).toStringWithSourceMap({
+  file: 'add.js'
+}));
+// { code: '40 + 2',
+//   map: [object SourceMapGenerator] }
+```
+
+#### With SourceMapGenerator (low level API)
+
+```js
+var map = new SourceMapGenerator({
+  file: "source-mapped.js"
+});
+
+map.addMapping({
+  generated: {
+    line: 10,
+    column: 35
+  },
+  source: "foo.js",
+  original: {
+    line: 33,
+    column: 2
+  },
+  name: "christopher"
+});
+
+console.log(map.toString());
+// '{"version":3,"file":"source-mapped.js","sources":["foo.js"],"names":["christopher"],"mappings":";;;;;;;;;mCAgCEA"}'
+```
+
+## API
+
+Get a reference to the module:
+
+```js
+// Node.js
+var sourceMap = require('source-map');
+
+// Browser builds
+var sourceMap = window.sourceMap;
+
+// Inside Firefox
+const sourceMap = require("devtools/toolkit/sourcemap/source-map.js");
+```
+
+### SourceMapConsumer
+
+A SourceMapConsumer 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.
+
+#### new SourceMapConsumer(rawSourceMap)
+
+The only parameter is the raw source map (either as a string which can be
+`JSON.parse`'d, or 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 referenced 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 filename this source map is associated with.
+
+```js
+var consumer = new sourceMap.SourceMapConsumer(rawSourceMapJsonData);
+```
+
+#### SourceMapConsumer.prototype.computeColumnSpans()
+
+Compute the last column for each generated mapping. The last column is
+inclusive.
+
+```js
+// Before:
+consumer.allGeneratedPositionsFor({ line: 2, source: "foo.coffee" })
+// [ { line: 2,
+//     column: 1 },
+//   { line: 2,
+//     column: 10 },
+//   { line: 2,
+//     column: 20 } ]
+
+consumer.computeColumnSpans();
+
+// After:
+consumer.allGeneratedPositionsFor({ line: 2, source: "foo.coffee" })
+// [ { line: 2,
+//     column: 1,
+//     lastColumn: 9 },
+//   { line: 2,
+//     column: 10,
+//     lastColumn: 19 },
+//   { line: 2,
+//     column: 20,
+//     lastColumn: Infinity } ]
+
+```
+
+#### SourceMapConsumer.prototype.originalPositionFor(generatedPosition)
+
+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 if this information is not
+  available.
+
+* `line`: The line number in the original source, or null if this information is
+  not available.
+
+* `column`: The column number in the original source, or null if this
+  information is not available.
+
+* `name`: The original identifier, or null if this information is not available.
+
+```js
+consumer.originalPositionFor({ line: 2, column: 10 })
+// { source: 'foo.coffee',
+//   line: 2,
+//   column: 2,
+//   name: null }
+
+consumer.originalPositionFor({ line: 99999999999999999, column: 999999999999999 })
+// { source: null,
+//   line: null,
+//   column: null,
+//   name: null }
+```
+
+#### SourceMapConsumer.prototype.generatedPositionFor(originalPosition)
+
+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.
+
+```js
+consumer.generatedPositionFor({ source: "example.js", line: 2, column: 10 })
+// { line: 1,
+//   column: 56 }
+```
+
+#### SourceMapConsumer.prototype.allGeneratedPositionsFor(originalPosition)
+
+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.
+
+```js
+consumer.allGeneratedpositionsfor({ line: 2, source: "foo.coffee" })
+// [ { line: 2,
+//     column: 1 },
+//   { line: 2,
+//     column: 10 },
+//   { line: 2,
+//     column: 20 } ]
+```
+
+#### SourceMapConsumer.prototype.hasContentsOfAllSources()
+
+Return true if we have the embedded source content for every source listed in
+the source map, false otherwise.
+
+In other words, if this method returns `true`, then
+`consumer.sourceContentFor(s)` will succeed for every source `s` in
+`consumer.sources`.
+
+```js
+// ...
+if (consumer.hasContentsOfAllSources()) {
+  consumerReadyCallback(consumer);
+} else {
+  fetchSources(consumer, consumerReadyCallback);
+}
+// ...
+```
+
+#### SourceMapConsumer.prototype.sourceContentFor(source[, returnNullOnMissing])
+
+Returns the original source content for the source provided. The only
+argument is the URL of the original source file.
+
+If the source content for the given source is not found, then an error is
+thrown. Optionally, pass `true` as the second param to have `null` returned
+instead.
+
+```js
+consumer.sources
+// [ "my-cool-lib.clj" ]
+
+consumer.sourceContentFor("my-cool-lib.clj")
+// "..."
+
+consumer.sourceContentFor("this is not in the source map");
+// Error: "this is not in the source map" is not in the source map
+
+consumer.sourceContentFor("this is not in the source map", true);
+// null
+```
+
+#### SourceMapConsumer.prototype.eachMapping(callback, context, order)
+
+Iterate over each mapping between an original source/line/column and a
+generated line/column in this source map.
+
+* `callback`: The function that is called with each mapping. Mappings have the
+  form `{ source, generatedLine, generatedColumn, originalLine, originalColumn,
+  name }`
+
+* `context`: Optional. If specified, this object will be the value of `this`
+  every time that `callback` is called.
+
+* `order`: 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`.
+
+```js
+consumer.eachMapping(function (m) { console.log(m); })
+// ...
+// { source: 'illmatic.js',
+//   generatedLine: 1,
+//   generatedColumn: 0,
+//   originalLine: 1,
+//   originalColumn: 0,
+//   name: null }
+// { source: 'illmatic.js',
+//   generatedLine: 2,
+//   generatedColumn: 0,
+//   originalLine: 2,
+//   originalColumn: 0,
+//   name: null }
+// ...
+```
+### SourceMapGenerator
+
+An instance of the SourceMapGenerator represents a source map which is being
+built incrementally.
+
+#### new SourceMapGenerator([startOfSourceMap])
+
+You may pass an object with the following properties:
+
+* `file`: The filename of the generated source that this source map is
+  associated with.
+
+* `sourceRoot`: A root for all relative URLs in this source map.
+
+* `skipValidation`: Optional. When `true`, disables validation of mappings as
+  they are added. This can improve performance but should be used with
+  discretion, as a last resort. Even then, one should avoid using this flag when
+  running tests, if possible.
+
+```js
+var generator = new sourceMap.SourceMapGenerator({
+  file: "my-generated-javascript-file.js",
+  sourceRoot: "http://example.com/app/js/"
+});
+```
+
+#### SourceMapGenerator.fromSourceMap(sourceMapConsumer)
+
+Creates a new `SourceMapGenerator` from an existing `SourceMapConsumer` instance.
+
+* `sourceMapConsumer` The SourceMap.
+
+```js
+var generator = sourceMap.SourceMapGenerator.fromSourceMap(consumer);
+```
+
+#### SourceMapGenerator.prototype.addMapping(mapping)
+
+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.
+
+```js
+generator.addMapping({
+  source: "module-one.scm",
+  original: { line: 128, column: 0 },
+  generated: { line: 3, column: 456 }
+})
+```
+
+#### SourceMapGenerator.prototype.setSourceContent(sourceFile, sourceContent)
+
+Set the source content for an original source file.
+
+* `sourceFile` the URL of the original source file.
+
+* `sourceContent` the content of the source file.
+
+```js
+generator.setSourceContent("module-one.scm",
+                           fs.readFileSync("path/to/module-one.scm"))
+```
+
+#### SourceMapGenerator.prototype.applySourceMap(sourceMapConsumer[, sourceFile[, sourceMapPath]])
+
+Applies a SourceMap for a source file to the SourceMap.
+Each mapping to the supplied source file is rewritten using the
+supplied SourceMap. Note: The resolution for the resulting mappings
+is the minimum of this map and the supplied map.
+
+* `sourceMapConsumer`: The SourceMap to be applied.
+
+* `sourceFile`: Optional. The filename of the source file.
+  If omitted, sourceMapConsumer.file will be used, if it exists.
+  Otherwise an error will be thrown.
+
+* `sourceMapPath`: Optional. The dirname of the path to the SourceMap
+  to be applied. If relative, it is relative to the SourceMap.
+
+  This parameter is needed when the two SourceMaps aren't in the same
+  directory, and the SourceMap to be applied contains relative source
+  paths. If so, those relative source paths need to be rewritten
+  relative to the SourceMap.
+
+  If omitted, it is assumed that both SourceMaps are in the same directory,
+  thus not needing any rewriting. (Supplying `'.'` has the same effect.)
+
+#### SourceMapGenerator.prototype.toString()
+
+Renders the source map being generated to a string.
+
+```js
+generator.toString()
+// '{"version":3,"sources":["module-one.scm"],"names":[],"mappings":"...snip...","file":"my-generated-javascript-file.js","sourceRoot":"http://example.com/app/js/"}'
+```
+
+### SourceNode
+
+SourceNodes provide a way to abstract over interpolating and/or concatenating
+snippets of generated JavaScript source code, while maintaining the line and
+column information associated between those snippets and the original source
+code. This is useful as the final intermediate representation a compiler might
+use before outputting the generated JS and source map.
+
+#### new SourceNode([line, column, source[, chunk[, name]]])
+
+* `line`: The original line number associated with this source node, or null if
+  it isn't associated with an original line.
+
+* `column`: The original column number associated with this source node, or null
+  if it isn't associated with an original column.
+
+* `source`: The original source's filename; null if no filename is provided.
+
+* `chunk`: Optional. Is immediately passed to `SourceNode.prototype.add`, see
+  below.
+
+* `name`: Optional. The original identifier.
+
+```js
+var node = new SourceNode(1, 2, "a.cpp", [
+  new SourceNode(3, 4, "b.cpp", "extern int status;\n"),
+  new SourceNode(5, 6, "c.cpp", "std::string* make_string(size_t n);\n"),
+  new SourceNode(7, 8, "d.cpp", "int main(int argc, char** argv) {}\n"),
+]);
+```
+
+#### SourceNode.fromStringWithSourceMap(code, sourceMapConsumer[, relativePath])
+
+Creates a SourceNode from generated code and a SourceMapConsumer.
+
+* `code`: The generated code
+
+* `sourceMapConsumer` The SourceMap for the generated code
+
+* `relativePath` The optional path that relative sources in `sourceMapConsumer`
+  should be relative to.
+
+```js
+var consumer = new SourceMapConsumer(fs.readFileSync("path/to/my-file.js.map", "utf8"));
+var node = SourceNode.fromStringWithSourceMap(fs.readFileSync("path/to/my-file.js"),
+                                              consumer);
+```
+
+#### SourceNode.prototype.add(chunk)
+
+Add a chunk of generated JS to this source node.
+
+* `chunk`: A string snippet of generated JS code, another instance of
+   `SourceNode`, or an array where each member is one of those things.
+
+```js
+node.add(" + ");
+node.add(otherNode);
+node.add([leftHandOperandNode, " + ", rightHandOperandNode]);
+```
+
+#### SourceNode.prototype.prepend(chunk)
+
+Prepend a chunk of generated JS to this source node.
+
+* `chunk`: A string snippet of generated JS code, another instance of
+   `SourceNode`, or an array where each member is one of those things.
+
+```js
+node.prepend("/** Build Id: f783haef86324gf **/\n\n");
+```
+
+#### SourceNode.prototype.setSourceContent(sourceFile, sourceContent)
+
+Set the source content for a source file. This will be added to the
+`SourceMap` in the `sourcesContent` field.
+
+* `sourceFile`: The filename of the source file
+
+* `sourceContent`: The content of the source file
+
+```js
+node.setSourceContent("module-one.scm",
+                      fs.readFileSync("path/to/module-one.scm"))
+```
+
+#### SourceNode.prototype.walk(fn)
+
+Walk over the tree of JS snippets in this node and its children. The walking
+function is called once for each snippet of JS and is passed that snippet and
+the its original associated source's line/column location.
+
+* `fn`: The traversal function.
+
+```js
+var node = new SourceNode(1, 2, "a.js", [
+  new SourceNode(3, 4, "b.js", "uno"),
+  "dos",
+  [
+    "tres",
+    new SourceNode(5, 6, "c.js", "quatro")
+  ]
+]);
+
+node.walk(function (code, loc) { console.log("WALK:", code, loc); })
+// WALK: uno { source: 'b.js', line: 3, column: 4, name: null }
+// WALK: dos { source: 'a.js', line: 1, column: 2, name: null }
+// WALK: tres { source: 'a.js', line: 1, column: 2, name: null }
+// WALK: quatro { source: 'c.js', line: 5, column: 6, name: null }
+```
+
+#### SourceNode.prototype.walkSourceContents(fn)
+
+Walk over the tree of SourceNodes. The walking function is called for each
+source file content and is passed the filename and source content.
+
+* `fn`: The traversal function.
+
+```js
+var a = new SourceNode(1, 2, "a.js", "generated from a");
+a.setSourceContent("a.js", "original a");
+var b = new SourceNode(1, 2, "b.js", "generated from b");
+b.setSourceContent("b.js", "original b");
+var c = new SourceNode(1, 2, "c.js", "generated from c");
+c.setSourceContent("c.js", "original c");
+
+var node = new SourceNode(null, null, null, [a, b, c]);
+node.walkSourceContents(function (source, contents) { console.log("WALK:", source, ":", contents); })
+// WALK: a.js : original a
+// WALK: b.js : original b
+// WALK: c.js : original c
+```
+
+#### SourceNode.prototype.join(sep)
+
+Like `Array.prototype.join` except for SourceNodes. Inserts the separator
+between each of this source node's children.
+
+* `sep`: The separator.
+
+```js
+var lhs = new SourceNode(1, 2, "a.rs", "my_copy");
+var operand = new SourceNode(3, 4, "a.rs", "=");
+var rhs = new SourceNode(5, 6, "a.rs", "orig.clone()");
+
+var node = new SourceNode(null, null, null, [ lhs, operand, rhs ]);
+var joinedNode = node.join(" ");
+```
+
+#### SourceNode.prototype.replaceRight(pattern, replacement)
+
+Call `String.prototype.replace` on the very right-most source snippet. Useful
+for trimming white space from the end of a source node, etc.
+
+* `pattern`: The pattern to replace.
+
+* `replacement`: The thing to replace the pattern with.
+
+```js
+// Trim trailing white space.
+node.replaceRight(/\s*$/, "");
+```
+
+#### SourceNode.prototype.toString()
+
+Return the string representation of this source node. Walks over the tree and
+concatenates all the various snippets together to one string.
+
+```js
+var node = new SourceNode(1, 2, "a.js", [
+  new SourceNode(3, 4, "b.js", "uno"),
+  "dos",
+  [
+    "tres",
+    new SourceNode(5, 6, "c.js", "quatro")
+  ]
+]);
+
+node.toString()
+// 'unodostresquatro'
+```
+
+#### SourceNode.prototype.toStringWithSourceMap([startOfSourceMap])
+
+Returns the string representation of this tree of source nodes, plus a
+SourceMapGenerator which contains all the mappings between the generated and
+original sources.
+
+The arguments are the same as those to `new SourceMapGenerator`.
+
+```js
+var node = new SourceNode(1, 2, "a.js", [
+  new SourceNode(3, 4, "b.js", "uno"),
+  "dos",
+  [
+    "tres",
+    new SourceNode(5, 6, "c.js", "quatro")
+  ]
+]);
+
+node.toStringWithSourceMap({ file: "my-output-file.js" })
+// { code: 'unodostresquatro',
+//   map: [object SourceMapGenerator] }
+```
diff --git a/node_modules/@babel/generator/node_modules/source-map/dist/source-map.debug.js b/node_modules/@babel/generator/node_modules/source-map/dist/source-map.debug.js
new file mode 100644
index 00000000..b5ab6382
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/source-map/dist/source-map.debug.js
@@ -0,0 +1,3091 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], 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) {
+	    // When aOriginal is truthy but has empty values for .line and .column,
+	    // it is most likely a programmer error. In this case we throw a very
+	    // specific error message to try to guide them the right way.
+	    // For example: https://github.com/Polymer/polymer-bundler/pull/519
+	    if (aOriginal && typeof aOriginal.line !== 'number' && typeof aOriginal.column !== 'number') {
+	        throw new Error(
+	            'original.line and original.column are not numbers -- you probably meant to omit ' +
+	            'the original mapping entirely and only map the generated position. If so, pass ' +
+	            'null for the original mapping instead of an object with empty or null values.'
+	        );
+	    }
+	
+	    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 consecutive 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;
+	var hasNativeMap = typeof Map !== "undefined";
+	
+	/**
+	 * 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 = hasNativeMap ? new Map() : 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 hasNativeMap ? this._set.size : 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 = hasNativeMap ? aStr : util.toSetString(aStr);
+	  var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
+	  var idx = this._array.length;
+	  if (!isDuplicate || aAllowDuplicates) {
+	    this._array.push(aStr);
+	  }
+	  if (!isDuplicate) {
+	    if (hasNativeMap) {
+	      this._set.set(aStr, idx);
+	    } else {
+	      this._set[sStr] = idx;
+	    }
+	  }
+	};
+	
+	/**
+	 * Is the given string a member of this set?
+	 *
+	 * @param String aStr
+	 */
+	ArraySet.prototype.has = function ArraySet_has(aStr) {
+	  if (hasNativeMap) {
+	    return this._set.has(aStr);
+	  } else {
+	    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) {
+	  if (hasNativeMap) {
+	    var idx = this._set.get(aStr);
+	    if (idx >= 0) {
+	        return idx;
+	    }
+	  } else {
+	    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 accessed by calling `shiftNextLine`.
+	    var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
+	    var remainingLinesIndex = 0;
+	    var shiftNextLine = function() {
+	      var lineContents = getNextLine();
+	      // The last line of a file might not have a newline.
+	      var newLine = getNextLine() || "";
+	      return lineContents + newLine;
+	
+	      function getNextLine() {
+	        return remainingLinesIndex < remainingLines.length ?
+	            remainingLines[remainingLinesIndex++] : undefined;
+	      }
+	    };
+	
+	    // 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[remainingLinesIndex];
+	          var code = nextLine.substr(0, mapping.generatedColumn -
+	                                        lastGeneratedColumn);
+	          remainingLines[remainingLinesIndex] = 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[remainingLinesIndex];
+	        node.add(nextLine.substr(0, mapping.generatedColumn));
+	        remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
+	        lastGeneratedColumn = mapping.generatedColumn;
+	      }
+	      lastMapping = mapping;
+	    }, this);
+	    // We have processed all mappings.
+	    if (remainingLinesIndex < remainingLines.length) {
+	      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.splice(remainingLinesIndex).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) {
+	        node.add(code);
+	      } else {
+	        var source = aRelativePath
+	          ? util.join(aRelativePath, mapping.source)
+	          : mapping.source;
+	        node.add(new SourceNode(mapping.originalLine,
+	                                mapping.originalColumn,
+	                                source,
+	                                code,
+	                                mapping.name));
+	      }
+	    }
+	  };
+	
+	/**
+	 * Add a chunk of generated JS to this source node.
+	 *
+	 * @param aChunk A string snippet of generated JS code, another instance of
+	 *        SourceNode, or an array where each member is one of those things.
+	 */
+	SourceNode.prototype.add = function SourceNode_add(aChunk) {
+	  if (Array.isArray(aChunk)) {
+	    aChunk.forEach(function (chunk) {
+	      this.add(chunk);
+	    }, this);
+	  }
+	  else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+	    if (aChunk) {
+	      this.children.push(aChunk);
+	    }
+	  }
+	  else {
+	    throw new TypeError(
+	      "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+	    );
+	  }
+	  return this;
+	};
+	
+	/**
+	 * Add a chunk of generated JS to the beginning of this source node.
+	 *
+	 * @param aChunk A string snippet of generated JS code, another instance of
+	 *        SourceNode, or an array where each member is one of those things.
+	 */
+	SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
+	  if (Array.isArray(aChunk)) {
+	    for (var i = aChunk.length-1; i >= 0; i--) {
+	      this.prepend(aChunk[i]);
+	    }
+	  }
+	  else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+	    this.children.unshift(aChunk);
+	  }
+	  else {
+	    throw new TypeError(
+	      "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+	    );
+	  }
+	  return this;
+	};
+	
+	/**
+	 * Walk over the tree of JS snippets in this node and its children. The
+	 * walking function is called once for each snippet of JS and is passed that
+	 * snippet and the its original associated source's line/column location.
+	 *
+	 * @param aFn The traversal function.
+	 */
+	SourceNode.prototype.walk = function SourceNode_walk(aFn) {
+	  var chunk;
+	  for (var i = 0, len = this.children.length; i < len; i++) {
+	    chunk = this.children[i];
+	    if (chunk[isSourceNode]) {
+	      chunk.walk(aFn);
+	    }
+	    else {
+	      if (chunk !== '') {
+	        aFn(chunk, { source: this.source,
+	                     line: this.line,
+	                     column: this.column,
+	                     name: this.name });
+	      }
+	    }
+	  }
+	};
+	
+	/**
+	 * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
+	 * each of `this.children`.
+	 *
+	 * @param aSep The separator.
+	 */
+	SourceNode.prototype.join = function SourceNode_join(aSep) {
+	  var newChildren;
+	  var i;
+	  var len = this.children.length;
+	  if (len > 0) {
+	    newChildren = [];
+	    for (i = 0; i < len-1; i++) {
+	      newChildren.push(this.children[i]);
+	      newChildren.push(aSep);
+	    }
+	    newChildren.push(this.children[i]);
+	    this.children = newChildren;
+	  }
+	  return this;
+	};
+	
+	/**
+	 * Call String.prototype.replace on the very right-most source snippet. Useful
+	 * for trimming whitespace from the end of a source node, etc.
+	 *
+	 * @param aPattern The pattern to replace.
+	 * @param aReplacement The thing to replace the pattern with.
+	 */
+	SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
+	  var lastChild = this.children[this.children.length - 1];
+	  if (lastChild[isSourceNode]) {
+	    lastChild.replaceRight(aPattern, aReplacement);
+	  }
+	  else if (typeof lastChild === 'string') {
+	    this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
+	  }
+	  else {
+	    this.children.push(''.replace(aPattern, aReplacement));
+	  }
+	  return this;
+	};
+	
+	/**
+	 * Set the source content for a source file. This will be added to the SourceMapGenerator
+	 * in the sourcesContent field.
+	 *
+	 * @param aSourceFile The filename of the source file
+	 * @param aSourceContent The content of the source file
+	 */
+	SourceNode.prototype.setSourceContent =
+	  function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
+	    this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
+	  };
+	
+	/**
+	 * Walk over the tree of SourceNodes. The walking function is called for each
+	 * source file content and is passed the filename and source content.
+	 *
+	 * @param aFn The traversal function.
+	 */
+	SourceNode.prototype.walkSourceContents =
+	  function SourceNode_walkSourceContents(aFn) {
+	    for (var i = 0, len = this.children.length; i < len; i++) {
+	      if (this.children[i][isSourceNode]) {
+	        this.children[i].walkSourceContents(aFn);
+	      }
+	    }
+	
+	    var sources = Object.keys(this.sourceContents);
+	    for (var i = 0, len = sources.length; i < len; i++) {
+	      aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
+	    }
+	  };
+	
+	/**
+	 * Return the string representation of this source node. Walks over the tree
+	 * and concatenates all the various snippets together to one string.
+	 */
+	SourceNode.prototype.toString = function SourceNode_toString() {
+	  var str = "";
+	  this.walk(function (chunk) {
+	    str += chunk;
+	  });
+	  return str;
+	};
+	
+	/**
+	 * Returns the string representation of this source node along with a source
+	 * map.
+	 */
+	SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
+	  var generated = {
+	    code: "",
+	    line: 1,
+	    column: 0
+	  };
+	  var map = new SourceMapGenerator(aArgs);
+	  var sourceMappingActive = false;
+	  var lastOriginalSource = null;
+	  var lastOriginalLine = null;
+	  var lastOriginalColumn = null;
+	  var lastOriginalName = null;
+	  this.walk(function (chunk, original) {
+	    generated.code += chunk;
+	    if (original.source !== null
+	        && original.line !== null
+	        && original.column !== null) {
+	      if(lastOriginalSource !== original.source
+	         || lastOriginalLine !== original.line
+	         || lastOriginalColumn !== original.column
+	         || lastOriginalName !== original.name) {
+	        map.addMapping({
+	          source: original.source,
+	          original: {
+	            line: original.line,
+	            column: original.column
+	          },
+	          generated: {
+	            line: generated.line,
+	            column: generated.column
+	          },
+	          name: original.name
+	        });
+	      }
+	      lastOriginalSource = original.source;
+	      lastOriginalLine = original.line;
+	      lastOriginalColumn = original.column;
+	      lastOriginalName = original.name;
+	      sourceMappingActive = true;
+	    } else if (sourceMappingActive) {
+	      map.addMapping({
+	        generated: {
+	          line: generated.line,
+	          column: generated.column
+	        }
+	      });
+	      lastOriginalSource = null;
+	      sourceMappingActive = false;
+	    }
+	    for (var idx = 0, length = chunk.length; idx < length; idx++) {
+	      if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
+	        generated.line++;
+	        generated.column = 0;
+	        // Mappings end at eol
+	        if (idx + 1 === length) {
+	          lastOriginalSource = null;
+	          sourceMappingActive = false;
+	        } else if (sourceMappingActive) {
+	          map.addMapping({
+	            source: original.source,
+	            original: {
+	              line: original.line,
+	              column: original.column
+	            },
+	            generated: {
+	              line: generated.line,
+	              column: generated.column
+	            },
+	            name: original.name
+	          });
+	        }
+	      } else {
+	        generated.column++;
+	      }
+	    }
+	  });
+	  this.walkSourceContents(function (sourceFile, sourceContent) {
+	    map.setSourceContent(sourceFile, sourceContent);
+	  });
+	
+	  return { code: generated.code, map: map };
+	};
+	
+	exports.SourceNode = SourceNode;
+
+
+/***/ })
+/******/ ])
+});
+;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack:///webpack/universalModuleDefinition","webpack:///webpack/bootstrap e4738fc72a7b23039889","webpack:///./source-map.js","webpack:///./lib/source-map-generator.js","webpack:///./lib/base64-vlq.js","webpack:///./lib/base64.js","webpack:///./lib/util.js","webpack:///./lib/array-set.js","webpack:///./lib/mapping-list.js","webpack:///./lib/source-map-consumer.js","webpack:///./lib/binary-search.js","webpack:///./lib/quick-sort.js","webpack:///./lib/source-node.js"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD,O;ACVA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,uBAAe;AACf;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;;;;;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACPA,iBAAgB,oBAAoB;AACpC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,MAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAO;AACP;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,2CAA0C,SAAS;AACnD;AACA;;AAEA;AACA;AACA;AACA,qBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC/ZA,iBAAgB,oBAAoB;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4DAA2D;AAC3D,qBAAoB;AACpB;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;;AAEH;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,IAAG;;AAEH;AACA;AACA;;;;;;;AC3IA,iBAAgB,oBAAoB;AACpC;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,iBAAgB;AAChB,iBAAgB;;AAEhB,oBAAmB;AACnB,qBAAoB;;AAEpB,iBAAgB;AAChB,iBAAgB;;AAEhB,iBAAgB;AAChB,kBAAiB;;AAEjB;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;;;;;;AClEA,iBAAgB,oBAAoB;AACpC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA,IAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,+CAA8C,QAAQ;AACtD;AACA;AACA;AACA,MAAK;AACL;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,QAAO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,EAAC;;AAED;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,4BAA2B,QAAQ;AACnC;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;;;;;;AChaA,iBAAgB,oBAAoB;AACpC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,uCAAsC,SAAS;AAC/C;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACxHA,iBAAgB,oBAAoB;AACpC;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAgB;AAChB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC9EA,iBAAgB,oBAAoB;AACpC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,uDAAsD;AACtD;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,EAAC;;AAED;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,EAAC;;AAED;AACA;AACA;AACA,oBAAmB;AACnB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAW;;AAEX;AACA;AACA,QAAO;AACP;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAW;;AAEX;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA2B,MAAM;AACjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uDAAsD;AACtD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,uDAAsD,YAAY;AAClE;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA,EAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,oCAAmC;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,0BAAyB,cAAc;AACvC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAuB,wCAAwC;AAC/D;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAA+C,mBAAmB,EAAE;AACpE;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAiB,oBAAoB;AACrC;AACA;AACA;AACA;AACA;AACA,8BAA6B,MAAM;AACnC;AACA,QAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uDAAsD;AACtD;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,QAAO;AACP;AACA;AACA,IAAG;AACH;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAmB,2BAA2B;AAC9C,sBAAqB,+CAA+C;AACpE;AACA;AACA;AACA;AACA;AACA,EAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,QAAO;AACP;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAmB,2BAA2B;AAC9C;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAmB,2BAA2B;AAC9C;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAmB,2BAA2B;AAC9C;AACA;AACA,sBAAqB,4BAA4B;AACjD;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;;;;;;ACzjCA,iBAAgB,oBAAoB;AACpC;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;;;;;AC9GA,iBAAgB,oBAAoB;AACpC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,YAAW,MAAM;AACjB;AACA,YAAW,OAAO;AAClB;AACA,YAAW,OAAO;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,YAAW,OAAO;AAClB;AACA,YAAW,OAAO;AAClB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,YAAW,MAAM;AACjB;AACA,YAAW,SAAS;AACpB;AACA,YAAW,OAAO;AAClB;AACA,YAAW,OAAO;AAClB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAmB,OAAO;AAC1B;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,YAAW,MAAM;AACjB;AACA,YAAW,SAAS;AACpB;AACA;AACA;AACA;AACA;;;;;;;ACjHA,iBAAgB,oBAAoB;AACpC;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;;AAEL;;AAEA;AACA;AACA;AACA,QAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAiC,QAAQ;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA6C,SAAS;AACtD;AACA;AACA;AACA;AACA;AACA;AACA,qBAAoB;AACpB;AACA;AACA,uCAAsC;AACtC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAe,WAAW;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAA+C,SAAS;AACxD;AACA;AACA;AACA;;AAEA;AACA,0CAAyC,SAAS;AAClD;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAW;AACX;AACA;AACA;AACA,YAAW;AACX;AACA,UAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA,QAAO;AACP;AACA;AACA;AACA,6CAA4C,cAAc;AAC1D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAS;AACT;AACA;AACA;AACA;AACA;AACA,cAAa;AACb;AACA;AACA;AACA,cAAa;AACb;AACA,YAAW;AACX;AACA,QAAO;AACP;AACA;AACA;AACA,IAAG;AACH;AACA;AACA,IAAG;;AAEH,WAAU;AACV;;AAEA","file":"source-map.debug.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"sourceMap\"] = factory();\n\telse\n\t\troot[\"sourceMap\"] = factory();\n})(this, function() {\nreturn \n\n\n// WEBPACK FOOTER //\n// webpack/universalModuleDefinition"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.loaded = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap e4738fc72a7b23039889","/*\n * Copyright 2009-2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE.txt or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\nexports.SourceMapGenerator = require('./lib/source-map-generator').SourceMapGenerator;\nexports.SourceMapConsumer = require('./lib/source-map-consumer').SourceMapConsumer;\nexports.SourceNode = require('./lib/source-node').SourceNode;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./source-map.js\n// module id = 0\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar base64VLQ = require('./base64-vlq');\nvar util = require('./util');\nvar ArraySet = require('./array-set').ArraySet;\nvar MappingList = require('./mapping-list').MappingList;\n\n/**\n * An instance of the SourceMapGenerator represents a source map which is\n * being built incrementally. You may pass an object with the following\n * properties:\n *\n *   - file: The filename of the generated source.\n *   - sourceRoot: A root for all relative URLs in this source map.\n */\nfunction SourceMapGenerator(aArgs) {\n  if (!aArgs) {\n    aArgs = {};\n  }\n  this._file = util.getArg(aArgs, 'file', null);\n  this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);\n  this._skipValidation = util.getArg(aArgs, 'skipValidation', false);\n  this._sources = new ArraySet();\n  this._names = new ArraySet();\n  this._mappings = new MappingList();\n  this._sourcesContents = null;\n}\n\nSourceMapGenerator.prototype._version = 3;\n\n/**\n * Creates a new SourceMapGenerator based on a SourceMapConsumer\n *\n * @param aSourceMapConsumer The SourceMap.\n */\nSourceMapGenerator.fromSourceMap =\n  function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {\n    var sourceRoot = aSourceMapConsumer.sourceRoot;\n    var generator = new SourceMapGenerator({\n      file: aSourceMapConsumer.file,\n      sourceRoot: sourceRoot\n    });\n    aSourceMapConsumer.eachMapping(function (mapping) {\n      var newMapping = {\n        generated: {\n          line: mapping.generatedLine,\n          column: mapping.generatedColumn\n        }\n      };\n\n      if (mapping.source != null) {\n        newMapping.source = mapping.source;\n        if (sourceRoot != null) {\n          newMapping.source = util.relative(sourceRoot, newMapping.source);\n        }\n\n        newMapping.original = {\n          line: mapping.originalLine,\n          column: mapping.originalColumn\n        };\n\n        if (mapping.name != null) {\n          newMapping.name = mapping.name;\n        }\n      }\n\n      generator.addMapping(newMapping);\n    });\n    aSourceMapConsumer.sources.forEach(function (sourceFile) {\n      var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n      if (content != null) {\n        generator.setSourceContent(sourceFile, content);\n      }\n    });\n    return generator;\n  };\n\n/**\n * Add a single mapping from original source line and column to the generated\n * source's line and column for this source map being created. The mapping\n * object should have the following properties:\n *\n *   - generated: An object with the generated line and column positions.\n *   - original: An object with the original line and column positions.\n *   - source: The original source file (relative to the sourceRoot).\n *   - name: An optional original token name for this mapping.\n */\nSourceMapGenerator.prototype.addMapping =\n  function SourceMapGenerator_addMapping(aArgs) {\n    var generated = util.getArg(aArgs, 'generated');\n    var original = util.getArg(aArgs, 'original', null);\n    var source = util.getArg(aArgs, 'source', null);\n    var name = util.getArg(aArgs, 'name', null);\n\n    if (!this._skipValidation) {\n      this._validateMapping(generated, original, source, name);\n    }\n\n    if (source != null) {\n      source = String(source);\n      if (!this._sources.has(source)) {\n        this._sources.add(source);\n      }\n    }\n\n    if (name != null) {\n      name = String(name);\n      if (!this._names.has(name)) {\n        this._names.add(name);\n      }\n    }\n\n    this._mappings.add({\n      generatedLine: generated.line,\n      generatedColumn: generated.column,\n      originalLine: original != null && original.line,\n      originalColumn: original != null && original.column,\n      source: source,\n      name: name\n    });\n  };\n\n/**\n * Set the source content for a source file.\n */\nSourceMapGenerator.prototype.setSourceContent =\n  function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {\n    var source = aSourceFile;\n    if (this._sourceRoot != null) {\n      source = util.relative(this._sourceRoot, source);\n    }\n\n    if (aSourceContent != null) {\n      // Add the source content to the _sourcesContents map.\n      // Create a new _sourcesContents map if the property is null.\n      if (!this._sourcesContents) {\n        this._sourcesContents = Object.create(null);\n      }\n      this._sourcesContents[util.toSetString(source)] = aSourceContent;\n    } else if (this._sourcesContents) {\n      // Remove the source file from the _sourcesContents map.\n      // If the _sourcesContents map is empty, set the property to null.\n      delete this._sourcesContents[util.toSetString(source)];\n      if (Object.keys(this._sourcesContents).length === 0) {\n        this._sourcesContents = null;\n      }\n    }\n  };\n\n/**\n * Applies the mappings of a sub-source-map for a specific source file to the\n * source map being generated. Each mapping to the supplied source file is\n * rewritten using the supplied source map. Note: The resolution for the\n * resulting mappings is the minimium of this map and the supplied map.\n *\n * @param aSourceMapConsumer The source map to be applied.\n * @param aSourceFile Optional. The filename of the source file.\n *        If omitted, SourceMapConsumer's file property will be used.\n * @param aSourceMapPath Optional. The dirname of the path to the source map\n *        to be applied. If relative, it is relative to the SourceMapConsumer.\n *        This parameter is needed when the two source maps aren't in the same\n *        directory, and the source map to be applied contains relative source\n *        paths. If so, those relative source paths need to be rewritten\n *        relative to the SourceMapGenerator.\n */\nSourceMapGenerator.prototype.applySourceMap =\n  function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {\n    var sourceFile = aSourceFile;\n    // If aSourceFile is omitted, we will use the file property of the SourceMap\n    if (aSourceFile == null) {\n      if (aSourceMapConsumer.file == null) {\n        throw new Error(\n          'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +\n          'or the source map\\'s \"file\" property. Both were omitted.'\n        );\n      }\n      sourceFile = aSourceMapConsumer.file;\n    }\n    var sourceRoot = this._sourceRoot;\n    // Make \"sourceFile\" relative if an absolute Url is passed.\n    if (sourceRoot != null) {\n      sourceFile = util.relative(sourceRoot, sourceFile);\n    }\n    // Applying the SourceMap can add and remove items from the sources and\n    // the names array.\n    var newSources = new ArraySet();\n    var newNames = new ArraySet();\n\n    // Find mappings for the \"sourceFile\"\n    this._mappings.unsortedForEach(function (mapping) {\n      if (mapping.source === sourceFile && mapping.originalLine != null) {\n        // Check if it can be mapped by the source map, then update the mapping.\n        var original = aSourceMapConsumer.originalPositionFor({\n          line: mapping.originalLine,\n          column: mapping.originalColumn\n        });\n        if (original.source != null) {\n          // Copy mapping\n          mapping.source = original.source;\n          if (aSourceMapPath != null) {\n            mapping.source = util.join(aSourceMapPath, mapping.source)\n          }\n          if (sourceRoot != null) {\n            mapping.source = util.relative(sourceRoot, mapping.source);\n          }\n          mapping.originalLine = original.line;\n          mapping.originalColumn = original.column;\n          if (original.name != null) {\n            mapping.name = original.name;\n          }\n        }\n      }\n\n      var source = mapping.source;\n      if (source != null && !newSources.has(source)) {\n        newSources.add(source);\n      }\n\n      var name = mapping.name;\n      if (name != null && !newNames.has(name)) {\n        newNames.add(name);\n      }\n\n    }, this);\n    this._sources = newSources;\n    this._names = newNames;\n\n    // Copy sourcesContents of applied map.\n    aSourceMapConsumer.sources.forEach(function (sourceFile) {\n      var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n      if (content != null) {\n        if (aSourceMapPath != null) {\n          sourceFile = util.join(aSourceMapPath, sourceFile);\n        }\n        if (sourceRoot != null) {\n          sourceFile = util.relative(sourceRoot, sourceFile);\n        }\n        this.setSourceContent(sourceFile, content);\n      }\n    }, this);\n  };\n\n/**\n * A mapping can have one of the three levels of data:\n *\n *   1. Just the generated position.\n *   2. The Generated position, original position, and original source.\n *   3. Generated and original position, original source, as well as a name\n *      token.\n *\n * To maintain consistency, we validate that any new mapping being added falls\n * in to one of these categories.\n */\nSourceMapGenerator.prototype._validateMapping =\n  function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,\n                                              aName) {\n    // When aOriginal is truthy but has empty values for .line and .column,\n    // it is most likely a programmer error. In this case we throw a very\n    // specific error message to try to guide them the right way.\n    // For example: https://github.com/Polymer/polymer-bundler/pull/519\n    if (aOriginal && typeof aOriginal.line !== 'number' && typeof aOriginal.column !== 'number') {\n        throw new Error(\n            'original.line and original.column are not numbers -- you probably meant to omit ' +\n            'the original mapping entirely and only map the generated position. If so, pass ' +\n            'null for the original mapping instead of an object with empty or null values.'\n        );\n    }\n\n    if (aGenerated && 'line' in aGenerated && 'column' in aGenerated\n        && aGenerated.line > 0 && aGenerated.column >= 0\n        && !aOriginal && !aSource && !aName) {\n      // Case 1.\n      return;\n    }\n    else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated\n             && aOriginal && 'line' in aOriginal && 'column' in aOriginal\n             && aGenerated.line > 0 && aGenerated.column >= 0\n             && aOriginal.line > 0 && aOriginal.column >= 0\n             && aSource) {\n      // Cases 2 and 3.\n      return;\n    }\n    else {\n      throw new Error('Invalid mapping: ' + JSON.stringify({\n        generated: aGenerated,\n        source: aSource,\n        original: aOriginal,\n        name: aName\n      }));\n    }\n  };\n\n/**\n * Serialize the accumulated mappings in to the stream of base 64 VLQs\n * specified by the source map format.\n */\nSourceMapGenerator.prototype._serializeMappings =\n  function SourceMapGenerator_serializeMappings() {\n    var previousGeneratedColumn = 0;\n    var previousGeneratedLine = 1;\n    var previousOriginalColumn = 0;\n    var previousOriginalLine = 0;\n    var previousName = 0;\n    var previousSource = 0;\n    var result = '';\n    var next;\n    var mapping;\n    var nameIdx;\n    var sourceIdx;\n\n    var mappings = this._mappings.toArray();\n    for (var i = 0, len = mappings.length; i < len; i++) {\n      mapping = mappings[i];\n      next = ''\n\n      if (mapping.generatedLine !== previousGeneratedLine) {\n        previousGeneratedColumn = 0;\n        while (mapping.generatedLine !== previousGeneratedLine) {\n          next += ';';\n          previousGeneratedLine++;\n        }\n      }\n      else {\n        if (i > 0) {\n          if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {\n            continue;\n          }\n          next += ',';\n        }\n      }\n\n      next += base64VLQ.encode(mapping.generatedColumn\n                                 - previousGeneratedColumn);\n      previousGeneratedColumn = mapping.generatedColumn;\n\n      if (mapping.source != null) {\n        sourceIdx = this._sources.indexOf(mapping.source);\n        next += base64VLQ.encode(sourceIdx - previousSource);\n        previousSource = sourceIdx;\n\n        // lines are stored 0-based in SourceMap spec version 3\n        next += base64VLQ.encode(mapping.originalLine - 1\n                                   - previousOriginalLine);\n        previousOriginalLine = mapping.originalLine - 1;\n\n        next += base64VLQ.encode(mapping.originalColumn\n                                   - previousOriginalColumn);\n        previousOriginalColumn = mapping.originalColumn;\n\n        if (mapping.name != null) {\n          nameIdx = this._names.indexOf(mapping.name);\n          next += base64VLQ.encode(nameIdx - previousName);\n          previousName = nameIdx;\n        }\n      }\n\n      result += next;\n    }\n\n    return result;\n  };\n\nSourceMapGenerator.prototype._generateSourcesContent =\n  function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {\n    return aSources.map(function (source) {\n      if (!this._sourcesContents) {\n        return null;\n      }\n      if (aSourceRoot != null) {\n        source = util.relative(aSourceRoot, source);\n      }\n      var key = util.toSetString(source);\n      return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)\n        ? this._sourcesContents[key]\n        : null;\n    }, this);\n  };\n\n/**\n * Externalize the source map.\n */\nSourceMapGenerator.prototype.toJSON =\n  function SourceMapGenerator_toJSON() {\n    var map = {\n      version: this._version,\n      sources: this._sources.toArray(),\n      names: this._names.toArray(),\n      mappings: this._serializeMappings()\n    };\n    if (this._file != null) {\n      map.file = this._file;\n    }\n    if (this._sourceRoot != null) {\n      map.sourceRoot = this._sourceRoot;\n    }\n    if (this._sourcesContents) {\n      map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);\n    }\n\n    return map;\n  };\n\n/**\n * Render the source map being generated to a string.\n */\nSourceMapGenerator.prototype.toString =\n  function SourceMapGenerator_toString() {\n    return JSON.stringify(this.toJSON());\n  };\n\nexports.SourceMapGenerator = SourceMapGenerator;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/source-map-generator.js\n// module id = 1\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n *\n * Based on the Base 64 VLQ implementation in Closure Compiler:\n * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java\n *\n * Copyright 2011 The Closure Compiler Authors. All rights reserved.\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n *  * Redistributions of source code must retain the above copyright\n *    notice, this list of conditions and the following disclaimer.\n *  * Redistributions in binary form must reproduce the above\n *    copyright notice, this list of conditions and the following\n *    disclaimer in the documentation and/or other materials provided\n *    with the distribution.\n *  * Neither the name of Google Inc. nor the names of its\n *    contributors may be used to endorse or promote products derived\n *    from this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\nvar base64 = require('./base64');\n\n// A single base 64 digit can contain 6 bits of data. For the base 64 variable\n// length quantities we use in the source map spec, the first bit is the sign,\n// the next four bits are the actual value, and the 6th bit is the\n// continuation bit. The continuation bit tells us whether there are more\n// digits in this value following this digit.\n//\n//   Continuation\n//   |    Sign\n//   |    |\n//   V    V\n//   101011\n\nvar VLQ_BASE_SHIFT = 5;\n\n// binary: 100000\nvar VLQ_BASE = 1 << VLQ_BASE_SHIFT;\n\n// binary: 011111\nvar VLQ_BASE_MASK = VLQ_BASE - 1;\n\n// binary: 100000\nvar VLQ_CONTINUATION_BIT = VLQ_BASE;\n\n/**\n * Converts from a two-complement value to a value where the sign bit is\n * placed in the least significant bit.  For example, as decimals:\n *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)\n *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)\n */\nfunction toVLQSigned(aValue) {\n  return aValue < 0\n    ? ((-aValue) << 1) + 1\n    : (aValue << 1) + 0;\n}\n\n/**\n * Converts to a two-complement value from a value where the sign bit is\n * placed in the least significant bit.  For example, as decimals:\n *   2 (10 binary) becomes 1, 3 (11 binary) becomes -1\n *   4 (100 binary) becomes 2, 5 (101 binary) becomes -2\n */\nfunction fromVLQSigned(aValue) {\n  var isNegative = (aValue & 1) === 1;\n  var shifted = aValue >> 1;\n  return isNegative\n    ? -shifted\n    : shifted;\n}\n\n/**\n * Returns the base 64 VLQ encoded value.\n */\nexports.encode = function base64VLQ_encode(aValue) {\n  var encoded = \"\";\n  var digit;\n\n  var vlq = toVLQSigned(aValue);\n\n  do {\n    digit = vlq & VLQ_BASE_MASK;\n    vlq >>>= VLQ_BASE_SHIFT;\n    if (vlq > 0) {\n      // There are still more digits in this value, so we must make sure the\n      // continuation bit is marked.\n      digit |= VLQ_CONTINUATION_BIT;\n    }\n    encoded += base64.encode(digit);\n  } while (vlq > 0);\n\n  return encoded;\n};\n\n/**\n * Decodes the next base 64 VLQ value from the given string and returns the\n * value and the rest of the string via the out parameter.\n */\nexports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {\n  var strLen = aStr.length;\n  var result = 0;\n  var shift = 0;\n  var continuation, digit;\n\n  do {\n    if (aIndex >= strLen) {\n      throw new Error(\"Expected more digits in base 64 VLQ value.\");\n    }\n\n    digit = base64.decode(aStr.charCodeAt(aIndex++));\n    if (digit === -1) {\n      throw new Error(\"Invalid base64 digit: \" + aStr.charAt(aIndex - 1));\n    }\n\n    continuation = !!(digit & VLQ_CONTINUATION_BIT);\n    digit &= VLQ_BASE_MASK;\n    result = result + (digit << shift);\n    shift += VLQ_BASE_SHIFT;\n  } while (continuation);\n\n  aOutParam.value = fromVLQSigned(result);\n  aOutParam.rest = aIndex;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/base64-vlq.js\n// module id = 2\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar intToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');\n\n/**\n * Encode an integer in the range of 0 to 63 to a single base 64 digit.\n */\nexports.encode = function (number) {\n  if (0 <= number && number < intToCharMap.length) {\n    return intToCharMap[number];\n  }\n  throw new TypeError(\"Must be between 0 and 63: \" + number);\n};\n\n/**\n * Decode a single base 64 character code digit to an integer. Returns -1 on\n * failure.\n */\nexports.decode = function (charCode) {\n  var bigA = 65;     // 'A'\n  var bigZ = 90;     // 'Z'\n\n  var littleA = 97;  // 'a'\n  var littleZ = 122; // 'z'\n\n  var zero = 48;     // '0'\n  var nine = 57;     // '9'\n\n  var plus = 43;     // '+'\n  var slash = 47;    // '/'\n\n  var littleOffset = 26;\n  var numberOffset = 52;\n\n  // 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ\n  if (bigA <= charCode && charCode <= bigZ) {\n    return (charCode - bigA);\n  }\n\n  // 26 - 51: abcdefghijklmnopqrstuvwxyz\n  if (littleA <= charCode && charCode <= littleZ) {\n    return (charCode - littleA + littleOffset);\n  }\n\n  // 52 - 61: 0123456789\n  if (zero <= charCode && charCode <= nine) {\n    return (charCode - zero + numberOffset);\n  }\n\n  // 62: +\n  if (charCode == plus) {\n    return 62;\n  }\n\n  // 63: /\n  if (charCode == slash) {\n    return 63;\n  }\n\n  // Invalid base64 digit.\n  return -1;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/base64.js\n// module id = 3\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\n/**\n * This is a helper function for getting values from parameter/options\n * objects.\n *\n * @param args The object we are extracting values from\n * @param name The name of the property we are getting.\n * @param defaultValue An optional value to return if the property is missing\n * from the object. If this is not specified and the property is missing, an\n * error will be thrown.\n */\nfunction getArg(aArgs, aName, aDefaultValue) {\n  if (aName in aArgs) {\n    return aArgs[aName];\n  } else if (arguments.length === 3) {\n    return aDefaultValue;\n  } else {\n    throw new Error('\"' + aName + '\" is a required argument.');\n  }\n}\nexports.getArg = getArg;\n\nvar urlRegexp = /^(?:([\\w+\\-.]+):)?\\/\\/(?:(\\w+:\\w+)@)?([\\w.]*)(?::(\\d+))?(\\S*)$/;\nvar dataUrlRegexp = /^data:.+\\,.+$/;\n\nfunction urlParse(aUrl) {\n  var match = aUrl.match(urlRegexp);\n  if (!match) {\n    return null;\n  }\n  return {\n    scheme: match[1],\n    auth: match[2],\n    host: match[3],\n    port: match[4],\n    path: match[5]\n  };\n}\nexports.urlParse = urlParse;\n\nfunction urlGenerate(aParsedUrl) {\n  var url = '';\n  if (aParsedUrl.scheme) {\n    url += aParsedUrl.scheme + ':';\n  }\n  url += '//';\n  if (aParsedUrl.auth) {\n    url += aParsedUrl.auth + '@';\n  }\n  if (aParsedUrl.host) {\n    url += aParsedUrl.host;\n  }\n  if (aParsedUrl.port) {\n    url += \":\" + aParsedUrl.port\n  }\n  if (aParsedUrl.path) {\n    url += aParsedUrl.path;\n  }\n  return url;\n}\nexports.urlGenerate = urlGenerate;\n\n/**\n * Normalizes a path, or the path portion of a URL:\n *\n * - Replaces consecutive slashes with one slash.\n * - Removes unnecessary '.' parts.\n * - Removes unnecessary '<dir>/..' parts.\n *\n * Based on code in the Node.js 'path' core module.\n *\n * @param aPath The path or url to normalize.\n */\nfunction normalize(aPath) {\n  var path = aPath;\n  var url = urlParse(aPath);\n  if (url) {\n    if (!url.path) {\n      return aPath;\n    }\n    path = url.path;\n  }\n  var isAbsolute = exports.isAbsolute(path);\n\n  var parts = path.split(/\\/+/);\n  for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {\n    part = parts[i];\n    if (part === '.') {\n      parts.splice(i, 1);\n    } else if (part === '..') {\n      up++;\n    } else if (up > 0) {\n      if (part === '') {\n        // The first part is blank if the path is absolute. Trying to go\n        // above the root is a no-op. Therefore we can remove all '..' parts\n        // directly after the root.\n        parts.splice(i + 1, up);\n        up = 0;\n      } else {\n        parts.splice(i, 2);\n        up--;\n      }\n    }\n  }\n  path = parts.join('/');\n\n  if (path === '') {\n    path = isAbsolute ? '/' : '.';\n  }\n\n  if (url) {\n    url.path = path;\n    return urlGenerate(url);\n  }\n  return path;\n}\nexports.normalize = normalize;\n\n/**\n * Joins two paths/URLs.\n *\n * @param aRoot The root path or URL.\n * @param aPath The path or URL to be joined with the root.\n *\n * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a\n *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended\n *   first.\n * - Otherwise aPath is a path. If aRoot is a URL, then its path portion\n *   is updated with the result and aRoot is returned. Otherwise the result\n *   is returned.\n *   - If aPath is absolute, the result is aPath.\n *   - Otherwise the two paths are joined with a slash.\n * - Joining for example 'http://' and 'www.example.com' is also supported.\n */\nfunction join(aRoot, aPath) {\n  if (aRoot === \"\") {\n    aRoot = \".\";\n  }\n  if (aPath === \"\") {\n    aPath = \".\";\n  }\n  var aPathUrl = urlParse(aPath);\n  var aRootUrl = urlParse(aRoot);\n  if (aRootUrl) {\n    aRoot = aRootUrl.path || '/';\n  }\n\n  // `join(foo, '//www.example.org')`\n  if (aPathUrl && !aPathUrl.scheme) {\n    if (aRootUrl) {\n      aPathUrl.scheme = aRootUrl.scheme;\n    }\n    return urlGenerate(aPathUrl);\n  }\n\n  if (aPathUrl || aPath.match(dataUrlRegexp)) {\n    return aPath;\n  }\n\n  // `join('http://', 'www.example.com')`\n  if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {\n    aRootUrl.host = aPath;\n    return urlGenerate(aRootUrl);\n  }\n\n  var joined = aPath.charAt(0) === '/'\n    ? aPath\n    : normalize(aRoot.replace(/\\/+$/, '') + '/' + aPath);\n\n  if (aRootUrl) {\n    aRootUrl.path = joined;\n    return urlGenerate(aRootUrl);\n  }\n  return joined;\n}\nexports.join = join;\n\nexports.isAbsolute = function (aPath) {\n  return aPath.charAt(0) === '/' || !!aPath.match(urlRegexp);\n};\n\n/**\n * Make a path relative to a URL or another path.\n *\n * @param aRoot The root path or URL.\n * @param aPath The path or URL to be made relative to aRoot.\n */\nfunction relative(aRoot, aPath) {\n  if (aRoot === \"\") {\n    aRoot = \".\";\n  }\n\n  aRoot = aRoot.replace(/\\/$/, '');\n\n  // It is possible for the path to be above the root. In this case, simply\n  // checking whether the root is a prefix of the path won't work. Instead, we\n  // need to remove components from the root one by one, until either we find\n  // a prefix that fits, or we run out of components to remove.\n  var level = 0;\n  while (aPath.indexOf(aRoot + '/') !== 0) {\n    var index = aRoot.lastIndexOf(\"/\");\n    if (index < 0) {\n      return aPath;\n    }\n\n    // If the only part of the root that is left is the scheme (i.e. http://,\n    // file:///, etc.), one or more slashes (/), or simply nothing at all, we\n    // have exhausted all components, so the path is not relative to the root.\n    aRoot = aRoot.slice(0, index);\n    if (aRoot.match(/^([^\\/]+:\\/)?\\/*$/)) {\n      return aPath;\n    }\n\n    ++level;\n  }\n\n  // Make sure we add a \"../\" for each component we removed from the root.\n  return Array(level + 1).join(\"../\") + aPath.substr(aRoot.length + 1);\n}\nexports.relative = relative;\n\nvar supportsNullProto = (function () {\n  var obj = Object.create(null);\n  return !('__proto__' in obj);\n}());\n\nfunction identity (s) {\n  return s;\n}\n\n/**\n * Because behavior goes wacky when you set `__proto__` on objects, we\n * have to prefix all the strings in our set with an arbitrary character.\n *\n * See https://github.com/mozilla/source-map/pull/31 and\n * https://github.com/mozilla/source-map/issues/30\n *\n * @param String aStr\n */\nfunction toSetString(aStr) {\n  if (isProtoString(aStr)) {\n    return '$' + aStr;\n  }\n\n  return aStr;\n}\nexports.toSetString = supportsNullProto ? identity : toSetString;\n\nfunction fromSetString(aStr) {\n  if (isProtoString(aStr)) {\n    return aStr.slice(1);\n  }\n\n  return aStr;\n}\nexports.fromSetString = supportsNullProto ? identity : fromSetString;\n\nfunction isProtoString(s) {\n  if (!s) {\n    return false;\n  }\n\n  var length = s.length;\n\n  if (length < 9 /* \"__proto__\".length */) {\n    return false;\n  }\n\n  if (s.charCodeAt(length - 1) !== 95  /* '_' */ ||\n      s.charCodeAt(length - 2) !== 95  /* '_' */ ||\n      s.charCodeAt(length - 3) !== 111 /* 'o' */ ||\n      s.charCodeAt(length - 4) !== 116 /* 't' */ ||\n      s.charCodeAt(length - 5) !== 111 /* 'o' */ ||\n      s.charCodeAt(length - 6) !== 114 /* 'r' */ ||\n      s.charCodeAt(length - 7) !== 112 /* 'p' */ ||\n      s.charCodeAt(length - 8) !== 95  /* '_' */ ||\n      s.charCodeAt(length - 9) !== 95  /* '_' */) {\n    return false;\n  }\n\n  for (var i = length - 10; i >= 0; i--) {\n    if (s.charCodeAt(i) !== 36 /* '$' */) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Comparator between two mappings where the original positions are compared.\n *\n * Optionally pass in `true` as `onlyCompareGenerated` to consider two\n * mappings with the same original source/line/column, but different generated\n * line and column the same. Useful when searching for a mapping with a\n * stubbed out mapping.\n */\nfunction compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {\n  var cmp = mappingA.source - mappingB.source;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalLine - mappingB.originalLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalColumn - mappingB.originalColumn;\n  if (cmp !== 0 || onlyCompareOriginal) {\n    return cmp;\n  }\n\n  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.generatedLine - mappingB.generatedLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  return mappingA.name - mappingB.name;\n}\nexports.compareByOriginalPositions = compareByOriginalPositions;\n\n/**\n * Comparator between two mappings with deflated source and name indices where\n * the generated positions are compared.\n *\n * Optionally pass in `true` as `onlyCompareGenerated` to consider two\n * mappings with the same generated line and column, but different\n * source/name/original line and column the same. Useful when searching for a\n * mapping with a stubbed out mapping.\n */\nfunction compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {\n  var cmp = mappingA.generatedLine - mappingB.generatedLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n  if (cmp !== 0 || onlyCompareGenerated) {\n    return cmp;\n  }\n\n  cmp = mappingA.source - mappingB.source;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalLine - mappingB.originalLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalColumn - mappingB.originalColumn;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  return mappingA.name - mappingB.name;\n}\nexports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;\n\nfunction strcmp(aStr1, aStr2) {\n  if (aStr1 === aStr2) {\n    return 0;\n  }\n\n  if (aStr1 > aStr2) {\n    return 1;\n  }\n\n  return -1;\n}\n\n/**\n * Comparator between two mappings with inflated source and name strings where\n * the generated positions are compared.\n */\nfunction compareByGeneratedPositionsInflated(mappingA, mappingB) {\n  var cmp = mappingA.generatedLine - mappingB.generatedLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = strcmp(mappingA.source, mappingB.source);\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalLine - mappingB.originalLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalColumn - mappingB.originalColumn;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  return strcmp(mappingA.name, mappingB.name);\n}\nexports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/util.js\n// module id = 4\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar util = require('./util');\nvar has = Object.prototype.hasOwnProperty;\nvar hasNativeMap = typeof Map !== \"undefined\";\n\n/**\n * A data structure which is a combination of an array and a set. Adding a new\n * member is O(1), testing for membership is O(1), and finding the index of an\n * element is O(1). Removing elements from the set is not supported. Only\n * strings are supported for membership.\n */\nfunction ArraySet() {\n  this._array = [];\n  this._set = hasNativeMap ? new Map() : Object.create(null);\n}\n\n/**\n * Static method for creating ArraySet instances from an existing array.\n */\nArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {\n  var set = new ArraySet();\n  for (var i = 0, len = aArray.length; i < len; i++) {\n    set.add(aArray[i], aAllowDuplicates);\n  }\n  return set;\n};\n\n/**\n * Return how many unique items are in this ArraySet. If duplicates have been\n * added, than those do not count towards the size.\n *\n * @returns Number\n */\nArraySet.prototype.size = function ArraySet_size() {\n  return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;\n};\n\n/**\n * Add the given string to this set.\n *\n * @param String aStr\n */\nArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {\n  var sStr = hasNativeMap ? aStr : util.toSetString(aStr);\n  var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);\n  var idx = this._array.length;\n  if (!isDuplicate || aAllowDuplicates) {\n    this._array.push(aStr);\n  }\n  if (!isDuplicate) {\n    if (hasNativeMap) {\n      this._set.set(aStr, idx);\n    } else {\n      this._set[sStr] = idx;\n    }\n  }\n};\n\n/**\n * Is the given string a member of this set?\n *\n * @param String aStr\n */\nArraySet.prototype.has = function ArraySet_has(aStr) {\n  if (hasNativeMap) {\n    return this._set.has(aStr);\n  } else {\n    var sStr = util.toSetString(aStr);\n    return has.call(this._set, sStr);\n  }\n};\n\n/**\n * What is the index of the given string in the array?\n *\n * @param String aStr\n */\nArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {\n  if (hasNativeMap) {\n    var idx = this._set.get(aStr);\n    if (idx >= 0) {\n        return idx;\n    }\n  } else {\n    var sStr = util.toSetString(aStr);\n    if (has.call(this._set, sStr)) {\n      return this._set[sStr];\n    }\n  }\n\n  throw new Error('\"' + aStr + '\" is not in the set.');\n};\n\n/**\n * What is the element at the given index?\n *\n * @param Number aIdx\n */\nArraySet.prototype.at = function ArraySet_at(aIdx) {\n  if (aIdx >= 0 && aIdx < this._array.length) {\n    return this._array[aIdx];\n  }\n  throw new Error('No element indexed by ' + aIdx);\n};\n\n/**\n * Returns the array representation of this set (which has the proper indices\n * indicated by indexOf). Note that this is a copy of the internal array used\n * for storing the members so that no one can mess with internal state.\n */\nArraySet.prototype.toArray = function ArraySet_toArray() {\n  return this._array.slice();\n};\n\nexports.ArraySet = ArraySet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/array-set.js\n// module id = 5\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2014 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar util = require('./util');\n\n/**\n * Determine whether mappingB is after mappingA with respect to generated\n * position.\n */\nfunction generatedPositionAfter(mappingA, mappingB) {\n  // Optimized for most common case\n  var lineA = mappingA.generatedLine;\n  var lineB = mappingB.generatedLine;\n  var columnA = mappingA.generatedColumn;\n  var columnB = mappingB.generatedColumn;\n  return lineB > lineA || lineB == lineA && columnB >= columnA ||\n         util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;\n}\n\n/**\n * A data structure to provide a sorted view of accumulated mappings in a\n * performance conscious manner. It trades a neglibable overhead in general\n * case for a large speedup in case of mappings being added in order.\n */\nfunction MappingList() {\n  this._array = [];\n  this._sorted = true;\n  // Serves as infimum\n  this._last = {generatedLine: -1, generatedColumn: 0};\n}\n\n/**\n * Iterate through internal items. This method takes the same arguments that\n * `Array.prototype.forEach` takes.\n *\n * NOTE: The order of the mappings is NOT guaranteed.\n */\nMappingList.prototype.unsortedForEach =\n  function MappingList_forEach(aCallback, aThisArg) {\n    this._array.forEach(aCallback, aThisArg);\n  };\n\n/**\n * Add the given source mapping.\n *\n * @param Object aMapping\n */\nMappingList.prototype.add = function MappingList_add(aMapping) {\n  if (generatedPositionAfter(this._last, aMapping)) {\n    this._last = aMapping;\n    this._array.push(aMapping);\n  } else {\n    this._sorted = false;\n    this._array.push(aMapping);\n  }\n};\n\n/**\n * Returns the flat, sorted array of mappings. The mappings are sorted by\n * generated position.\n *\n * WARNING: This method returns internal data without copying, for\n * performance. The return value must NOT be mutated, and should be treated as\n * an immutable borrow. If you want to take ownership, you must make your own\n * copy.\n */\nMappingList.prototype.toArray = function MappingList_toArray() {\n  if (!this._sorted) {\n    this._array.sort(util.compareByGeneratedPositionsInflated);\n    this._sorted = true;\n  }\n  return this._array;\n};\n\nexports.MappingList = MappingList;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/mapping-list.js\n// module id = 6\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar util = require('./util');\nvar binarySearch = require('./binary-search');\nvar ArraySet = require('./array-set').ArraySet;\nvar base64VLQ = require('./base64-vlq');\nvar quickSort = require('./quick-sort').quickSort;\n\nfunction SourceMapConsumer(aSourceMap) {\n  var sourceMap = aSourceMap;\n  if (typeof aSourceMap === 'string') {\n    sourceMap = JSON.parse(aSourceMap.replace(/^\\)\\]\\}'/, ''));\n  }\n\n  return sourceMap.sections != null\n    ? new IndexedSourceMapConsumer(sourceMap)\n    : new BasicSourceMapConsumer(sourceMap);\n}\n\nSourceMapConsumer.fromSourceMap = function(aSourceMap) {\n  return BasicSourceMapConsumer.fromSourceMap(aSourceMap);\n}\n\n/**\n * The version of the source mapping spec that we are consuming.\n */\nSourceMapConsumer.prototype._version = 3;\n\n// `__generatedMappings` and `__originalMappings` are arrays that hold the\n// parsed mapping coordinates from the source map's \"mappings\" attribute. They\n// are lazily instantiated, accessed via the `_generatedMappings` and\n// `_originalMappings` getters respectively, and we only parse the mappings\n// and create these arrays once queried for a source location. We jump through\n// these hoops because there can be many thousands of mappings, and parsing\n// them is expensive, so we only want to do it if we must.\n//\n// Each object in the arrays is of the form:\n//\n//     {\n//       generatedLine: The line number in the generated code,\n//       generatedColumn: The column number in the generated code,\n//       source: The path to the original source file that generated this\n//               chunk of code,\n//       originalLine: The line number in the original source that\n//                     corresponds to this chunk of generated code,\n//       originalColumn: The column number in the original source that\n//                       corresponds to this chunk of generated code,\n//       name: The name of the original symbol which generated this chunk of\n//             code.\n//     }\n//\n// All properties except for `generatedLine` and `generatedColumn` can be\n// `null`.\n//\n// `_generatedMappings` is ordered by the generated positions.\n//\n// `_originalMappings` is ordered by the original positions.\n\nSourceMapConsumer.prototype.__generatedMappings = null;\nObject.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {\n  get: function () {\n    if (!this.__generatedMappings) {\n      this._parseMappings(this._mappings, this.sourceRoot);\n    }\n\n    return this.__generatedMappings;\n  }\n});\n\nSourceMapConsumer.prototype.__originalMappings = null;\nObject.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {\n  get: function () {\n    if (!this.__originalMappings) {\n      this._parseMappings(this._mappings, this.sourceRoot);\n    }\n\n    return this.__originalMappings;\n  }\n});\n\nSourceMapConsumer.prototype._charIsMappingSeparator =\n  function SourceMapConsumer_charIsMappingSeparator(aStr, index) {\n    var c = aStr.charAt(index);\n    return c === \";\" || c === \",\";\n  };\n\n/**\n * Parse the mappings in a string in to a data structure which we can easily\n * query (the ordered arrays in the `this.__generatedMappings` and\n * `this.__originalMappings` properties).\n */\nSourceMapConsumer.prototype._parseMappings =\n  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n    throw new Error(\"Subclasses must implement _parseMappings\");\n  };\n\nSourceMapConsumer.GENERATED_ORDER = 1;\nSourceMapConsumer.ORIGINAL_ORDER = 2;\n\nSourceMapConsumer.GREATEST_LOWER_BOUND = 1;\nSourceMapConsumer.LEAST_UPPER_BOUND = 2;\n\n/**\n * Iterate over each mapping between an original source/line/column and a\n * generated line/column in this source map.\n *\n * @param Function aCallback\n *        The function that is called with each mapping.\n * @param Object aContext\n *        Optional. If specified, this object will be the value of `this` every\n *        time that `aCallback` is called.\n * @param aOrder\n *        Either `SourceMapConsumer.GENERATED_ORDER` or\n *        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to\n *        iterate over the mappings sorted by the generated file's line/column\n *        order or the original's source/line/column order, respectively. Defaults to\n *        `SourceMapConsumer.GENERATED_ORDER`.\n */\nSourceMapConsumer.prototype.eachMapping =\n  function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {\n    var context = aContext || null;\n    var order = aOrder || SourceMapConsumer.GENERATED_ORDER;\n\n    var mappings;\n    switch (order) {\n    case SourceMapConsumer.GENERATED_ORDER:\n      mappings = this._generatedMappings;\n      break;\n    case SourceMapConsumer.ORIGINAL_ORDER:\n      mappings = this._originalMappings;\n      break;\n    default:\n      throw new Error(\"Unknown order of iteration.\");\n    }\n\n    var sourceRoot = this.sourceRoot;\n    mappings.map(function (mapping) {\n      var source = mapping.source === null ? null : this._sources.at(mapping.source);\n      if (source != null && sourceRoot != null) {\n        source = util.join(sourceRoot, source);\n      }\n      return {\n        source: source,\n        generatedLine: mapping.generatedLine,\n        generatedColumn: mapping.generatedColumn,\n        originalLine: mapping.originalLine,\n        originalColumn: mapping.originalColumn,\n        name: mapping.name === null ? null : this._names.at(mapping.name)\n      };\n    }, this).forEach(aCallback, context);\n  };\n\n/**\n * Returns all generated line and column information for the original source,\n * line, and column provided. If no column is provided, returns all mappings\n * corresponding to a either the line we are searching for or the next\n * closest line that has any mappings. Otherwise, returns all mappings\n * corresponding to the given line and either the column we are searching for\n * or the next closest column that has any offsets.\n *\n * The only argument is an object with the following properties:\n *\n *   - source: The filename of the original source.\n *   - line: The line number in the original source.\n *   - column: Optional. the column number in the original source.\n *\n * and an array of objects is returned, each with the following properties:\n *\n *   - line: The line number in the generated source, or null.\n *   - column: The column number in the generated source, or null.\n */\nSourceMapConsumer.prototype.allGeneratedPositionsFor =\n  function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {\n    var line = util.getArg(aArgs, 'line');\n\n    // When there is no exact match, BasicSourceMapConsumer.prototype._findMapping\n    // returns the index of the closest mapping less than the needle. By\n    // setting needle.originalColumn to 0, we thus find the last mapping for\n    // the given line, provided such a mapping exists.\n    var needle = {\n      source: util.getArg(aArgs, 'source'),\n      originalLine: line,\n      originalColumn: util.getArg(aArgs, 'column', 0)\n    };\n\n    if (this.sourceRoot != null) {\n      needle.source = util.relative(this.sourceRoot, needle.source);\n    }\n    if (!this._sources.has(needle.source)) {\n      return [];\n    }\n    needle.source = this._sources.indexOf(needle.source);\n\n    var mappings = [];\n\n    var index = this._findMapping(needle,\n                                  this._originalMappings,\n                                  \"originalLine\",\n                                  \"originalColumn\",\n                                  util.compareByOriginalPositions,\n                                  binarySearch.LEAST_UPPER_BOUND);\n    if (index >= 0) {\n      var mapping = this._originalMappings[index];\n\n      if (aArgs.column === undefined) {\n        var originalLine = mapping.originalLine;\n\n        // Iterate until either we run out of mappings, or we run into\n        // a mapping for a different line than the one we found. Since\n        // mappings are sorted, this is guaranteed to find all mappings for\n        // the line we found.\n        while (mapping && mapping.originalLine === originalLine) {\n          mappings.push({\n            line: util.getArg(mapping, 'generatedLine', null),\n            column: util.getArg(mapping, 'generatedColumn', null),\n            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n          });\n\n          mapping = this._originalMappings[++index];\n        }\n      } else {\n        var originalColumn = mapping.originalColumn;\n\n        // Iterate until either we run out of mappings, or we run into\n        // a mapping for a different line than the one we were searching for.\n        // Since mappings are sorted, this is guaranteed to find all mappings for\n        // the line we are searching for.\n        while (mapping &&\n               mapping.originalLine === line &&\n               mapping.originalColumn == originalColumn) {\n          mappings.push({\n            line: util.getArg(mapping, 'generatedLine', null),\n            column: util.getArg(mapping, 'generatedColumn', null),\n            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n          });\n\n          mapping = this._originalMappings[++index];\n        }\n      }\n    }\n\n    return mappings;\n  };\n\nexports.SourceMapConsumer = SourceMapConsumer;\n\n/**\n * A BasicSourceMapConsumer instance represents a parsed source map which we can\n * query for information about the original file positions by giving it a file\n * position in the generated source.\n *\n * The only parameter is the raw source map (either as a JSON string, or\n * already parsed to an object). According to the spec, source maps have the\n * following attributes:\n *\n *   - version: Which version of the source map spec this map is following.\n *   - sources: An array of URLs to the original source files.\n *   - names: An array of identifiers which can be referrenced by individual mappings.\n *   - sourceRoot: Optional. The URL root from which all sources are relative.\n *   - sourcesContent: Optional. An array of contents of the original source files.\n *   - mappings: A string of base64 VLQs which contain the actual mappings.\n *   - file: Optional. The generated file this source map is associated with.\n *\n * Here is an example source map, taken from the source map spec[0]:\n *\n *     {\n *       version : 3,\n *       file: \"out.js\",\n *       sourceRoot : \"\",\n *       sources: [\"foo.js\", \"bar.js\"],\n *       names: [\"src\", \"maps\", \"are\", \"fun\"],\n *       mappings: \"AA,AB;;ABCDE;\"\n *     }\n *\n * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#\n */\nfunction BasicSourceMapConsumer(aSourceMap) {\n  var sourceMap = aSourceMap;\n  if (typeof aSourceMap === 'string') {\n    sourceMap = JSON.parse(aSourceMap.replace(/^\\)\\]\\}'/, ''));\n  }\n\n  var version = util.getArg(sourceMap, 'version');\n  var sources = util.getArg(sourceMap, 'sources');\n  // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which\n  // requires the array) to play nice here.\n  var names = util.getArg(sourceMap, 'names', []);\n  var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);\n  var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);\n  var mappings = util.getArg(sourceMap, 'mappings');\n  var file = util.getArg(sourceMap, 'file', null);\n\n  // Once again, Sass deviates from the spec and supplies the version as a\n  // string rather than a number, so we use loose equality checking here.\n  if (version != this._version) {\n    throw new Error('Unsupported version: ' + version);\n  }\n\n  sources = sources\n    .map(String)\n    // Some source maps produce relative source paths like \"./foo.js\" instead of\n    // \"foo.js\".  Normalize these first so that future comparisons will succeed.\n    // See bugzil.la/1090768.\n    .map(util.normalize)\n    // Always ensure that absolute sources are internally stored relative to\n    // the source root, if the source root is absolute. Not doing this would\n    // be particularly problematic when the source root is a prefix of the\n    // source (valid, but why??). See github issue #199 and bugzil.la/1188982.\n    .map(function (source) {\n      return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source)\n        ? util.relative(sourceRoot, source)\n        : source;\n    });\n\n  // Pass `true` below to allow duplicate names and sources. While source maps\n  // are intended to be compressed and deduplicated, the TypeScript compiler\n  // sometimes generates source maps with duplicates in them. See Github issue\n  // #72 and bugzil.la/889492.\n  this._names = ArraySet.fromArray(names.map(String), true);\n  this._sources = ArraySet.fromArray(sources, true);\n\n  this.sourceRoot = sourceRoot;\n  this.sourcesContent = sourcesContent;\n  this._mappings = mappings;\n  this.file = file;\n}\n\nBasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);\nBasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;\n\n/**\n * Create a BasicSourceMapConsumer from a SourceMapGenerator.\n *\n * @param SourceMapGenerator aSourceMap\n *        The source map that will be consumed.\n * @returns BasicSourceMapConsumer\n */\nBasicSourceMapConsumer.fromSourceMap =\n  function SourceMapConsumer_fromSourceMap(aSourceMap) {\n    var smc = Object.create(BasicSourceMapConsumer.prototype);\n\n    var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);\n    var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);\n    smc.sourceRoot = aSourceMap._sourceRoot;\n    smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),\n                                                            smc.sourceRoot);\n    smc.file = aSourceMap._file;\n\n    // Because we are modifying the entries (by converting string sources and\n    // names to indices into the sources and names ArraySets), we have to make\n    // a copy of the entry or else bad things happen. Shared mutable state\n    // strikes again! See github issue #191.\n\n    var generatedMappings = aSourceMap._mappings.toArray().slice();\n    var destGeneratedMappings = smc.__generatedMappings = [];\n    var destOriginalMappings = smc.__originalMappings = [];\n\n    for (var i = 0, length = generatedMappings.length; i < length; i++) {\n      var srcMapping = generatedMappings[i];\n      var destMapping = new Mapping;\n      destMapping.generatedLine = srcMapping.generatedLine;\n      destMapping.generatedColumn = srcMapping.generatedColumn;\n\n      if (srcMapping.source) {\n        destMapping.source = sources.indexOf(srcMapping.source);\n        destMapping.originalLine = srcMapping.originalLine;\n        destMapping.originalColumn = srcMapping.originalColumn;\n\n        if (srcMapping.name) {\n          destMapping.name = names.indexOf(srcMapping.name);\n        }\n\n        destOriginalMappings.push(destMapping);\n      }\n\n      destGeneratedMappings.push(destMapping);\n    }\n\n    quickSort(smc.__originalMappings, util.compareByOriginalPositions);\n\n    return smc;\n  };\n\n/**\n * The version of the source mapping spec that we are consuming.\n */\nBasicSourceMapConsumer.prototype._version = 3;\n\n/**\n * The list of original sources.\n */\nObject.defineProperty(BasicSourceMapConsumer.prototype, 'sources', {\n  get: function () {\n    return this._sources.toArray().map(function (s) {\n      return this.sourceRoot != null ? util.join(this.sourceRoot, s) : s;\n    }, this);\n  }\n});\n\n/**\n * Provide the JIT with a nice shape / hidden class.\n */\nfunction Mapping() {\n  this.generatedLine = 0;\n  this.generatedColumn = 0;\n  this.source = null;\n  this.originalLine = null;\n  this.originalColumn = null;\n  this.name = null;\n}\n\n/**\n * Parse the mappings in a string in to a data structure which we can easily\n * query (the ordered arrays in the `this.__generatedMappings` and\n * `this.__originalMappings` properties).\n */\nBasicSourceMapConsumer.prototype._parseMappings =\n  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n    var generatedLine = 1;\n    var previousGeneratedColumn = 0;\n    var previousOriginalLine = 0;\n    var previousOriginalColumn = 0;\n    var previousSource = 0;\n    var previousName = 0;\n    var length = aStr.length;\n    var index = 0;\n    var cachedSegments = {};\n    var temp = {};\n    var originalMappings = [];\n    var generatedMappings = [];\n    var mapping, str, segment, end, value;\n\n    while (index < length) {\n      if (aStr.charAt(index) === ';') {\n        generatedLine++;\n        index++;\n        previousGeneratedColumn = 0;\n      }\n      else if (aStr.charAt(index) === ',') {\n        index++;\n      }\n      else {\n        mapping = new Mapping();\n        mapping.generatedLine = generatedLine;\n\n        // Because each offset is encoded relative to the previous one,\n        // many segments often have the same encoding. We can exploit this\n        // fact by caching the parsed variable length fields of each segment,\n        // allowing us to avoid a second parse if we encounter the same\n        // segment again.\n        for (end = index; end < length; end++) {\n          if (this._charIsMappingSeparator(aStr, end)) {\n            break;\n          }\n        }\n        str = aStr.slice(index, end);\n\n        segment = cachedSegments[str];\n        if (segment) {\n          index += str.length;\n        } else {\n          segment = [];\n          while (index < end) {\n            base64VLQ.decode(aStr, index, temp);\n            value = temp.value;\n            index = temp.rest;\n            segment.push(value);\n          }\n\n          if (segment.length === 2) {\n            throw new Error('Found a source, but no line and column');\n          }\n\n          if (segment.length === 3) {\n            throw new Error('Found a source and line, but no column');\n          }\n\n          cachedSegments[str] = segment;\n        }\n\n        // Generated column.\n        mapping.generatedColumn = previousGeneratedColumn + segment[0];\n        previousGeneratedColumn = mapping.generatedColumn;\n\n        if (segment.length > 1) {\n          // Original source.\n          mapping.source = previousSource + segment[1];\n          previousSource += segment[1];\n\n          // Original line.\n          mapping.originalLine = previousOriginalLine + segment[2];\n          previousOriginalLine = mapping.originalLine;\n          // Lines are stored 0-based\n          mapping.originalLine += 1;\n\n          // Original column.\n          mapping.originalColumn = previousOriginalColumn + segment[3];\n          previousOriginalColumn = mapping.originalColumn;\n\n          if (segment.length > 4) {\n            // Original name.\n            mapping.name = previousName + segment[4];\n            previousName += segment[4];\n          }\n        }\n\n        generatedMappings.push(mapping);\n        if (typeof mapping.originalLine === 'number') {\n          originalMappings.push(mapping);\n        }\n      }\n    }\n\n    quickSort(generatedMappings, util.compareByGeneratedPositionsDeflated);\n    this.__generatedMappings = generatedMappings;\n\n    quickSort(originalMappings, util.compareByOriginalPositions);\n    this.__originalMappings = originalMappings;\n  };\n\n/**\n * Find the mapping that best matches the hypothetical \"needle\" mapping that\n * we are searching for in the given \"haystack\" of mappings.\n */\nBasicSourceMapConsumer.prototype._findMapping =\n  function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,\n                                         aColumnName, aComparator, aBias) {\n    // To return the position we are searching for, we must first find the\n    // mapping for the given position and then return the opposite position it\n    // points to. Because the mappings are sorted, we can use binary search to\n    // find the best mapping.\n\n    if (aNeedle[aLineName] <= 0) {\n      throw new TypeError('Line must be greater than or equal to 1, got '\n                          + aNeedle[aLineName]);\n    }\n    if (aNeedle[aColumnName] < 0) {\n      throw new TypeError('Column must be greater than or equal to 0, got '\n                          + aNeedle[aColumnName]);\n    }\n\n    return binarySearch.search(aNeedle, aMappings, aComparator, aBias);\n  };\n\n/**\n * Compute the last column for each generated mapping. The last column is\n * inclusive.\n */\nBasicSourceMapConsumer.prototype.computeColumnSpans =\n  function SourceMapConsumer_computeColumnSpans() {\n    for (var index = 0; index < this._generatedMappings.length; ++index) {\n      var mapping = this._generatedMappings[index];\n\n      // Mappings do not contain a field for the last generated columnt. We\n      // can come up with an optimistic estimate, however, by assuming that\n      // mappings are contiguous (i.e. given two consecutive mappings, the\n      // first mapping ends where the second one starts).\n      if (index + 1 < this._generatedMappings.length) {\n        var nextMapping = this._generatedMappings[index + 1];\n\n        if (mapping.generatedLine === nextMapping.generatedLine) {\n          mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;\n          continue;\n        }\n      }\n\n      // The last mapping for each line spans the entire line.\n      mapping.lastGeneratedColumn = Infinity;\n    }\n  };\n\n/**\n * Returns the original source, line, and column information for the generated\n * source's line and column positions provided. The only argument is an object\n * with the following properties:\n *\n *   - line: The line number in the generated source.\n *   - column: The column number in the generated source.\n *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or\n *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the\n *     closest element that is smaller than or greater than the one we are\n *     searching for, respectively, if the exact element cannot be found.\n *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.\n *\n * and an object is returned with the following properties:\n *\n *   - source: The original source file, or null.\n *   - line: The line number in the original source, or null.\n *   - column: The column number in the original source, or null.\n *   - name: The original identifier, or null.\n */\nBasicSourceMapConsumer.prototype.originalPositionFor =\n  function SourceMapConsumer_originalPositionFor(aArgs) {\n    var needle = {\n      generatedLine: util.getArg(aArgs, 'line'),\n      generatedColumn: util.getArg(aArgs, 'column')\n    };\n\n    var index = this._findMapping(\n      needle,\n      this._generatedMappings,\n      \"generatedLine\",\n      \"generatedColumn\",\n      util.compareByGeneratedPositionsDeflated,\n      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)\n    );\n\n    if (index >= 0) {\n      var mapping = this._generatedMappings[index];\n\n      if (mapping.generatedLine === needle.generatedLine) {\n        var source = util.getArg(mapping, 'source', null);\n        if (source !== null) {\n          source = this._sources.at(source);\n          if (this.sourceRoot != null) {\n            source = util.join(this.sourceRoot, source);\n          }\n        }\n        var name = util.getArg(mapping, 'name', null);\n        if (name !== null) {\n          name = this._names.at(name);\n        }\n        return {\n          source: source,\n          line: util.getArg(mapping, 'originalLine', null),\n          column: util.getArg(mapping, 'originalColumn', null),\n          name: name\n        };\n      }\n    }\n\n    return {\n      source: null,\n      line: null,\n      column: null,\n      name: null\n    };\n  };\n\n/**\n * Return true if we have the source content for every source in the source\n * map, false otherwise.\n */\nBasicSourceMapConsumer.prototype.hasContentsOfAllSources =\n  function BasicSourceMapConsumer_hasContentsOfAllSources() {\n    if (!this.sourcesContent) {\n      return false;\n    }\n    return this.sourcesContent.length >= this._sources.size() &&\n      !this.sourcesContent.some(function (sc) { return sc == null; });\n  };\n\n/**\n * Returns the original source content. The only argument is the url of the\n * original source file. Returns null if no original source content is\n * available.\n */\nBasicSourceMapConsumer.prototype.sourceContentFor =\n  function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {\n    if (!this.sourcesContent) {\n      return null;\n    }\n\n    if (this.sourceRoot != null) {\n      aSource = util.relative(this.sourceRoot, aSource);\n    }\n\n    if (this._sources.has(aSource)) {\n      return this.sourcesContent[this._sources.indexOf(aSource)];\n    }\n\n    var url;\n    if (this.sourceRoot != null\n        && (url = util.urlParse(this.sourceRoot))) {\n      // XXX: file:// URIs and absolute paths lead to unexpected behavior for\n      // many users. We can help them out when they expect file:// URIs to\n      // behave like it would if they were running a local HTTP server. See\n      // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.\n      var fileUriAbsPath = aSource.replace(/^file:\\/\\//, \"\");\n      if (url.scheme == \"file\"\n          && this._sources.has(fileUriAbsPath)) {\n        return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]\n      }\n\n      if ((!url.path || url.path == \"/\")\n          && this._sources.has(\"/\" + aSource)) {\n        return this.sourcesContent[this._sources.indexOf(\"/\" + aSource)];\n      }\n    }\n\n    // This function is used recursively from\n    // IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we\n    // don't want to throw if we can't find the source - we just want to\n    // return null, so we provide a flag to exit gracefully.\n    if (nullOnMissing) {\n      return null;\n    }\n    else {\n      throw new Error('\"' + aSource + '\" is not in the SourceMap.');\n    }\n  };\n\n/**\n * Returns the generated line and column information for the original source,\n * line, and column positions provided. The only argument is an object with\n * the following properties:\n *\n *   - source: The filename of the original source.\n *   - line: The line number in the original source.\n *   - column: The column number in the original source.\n *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or\n *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the\n *     closest element that is smaller than or greater than the one we are\n *     searching for, respectively, if the exact element cannot be found.\n *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.\n *\n * and an object is returned with the following properties:\n *\n *   - line: The line number in the generated source, or null.\n *   - column: The column number in the generated source, or null.\n */\nBasicSourceMapConsumer.prototype.generatedPositionFor =\n  function SourceMapConsumer_generatedPositionFor(aArgs) {\n    var source = util.getArg(aArgs, 'source');\n    if (this.sourceRoot != null) {\n      source = util.relative(this.sourceRoot, source);\n    }\n    if (!this._sources.has(source)) {\n      return {\n        line: null,\n        column: null,\n        lastColumn: null\n      };\n    }\n    source = this._sources.indexOf(source);\n\n    var needle = {\n      source: source,\n      originalLine: util.getArg(aArgs, 'line'),\n      originalColumn: util.getArg(aArgs, 'column')\n    };\n\n    var index = this._findMapping(\n      needle,\n      this._originalMappings,\n      \"originalLine\",\n      \"originalColumn\",\n      util.compareByOriginalPositions,\n      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)\n    );\n\n    if (index >= 0) {\n      var mapping = this._originalMappings[index];\n\n      if (mapping.source === needle.source) {\n        return {\n          line: util.getArg(mapping, 'generatedLine', null),\n          column: util.getArg(mapping, 'generatedColumn', null),\n          lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n        };\n      }\n    }\n\n    return {\n      line: null,\n      column: null,\n      lastColumn: null\n    };\n  };\n\nexports.BasicSourceMapConsumer = BasicSourceMapConsumer;\n\n/**\n * An IndexedSourceMapConsumer instance represents a parsed source map which\n * we can query for information. It differs from BasicSourceMapConsumer in\n * that it takes \"indexed\" source maps (i.e. ones with a \"sections\" field) as\n * input.\n *\n * The only parameter is a raw source map (either as a JSON string, or already\n * parsed to an object). According to the spec for indexed source maps, they\n * have the following attributes:\n *\n *   - version: Which version of the source map spec this map is following.\n *   - file: Optional. The generated file this source map is associated with.\n *   - sections: A list of section definitions.\n *\n * Each value under the \"sections\" field has two fields:\n *   - offset: The offset into the original specified at which this section\n *       begins to apply, defined as an object with a \"line\" and \"column\"\n *       field.\n *   - map: A source map definition. This source map could also be indexed,\n *       but doesn't have to be.\n *\n * Instead of the \"map\" field, it's also possible to have a \"url\" field\n * specifying a URL to retrieve a source map from, but that's currently\n * unsupported.\n *\n * Here's an example source map, taken from the source map spec[0], but\n * modified to omit a section which uses the \"url\" field.\n *\n *  {\n *    version : 3,\n *    file: \"app.js\",\n *    sections: [{\n *      offset: {line:100, column:10},\n *      map: {\n *        version : 3,\n *        file: \"section.js\",\n *        sources: [\"foo.js\", \"bar.js\"],\n *        names: [\"src\", \"maps\", \"are\", \"fun\"],\n *        mappings: \"AAAA,E;;ABCDE;\"\n *      }\n *    }],\n *  }\n *\n * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt\n */\nfunction IndexedSourceMapConsumer(aSourceMap) {\n  var sourceMap = aSourceMap;\n  if (typeof aSourceMap === 'string') {\n    sourceMap = JSON.parse(aSourceMap.replace(/^\\)\\]\\}'/, ''));\n  }\n\n  var version = util.getArg(sourceMap, 'version');\n  var sections = util.getArg(sourceMap, 'sections');\n\n  if (version != this._version) {\n    throw new Error('Unsupported version: ' + version);\n  }\n\n  this._sources = new ArraySet();\n  this._names = new ArraySet();\n\n  var lastOffset = {\n    line: -1,\n    column: 0\n  };\n  this._sections = sections.map(function (s) {\n    if (s.url) {\n      // The url field will require support for asynchronicity.\n      // See https://github.com/mozilla/source-map/issues/16\n      throw new Error('Support for url field in sections not implemented.');\n    }\n    var offset = util.getArg(s, 'offset');\n    var offsetLine = util.getArg(offset, 'line');\n    var offsetColumn = util.getArg(offset, 'column');\n\n    if (offsetLine < lastOffset.line ||\n        (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {\n      throw new Error('Section offsets must be ordered and non-overlapping.');\n    }\n    lastOffset = offset;\n\n    return {\n      generatedOffset: {\n        // The offset fields are 0-based, but we use 1-based indices when\n        // encoding/decoding from VLQ.\n        generatedLine: offsetLine + 1,\n        generatedColumn: offsetColumn + 1\n      },\n      consumer: new SourceMapConsumer(util.getArg(s, 'map'))\n    }\n  });\n}\n\nIndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);\nIndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;\n\n/**\n * The version of the source mapping spec that we are consuming.\n */\nIndexedSourceMapConsumer.prototype._version = 3;\n\n/**\n * The list of original sources.\n */\nObject.defineProperty(IndexedSourceMapConsumer.prototype, 'sources', {\n  get: function () {\n    var sources = [];\n    for (var i = 0; i < this._sections.length; i++) {\n      for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {\n        sources.push(this._sections[i].consumer.sources[j]);\n      }\n    }\n    return sources;\n  }\n});\n\n/**\n * Returns the original source, line, and column information for the generated\n * source's line and column positions provided. The only argument is an object\n * with the following properties:\n *\n *   - line: The line number in the generated source.\n *   - column: The column number in the generated source.\n *\n * and an object is returned with the following properties:\n *\n *   - source: The original source file, or null.\n *   - line: The line number in the original source, or null.\n *   - column: The column number in the original source, or null.\n *   - name: The original identifier, or null.\n */\nIndexedSourceMapConsumer.prototype.originalPositionFor =\n  function IndexedSourceMapConsumer_originalPositionFor(aArgs) {\n    var needle = {\n      generatedLine: util.getArg(aArgs, 'line'),\n      generatedColumn: util.getArg(aArgs, 'column')\n    };\n\n    // Find the section containing the generated position we're trying to map\n    // to an original position.\n    var sectionIndex = binarySearch.search(needle, this._sections,\n      function(needle, section) {\n        var cmp = needle.generatedLine - section.generatedOffset.generatedLine;\n        if (cmp) {\n          return cmp;\n        }\n\n        return (needle.generatedColumn -\n                section.generatedOffset.generatedColumn);\n      });\n    var section = this._sections[sectionIndex];\n\n    if (!section) {\n      return {\n        source: null,\n        line: null,\n        column: null,\n        name: null\n      };\n    }\n\n    return section.consumer.originalPositionFor({\n      line: needle.generatedLine -\n        (section.generatedOffset.generatedLine - 1),\n      column: needle.generatedColumn -\n        (section.generatedOffset.generatedLine === needle.generatedLine\n         ? section.generatedOffset.generatedColumn - 1\n         : 0),\n      bias: aArgs.bias\n    });\n  };\n\n/**\n * Return true if we have the source content for every source in the source\n * map, false otherwise.\n */\nIndexedSourceMapConsumer.prototype.hasContentsOfAllSources =\n  function IndexedSourceMapConsumer_hasContentsOfAllSources() {\n    return this._sections.every(function (s) {\n      return s.consumer.hasContentsOfAllSources();\n    });\n  };\n\n/**\n * Returns the original source content. The only argument is the url of the\n * original source file. Returns null if no original source content is\n * available.\n */\nIndexedSourceMapConsumer.prototype.sourceContentFor =\n  function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {\n    for (var i = 0; i < this._sections.length; i++) {\n      var section = this._sections[i];\n\n      var content = section.consumer.sourceContentFor(aSource, true);\n      if (content) {\n        return content;\n      }\n    }\n    if (nullOnMissing) {\n      return null;\n    }\n    else {\n      throw new Error('\"' + aSource + '\" is not in the SourceMap.');\n    }\n  };\n\n/**\n * Returns the generated line and column information for the original source,\n * line, and column positions provided. The only argument is an object with\n * the following properties:\n *\n *   - source: The filename of the original source.\n *   - line: The line number in the original source.\n *   - column: The column number in the original source.\n *\n * and an object is returned with the following properties:\n *\n *   - line: The line number in the generated source, or null.\n *   - column: The column number in the generated source, or null.\n */\nIndexedSourceMapConsumer.prototype.generatedPositionFor =\n  function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {\n    for (var i = 0; i < this._sections.length; i++) {\n      var section = this._sections[i];\n\n      // Only consider this section if the requested source is in the list of\n      // sources of the consumer.\n      if (section.consumer.sources.indexOf(util.getArg(aArgs, 'source')) === -1) {\n        continue;\n      }\n      var generatedPosition = section.consumer.generatedPositionFor(aArgs);\n      if (generatedPosition) {\n        var ret = {\n          line: generatedPosition.line +\n            (section.generatedOffset.generatedLine - 1),\n          column: generatedPosition.column +\n            (section.generatedOffset.generatedLine === generatedPosition.line\n             ? section.generatedOffset.generatedColumn - 1\n             : 0)\n        };\n        return ret;\n      }\n    }\n\n    return {\n      line: null,\n      column: null\n    };\n  };\n\n/**\n * Parse the mappings in a string in to a data structure which we can easily\n * query (the ordered arrays in the `this.__generatedMappings` and\n * `this.__originalMappings` properties).\n */\nIndexedSourceMapConsumer.prototype._parseMappings =\n  function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n    this.__generatedMappings = [];\n    this.__originalMappings = [];\n    for (var i = 0; i < this._sections.length; i++) {\n      var section = this._sections[i];\n      var sectionMappings = section.consumer._generatedMappings;\n      for (var j = 0; j < sectionMappings.length; j++) {\n        var mapping = sectionMappings[j];\n\n        var source = section.consumer._sources.at(mapping.source);\n        if (section.consumer.sourceRoot !== null) {\n          source = util.join(section.consumer.sourceRoot, source);\n        }\n        this._sources.add(source);\n        source = this._sources.indexOf(source);\n\n        var name = section.consumer._names.at(mapping.name);\n        this._names.add(name);\n        name = this._names.indexOf(name);\n\n        // The mappings coming from the consumer for the section have\n        // generated positions relative to the start of the section, so we\n        // need to offset them to be relative to the start of the concatenated\n        // generated file.\n        var adjustedMapping = {\n          source: source,\n          generatedLine: mapping.generatedLine +\n            (section.generatedOffset.generatedLine - 1),\n          generatedColumn: mapping.generatedColumn +\n            (section.generatedOffset.generatedLine === mapping.generatedLine\n            ? section.generatedOffset.generatedColumn - 1\n            : 0),\n          originalLine: mapping.originalLine,\n          originalColumn: mapping.originalColumn,\n          name: name\n        };\n\n        this.__generatedMappings.push(adjustedMapping);\n        if (typeof adjustedMapping.originalLine === 'number') {\n          this.__originalMappings.push(adjustedMapping);\n        }\n      }\n    }\n\n    quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);\n    quickSort(this.__originalMappings, util.compareByOriginalPositions);\n  };\n\nexports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/source-map-consumer.js\n// module id = 7\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nexports.GREATEST_LOWER_BOUND = 1;\nexports.LEAST_UPPER_BOUND = 2;\n\n/**\n * Recursive implementation of binary search.\n *\n * @param aLow Indices here and lower do not contain the needle.\n * @param aHigh Indices here and higher do not contain the needle.\n * @param aNeedle The element being searched for.\n * @param aHaystack The non-empty array being searched.\n * @param aCompare Function which takes two elements and returns -1, 0, or 1.\n * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or\n *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the\n *     closest element that is smaller than or greater than the one we are\n *     searching for, respectively, if the exact element cannot be found.\n */\nfunction recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {\n  // This function terminates when one of the following is true:\n  //\n  //   1. We find the exact element we are looking for.\n  //\n  //   2. We did not find the exact element, but we can return the index of\n  //      the next-closest element.\n  //\n  //   3. We did not find the exact element, and there is no next-closest\n  //      element than the one we are searching for, so we return -1.\n  var mid = Math.floor((aHigh - aLow) / 2) + aLow;\n  var cmp = aCompare(aNeedle, aHaystack[mid], true);\n  if (cmp === 0) {\n    // Found the element we are looking for.\n    return mid;\n  }\n  else if (cmp > 0) {\n    // Our needle is greater than aHaystack[mid].\n    if (aHigh - mid > 1) {\n      // The element is in the upper half.\n      return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);\n    }\n\n    // The exact needle element was not found in this haystack. Determine if\n    // we are in termination case (3) or (2) and return the appropriate thing.\n    if (aBias == exports.LEAST_UPPER_BOUND) {\n      return aHigh < aHaystack.length ? aHigh : -1;\n    } else {\n      return mid;\n    }\n  }\n  else {\n    // Our needle is less than aHaystack[mid].\n    if (mid - aLow > 1) {\n      // The element is in the lower half.\n      return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);\n    }\n\n    // we are in termination case (3) or (2) and return the appropriate thing.\n    if (aBias == exports.LEAST_UPPER_BOUND) {\n      return mid;\n    } else {\n      return aLow < 0 ? -1 : aLow;\n    }\n  }\n}\n\n/**\n * This is an implementation of binary search which will always try and return\n * the index of the closest element if there is no exact hit. This is because\n * mappings between original and generated line/col pairs are single points,\n * and there is an implicit region between each of them, so a miss just means\n * that you aren't on the very start of a region.\n *\n * @param aNeedle The element you are looking for.\n * @param aHaystack The array that is being searched.\n * @param aCompare A function which takes the needle and an element in the\n *     array and returns -1, 0, or 1 depending on whether the needle is less\n *     than, equal to, or greater than the element, respectively.\n * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or\n *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the\n *     closest element that is smaller than or greater than the one we are\n *     searching for, respectively, if the exact element cannot be found.\n *     Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.\n */\nexports.search = function search(aNeedle, aHaystack, aCompare, aBias) {\n  if (aHaystack.length === 0) {\n    return -1;\n  }\n\n  var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack,\n                              aCompare, aBias || exports.GREATEST_LOWER_BOUND);\n  if (index < 0) {\n    return -1;\n  }\n\n  // We have found either the exact element, or the next-closest element than\n  // the one we are searching for. However, there may be more than one such\n  // element. Make sure we always return the smallest of these.\n  while (index - 1 >= 0) {\n    if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {\n      break;\n    }\n    --index;\n  }\n\n  return index;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/binary-search.js\n// module id = 8\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\n// It turns out that some (most?) JavaScript engines don't self-host\n// `Array.prototype.sort`. This makes sense because C++ will likely remain\n// faster than JS when doing raw CPU-intensive sorting. However, when using a\n// custom comparator function, calling back and forth between the VM's C++ and\n// JIT'd JS is rather slow *and* loses JIT type information, resulting in\n// worse generated code for the comparator function than would be optimal. In\n// fact, when sorting with a comparator, these costs outweigh the benefits of\n// sorting in C++. By using our own JS-implemented Quick Sort (below), we get\n// a ~3500ms mean speed-up in `bench/bench.html`.\n\n/**\n * Swap the elements indexed by `x` and `y` in the array `ary`.\n *\n * @param {Array} ary\n *        The array.\n * @param {Number} x\n *        The index of the first item.\n * @param {Number} y\n *        The index of the second item.\n */\nfunction swap(ary, x, y) {\n  var temp = ary[x];\n  ary[x] = ary[y];\n  ary[y] = temp;\n}\n\n/**\n * Returns a random integer within the range `low .. high` inclusive.\n *\n * @param {Number} low\n *        The lower bound on the range.\n * @param {Number} high\n *        The upper bound on the range.\n */\nfunction randomIntInRange(low, high) {\n  return Math.round(low + (Math.random() * (high - low)));\n}\n\n/**\n * The Quick Sort algorithm.\n *\n * @param {Array} ary\n *        An array to sort.\n * @param {function} comparator\n *        Function to use to compare two items.\n * @param {Number} p\n *        Start index of the array\n * @param {Number} r\n *        End index of the array\n */\nfunction doQuickSort(ary, comparator, p, r) {\n  // If our lower bound is less than our upper bound, we (1) partition the\n  // array into two pieces and (2) recurse on each half. If it is not, this is\n  // the empty array and our base case.\n\n  if (p < r) {\n    // (1) Partitioning.\n    //\n    // The partitioning chooses a pivot between `p` and `r` and moves all\n    // elements that are less than or equal to the pivot to the before it, and\n    // all the elements that are greater than it after it. The effect is that\n    // once partition is done, the pivot is in the exact place it will be when\n    // the array is put in sorted order, and it will not need to be moved\n    // again. This runs in O(n) time.\n\n    // Always choose a random pivot so that an input array which is reverse\n    // sorted does not cause O(n^2) running time.\n    var pivotIndex = randomIntInRange(p, r);\n    var i = p - 1;\n\n    swap(ary, pivotIndex, r);\n    var pivot = ary[r];\n\n    // Immediately after `j` is incremented in this loop, the following hold\n    // true:\n    //\n    //   * Every element in `ary[p .. i]` is less than or equal to the pivot.\n    //\n    //   * Every element in `ary[i+1 .. j-1]` is greater than the pivot.\n    for (var j = p; j < r; j++) {\n      if (comparator(ary[j], pivot) <= 0) {\n        i += 1;\n        swap(ary, i, j);\n      }\n    }\n\n    swap(ary, i + 1, j);\n    var q = i + 1;\n\n    // (2) Recurse on each half.\n\n    doQuickSort(ary, comparator, p, q - 1);\n    doQuickSort(ary, comparator, q + 1, r);\n  }\n}\n\n/**\n * Sort the given array in-place with the given comparator function.\n *\n * @param {Array} ary\n *        An array to sort.\n * @param {function} comparator\n *        Function to use to compare two items.\n */\nexports.quickSort = function (ary, comparator) {\n  doQuickSort(ary, comparator, 0, ary.length - 1);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/quick-sort.js\n// module id = 9\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar SourceMapGenerator = require('./source-map-generator').SourceMapGenerator;\nvar util = require('./util');\n\n// Matches a Windows-style `\\r\\n` newline or a `\\n` newline used by all other\n// operating systems these days (capturing the result).\nvar REGEX_NEWLINE = /(\\r?\\n)/;\n\n// Newline character code for charCodeAt() comparisons\nvar NEWLINE_CODE = 10;\n\n// Private symbol for identifying `SourceNode`s when multiple versions of\n// the source-map library are loaded. This MUST NOT CHANGE across\n// versions!\nvar isSourceNode = \"$$$isSourceNode$$$\";\n\n/**\n * SourceNodes provide a way to abstract over interpolating/concatenating\n * snippets of generated JavaScript source code while maintaining the line and\n * column information associated with the original source code.\n *\n * @param aLine The original line number.\n * @param aColumn The original column number.\n * @param aSource The original source's filename.\n * @param aChunks Optional. An array of strings which are snippets of\n *        generated JS, or other SourceNodes.\n * @param aName The original identifier.\n */\nfunction SourceNode(aLine, aColumn, aSource, aChunks, aName) {\n  this.children = [];\n  this.sourceContents = {};\n  this.line = aLine == null ? null : aLine;\n  this.column = aColumn == null ? null : aColumn;\n  this.source = aSource == null ? null : aSource;\n  this.name = aName == null ? null : aName;\n  this[isSourceNode] = true;\n  if (aChunks != null) this.add(aChunks);\n}\n\n/**\n * Creates a SourceNode from generated code and a SourceMapConsumer.\n *\n * @param aGeneratedCode The generated code\n * @param aSourceMapConsumer The SourceMap for the generated code\n * @param aRelativePath Optional. The path that relative sources in the\n *        SourceMapConsumer should be relative to.\n */\nSourceNode.fromStringWithSourceMap =\n  function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {\n    // The SourceNode we want to fill with the generated code\n    // and the SourceMap\n    var node = new SourceNode();\n\n    // All even indices of this array are one line of the generated code,\n    // while all odd indices are the newlines between two adjacent lines\n    // (since `REGEX_NEWLINE` captures its match).\n    // Processed fragments are accessed by calling `shiftNextLine`.\n    var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);\n    var remainingLinesIndex = 0;\n    var shiftNextLine = function() {\n      var lineContents = getNextLine();\n      // The last line of a file might not have a newline.\n      var newLine = getNextLine() || \"\";\n      return lineContents + newLine;\n\n      function getNextLine() {\n        return remainingLinesIndex < remainingLines.length ?\n            remainingLines[remainingLinesIndex++] : undefined;\n      }\n    };\n\n    // We need to remember the position of \"remainingLines\"\n    var lastGeneratedLine = 1, lastGeneratedColumn = 0;\n\n    // The generate SourceNodes we need a code range.\n    // To extract it current and last mapping is used.\n    // Here we store the last mapping.\n    var lastMapping = null;\n\n    aSourceMapConsumer.eachMapping(function (mapping) {\n      if (lastMapping !== null) {\n        // We add the code from \"lastMapping\" to \"mapping\":\n        // First check if there is a new line in between.\n        if (lastGeneratedLine < mapping.generatedLine) {\n          // Associate first line with \"lastMapping\"\n          addMappingWithCode(lastMapping, shiftNextLine());\n          lastGeneratedLine++;\n          lastGeneratedColumn = 0;\n          // The remaining code is added without mapping\n        } else {\n          // There is no new line in between.\n          // Associate the code between \"lastGeneratedColumn\" and\n          // \"mapping.generatedColumn\" with \"lastMapping\"\n          var nextLine = remainingLines[remainingLinesIndex];\n          var code = nextLine.substr(0, mapping.generatedColumn -\n                                        lastGeneratedColumn);\n          remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn -\n                                              lastGeneratedColumn);\n          lastGeneratedColumn = mapping.generatedColumn;\n          addMappingWithCode(lastMapping, code);\n          // No more remaining code, continue\n          lastMapping = mapping;\n          return;\n        }\n      }\n      // We add the generated code until the first mapping\n      // to the SourceNode without any mapping.\n      // Each line is added as separate string.\n      while (lastGeneratedLine < mapping.generatedLine) {\n        node.add(shiftNextLine());\n        lastGeneratedLine++;\n      }\n      if (lastGeneratedColumn < mapping.generatedColumn) {\n        var nextLine = remainingLines[remainingLinesIndex];\n        node.add(nextLine.substr(0, mapping.generatedColumn));\n        remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);\n        lastGeneratedColumn = mapping.generatedColumn;\n      }\n      lastMapping = mapping;\n    }, this);\n    // We have processed all mappings.\n    if (remainingLinesIndex < remainingLines.length) {\n      if (lastMapping) {\n        // Associate the remaining code in the current line with \"lastMapping\"\n        addMappingWithCode(lastMapping, shiftNextLine());\n      }\n      // and add the remaining lines without any mapping\n      node.add(remainingLines.splice(remainingLinesIndex).join(\"\"));\n    }\n\n    // Copy sourcesContent into SourceNode\n    aSourceMapConsumer.sources.forEach(function (sourceFile) {\n      var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n      if (content != null) {\n        if (aRelativePath != null) {\n          sourceFile = util.join(aRelativePath, sourceFile);\n        }\n        node.setSourceContent(sourceFile, content);\n      }\n    });\n\n    return node;\n\n    function addMappingWithCode(mapping, code) {\n      if (mapping === null || mapping.source === undefined) {\n        node.add(code);\n      } else {\n        var source = aRelativePath\n          ? util.join(aRelativePath, mapping.source)\n          : mapping.source;\n        node.add(new SourceNode(mapping.originalLine,\n                                mapping.originalColumn,\n                                source,\n                                code,\n                                mapping.name));\n      }\n    }\n  };\n\n/**\n * Add a chunk of generated JS to this source node.\n *\n * @param aChunk A string snippet of generated JS code, another instance of\n *        SourceNode, or an array where each member is one of those things.\n */\nSourceNode.prototype.add = function SourceNode_add(aChunk) {\n  if (Array.isArray(aChunk)) {\n    aChunk.forEach(function (chunk) {\n      this.add(chunk);\n    }, this);\n  }\n  else if (aChunk[isSourceNode] || typeof aChunk === \"string\") {\n    if (aChunk) {\n      this.children.push(aChunk);\n    }\n  }\n  else {\n    throw new TypeError(\n      \"Expected a SourceNode, string, or an array of SourceNodes and strings. Got \" + aChunk\n    );\n  }\n  return this;\n};\n\n/**\n * Add a chunk of generated JS to the beginning of this source node.\n *\n * @param aChunk A string snippet of generated JS code, another instance of\n *        SourceNode, or an array where each member is one of those things.\n */\nSourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {\n  if (Array.isArray(aChunk)) {\n    for (var i = aChunk.length-1; i >= 0; i--) {\n      this.prepend(aChunk[i]);\n    }\n  }\n  else if (aChunk[isSourceNode] || typeof aChunk === \"string\") {\n    this.children.unshift(aChunk);\n  }\n  else {\n    throw new TypeError(\n      \"Expected a SourceNode, string, or an array of SourceNodes and strings. Got \" + aChunk\n    );\n  }\n  return this;\n};\n\n/**\n * Walk over the tree of JS snippets in this node and its children. The\n * walking function is called once for each snippet of JS and is passed that\n * snippet and the its original associated source's line/column location.\n *\n * @param aFn The traversal function.\n */\nSourceNode.prototype.walk = function SourceNode_walk(aFn) {\n  var chunk;\n  for (var i = 0, len = this.children.length; i < len; i++) {\n    chunk = this.children[i];\n    if (chunk[isSourceNode]) {\n      chunk.walk(aFn);\n    }\n    else {\n      if (chunk !== '') {\n        aFn(chunk, { source: this.source,\n                     line: this.line,\n                     column: this.column,\n                     name: this.name });\n      }\n    }\n  }\n};\n\n/**\n * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between\n * each of `this.children`.\n *\n * @param aSep The separator.\n */\nSourceNode.prototype.join = function SourceNode_join(aSep) {\n  var newChildren;\n  var i;\n  var len = this.children.length;\n  if (len > 0) {\n    newChildren = [];\n    for (i = 0; i < len-1; i++) {\n      newChildren.push(this.children[i]);\n      newChildren.push(aSep);\n    }\n    newChildren.push(this.children[i]);\n    this.children = newChildren;\n  }\n  return this;\n};\n\n/**\n * Call String.prototype.replace on the very right-most source snippet. Useful\n * for trimming whitespace from the end of a source node, etc.\n *\n * @param aPattern The pattern to replace.\n * @param aReplacement The thing to replace the pattern with.\n */\nSourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {\n  var lastChild = this.children[this.children.length - 1];\n  if (lastChild[isSourceNode]) {\n    lastChild.replaceRight(aPattern, aReplacement);\n  }\n  else if (typeof lastChild === 'string') {\n    this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);\n  }\n  else {\n    this.children.push(''.replace(aPattern, aReplacement));\n  }\n  return this;\n};\n\n/**\n * Set the source content for a source file. This will be added to the SourceMapGenerator\n * in the sourcesContent field.\n *\n * @param aSourceFile The filename of the source file\n * @param aSourceContent The content of the source file\n */\nSourceNode.prototype.setSourceContent =\n  function SourceNode_setSourceContent(aSourceFile, aSourceContent) {\n    this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;\n  };\n\n/**\n * Walk over the tree of SourceNodes. The walking function is called for each\n * source file content and is passed the filename and source content.\n *\n * @param aFn The traversal function.\n */\nSourceNode.prototype.walkSourceContents =\n  function SourceNode_walkSourceContents(aFn) {\n    for (var i = 0, len = this.children.length; i < len; i++) {\n      if (this.children[i][isSourceNode]) {\n        this.children[i].walkSourceContents(aFn);\n      }\n    }\n\n    var sources = Object.keys(this.sourceContents);\n    for (var i = 0, len = sources.length; i < len; i++) {\n      aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);\n    }\n  };\n\n/**\n * Return the string representation of this source node. Walks over the tree\n * and concatenates all the various snippets together to one string.\n */\nSourceNode.prototype.toString = function SourceNode_toString() {\n  var str = \"\";\n  this.walk(function (chunk) {\n    str += chunk;\n  });\n  return str;\n};\n\n/**\n * Returns the string representation of this source node along with a source\n * map.\n */\nSourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {\n  var generated = {\n    code: \"\",\n    line: 1,\n    column: 0\n  };\n  var map = new SourceMapGenerator(aArgs);\n  var sourceMappingActive = false;\n  var lastOriginalSource = null;\n  var lastOriginalLine = null;\n  var lastOriginalColumn = null;\n  var lastOriginalName = null;\n  this.walk(function (chunk, original) {\n    generated.code += chunk;\n    if (original.source !== null\n        && original.line !== null\n        && original.column !== null) {\n      if(lastOriginalSource !== original.source\n         || lastOriginalLine !== original.line\n         || lastOriginalColumn !== original.column\n         || lastOriginalName !== original.name) {\n        map.addMapping({\n          source: original.source,\n          original: {\n            line: original.line,\n            column: original.column\n          },\n          generated: {\n            line: generated.line,\n            column: generated.column\n          },\n          name: original.name\n        });\n      }\n      lastOriginalSource = original.source;\n      lastOriginalLine = original.line;\n      lastOriginalColumn = original.column;\n      lastOriginalName = original.name;\n      sourceMappingActive = true;\n    } else if (sourceMappingActive) {\n      map.addMapping({\n        generated: {\n          line: generated.line,\n          column: generated.column\n        }\n      });\n      lastOriginalSource = null;\n      sourceMappingActive = false;\n    }\n    for (var idx = 0, length = chunk.length; idx < length; idx++) {\n      if (chunk.charCodeAt(idx) === NEWLINE_CODE) {\n        generated.line++;\n        generated.column = 0;\n        // Mappings end at eol\n        if (idx + 1 === length) {\n          lastOriginalSource = null;\n          sourceMappingActive = false;\n        } else if (sourceMappingActive) {\n          map.addMapping({\n            source: original.source,\n            original: {\n              line: original.line,\n              column: original.column\n            },\n            generated: {\n              line: generated.line,\n              column: generated.column\n            },\n            name: original.name\n          });\n        }\n      } else {\n        generated.column++;\n      }\n    }\n  });\n  this.walkSourceContents(function (sourceFile, sourceContent) {\n    map.setSourceContent(sourceFile, sourceContent);\n  });\n\n  return { code: generated.code, map: map };\n};\n\nexports.SourceNode = SourceNode;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/source-node.js\n// module id = 10\n// module chunks = 0"],"sourceRoot":""}
\ No newline at end of file
diff --git a/node_modules/@babel/generator/node_modules/source-map/dist/source-map.js b/node_modules/@babel/generator/node_modules/source-map/dist/source-map.js
new file mode 100644
index 00000000..4e630e29
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/source-map/dist/source-map.js
@@ -0,0 +1,3090 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], 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) {
+	    // When aOriginal is truthy but has empty values for .line and .column,
+	    // it is most likely a programmer error. In this case we throw a very
+	    // specific error message to try to guide them the right way.
+	    // For example: https://github.com/Polymer/polymer-bundler/pull/519
+	    if (aOriginal && typeof aOriginal.line !== 'number' && typeof aOriginal.column !== 'number') {
+	        throw new Error(
+	            'original.line and original.column are not numbers -- you probably meant to omit ' +
+	            'the original mapping entirely and only map the generated position. If so, pass ' +
+	            'null for the original mapping instead of an object with empty or null values.'
+	        );
+	    }
+
+	    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 consecutive 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;
+	var hasNativeMap = typeof Map !== "undefined";
+
+	/**
+	 * 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 = hasNativeMap ? new Map() : 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 hasNativeMap ? this._set.size : 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 = hasNativeMap ? aStr : util.toSetString(aStr);
+	  var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
+	  var idx = this._array.length;
+	  if (!isDuplicate || aAllowDuplicates) {
+	    this._array.push(aStr);
+	  }
+	  if (!isDuplicate) {
+	    if (hasNativeMap) {
+	      this._set.set(aStr, idx);
+	    } else {
+	      this._set[sStr] = idx;
+	    }
+	  }
+	};
+
+	/**
+	 * Is the given string a member of this set?
+	 *
+	 * @param String aStr
+	 */
+	ArraySet.prototype.has = function ArraySet_has(aStr) {
+	  if (hasNativeMap) {
+	    return this._set.has(aStr);
+	  } else {
+	    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) {
+	  if (hasNativeMap) {
+	    var idx = this._set.get(aStr);
+	    if (idx >= 0) {
+	        return idx;
+	    }
+	  } else {
+	    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 accessed by calling `shiftNextLine`.
+	    var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
+	    var remainingLinesIndex = 0;
+	    var shiftNextLine = function() {
+	      var lineContents = getNextLine();
+	      // The last line of a file might not have a newline.
+	      var newLine = getNextLine() || "";
+	      return lineContents + newLine;
+
+	      function getNextLine() {
+	        return remainingLinesIndex < remainingLines.length ?
+	            remainingLines[remainingLinesIndex++] : undefined;
+	      }
+	    };
+
+	    // 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[remainingLinesIndex];
+	          var code = nextLine.substr(0, mapping.generatedColumn -
+	                                        lastGeneratedColumn);
+	          remainingLines[remainingLinesIndex] = 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[remainingLinesIndex];
+	        node.add(nextLine.substr(0, mapping.generatedColumn));
+	        remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
+	        lastGeneratedColumn = mapping.generatedColumn;
+	      }
+	      lastMapping = mapping;
+	    }, this);
+	    // We have processed all mappings.
+	    if (remainingLinesIndex < remainingLines.length) {
+	      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.splice(remainingLinesIndex).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) {
+	        node.add(code);
+	      } else {
+	        var source = aRelativePath
+	          ? util.join(aRelativePath, mapping.source)
+	          : mapping.source;
+	        node.add(new SourceNode(mapping.originalLine,
+	                                mapping.originalColumn,
+	                                source,
+	                                code,
+	                                mapping.name));
+	      }
+	    }
+	  };
+
+	/**
+	 * Add a chunk of generated JS to this source node.
+	 *
+	 * @param aChunk A string snippet of generated JS code, another instance of
+	 *        SourceNode, or an array where each member is one of those things.
+	 */
+	SourceNode.prototype.add = function SourceNode_add(aChunk) {
+	  if (Array.isArray(aChunk)) {
+	    aChunk.forEach(function (chunk) {
+	      this.add(chunk);
+	    }, this);
+	  }
+	  else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+	    if (aChunk) {
+	      this.children.push(aChunk);
+	    }
+	  }
+	  else {
+	    throw new TypeError(
+	      "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+	    );
+	  }
+	  return this;
+	};
+
+	/**
+	 * Add a chunk of generated JS to the beginning of this source node.
+	 *
+	 * @param aChunk A string snippet of generated JS code, another instance of
+	 *        SourceNode, or an array where each member is one of those things.
+	 */
+	SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
+	  if (Array.isArray(aChunk)) {
+	    for (var i = aChunk.length-1; i >= 0; i--) {
+	      this.prepend(aChunk[i]);
+	    }
+	  }
+	  else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+	    this.children.unshift(aChunk);
+	  }
+	  else {
+	    throw new TypeError(
+	      "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+	    );
+	  }
+	  return this;
+	};
+
+	/**
+	 * Walk over the tree of JS snippets in this node and its children. The
+	 * walking function is called once for each snippet of JS and is passed that
+	 * snippet and the its original associated source's line/column location.
+	 *
+	 * @param aFn The traversal function.
+	 */
+	SourceNode.prototype.walk = function SourceNode_walk(aFn) {
+	  var chunk;
+	  for (var i = 0, len = this.children.length; i < len; i++) {
+	    chunk = this.children[i];
+	    if (chunk[isSourceNode]) {
+	      chunk.walk(aFn);
+	    }
+	    else {
+	      if (chunk !== '') {
+	        aFn(chunk, { source: this.source,
+	                     line: this.line,
+	                     column: this.column,
+	                     name: this.name });
+	      }
+	    }
+	  }
+	};
+
+	/**
+	 * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
+	 * each of `this.children`.
+	 *
+	 * @param aSep The separator.
+	 */
+	SourceNode.prototype.join = function SourceNode_join(aSep) {
+	  var newChildren;
+	  var i;
+	  var len = this.children.length;
+	  if (len > 0) {
+	    newChildren = [];
+	    for (i = 0; i < len-1; i++) {
+	      newChildren.push(this.children[i]);
+	      newChildren.push(aSep);
+	    }
+	    newChildren.push(this.children[i]);
+	    this.children = newChildren;
+	  }
+	  return this;
+	};
+
+	/**
+	 * Call String.prototype.replace on the very right-most source snippet. Useful
+	 * for trimming whitespace from the end of a source node, etc.
+	 *
+	 * @param aPattern The pattern to replace.
+	 * @param aReplacement The thing to replace the pattern with.
+	 */
+	SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
+	  var lastChild = this.children[this.children.length - 1];
+	  if (lastChild[isSourceNode]) {
+	    lastChild.replaceRight(aPattern, aReplacement);
+	  }
+	  else if (typeof lastChild === 'string') {
+	    this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
+	  }
+	  else {
+	    this.children.push(''.replace(aPattern, aReplacement));
+	  }
+	  return this;
+	};
+
+	/**
+	 * Set the source content for a source file. This will be added to the SourceMapGenerator
+	 * in the sourcesContent field.
+	 *
+	 * @param aSourceFile The filename of the source file
+	 * @param aSourceContent The content of the source file
+	 */
+	SourceNode.prototype.setSourceContent =
+	  function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
+	    this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
+	  };
+
+	/**
+	 * Walk over the tree of SourceNodes. The walking function is called for each
+	 * source file content and is passed the filename and source content.
+	 *
+	 * @param aFn The traversal function.
+	 */
+	SourceNode.prototype.walkSourceContents =
+	  function SourceNode_walkSourceContents(aFn) {
+	    for (var i = 0, len = this.children.length; i < len; i++) {
+	      if (this.children[i][isSourceNode]) {
+	        this.children[i].walkSourceContents(aFn);
+	      }
+	    }
+
+	    var sources = Object.keys(this.sourceContents);
+	    for (var i = 0, len = sources.length; i < len; i++) {
+	      aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
+	    }
+	  };
+
+	/**
+	 * Return the string representation of this source node. Walks over the tree
+	 * and concatenates all the various snippets together to one string.
+	 */
+	SourceNode.prototype.toString = function SourceNode_toString() {
+	  var str = "";
+	  this.walk(function (chunk) {
+	    str += chunk;
+	  });
+	  return str;
+	};
+
+	/**
+	 * Returns the string representation of this source node along with a source
+	 * map.
+	 */
+	SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
+	  var generated = {
+	    code: "",
+	    line: 1,
+	    column: 0
+	  };
+	  var map = new SourceMapGenerator(aArgs);
+	  var sourceMappingActive = false;
+	  var lastOriginalSource = null;
+	  var lastOriginalLine = null;
+	  var lastOriginalColumn = null;
+	  var lastOriginalName = null;
+	  this.walk(function (chunk, original) {
+	    generated.code += chunk;
+	    if (original.source !== null
+	        && original.line !== null
+	        && original.column !== null) {
+	      if(lastOriginalSource !== original.source
+	         || lastOriginalLine !== original.line
+	         || lastOriginalColumn !== original.column
+	         || lastOriginalName !== original.name) {
+	        map.addMapping({
+	          source: original.source,
+	          original: {
+	            line: original.line,
+	            column: original.column
+	          },
+	          generated: {
+	            line: generated.line,
+	            column: generated.column
+	          },
+	          name: original.name
+	        });
+	      }
+	      lastOriginalSource = original.source;
+	      lastOriginalLine = original.line;
+	      lastOriginalColumn = original.column;
+	      lastOriginalName = original.name;
+	      sourceMappingActive = true;
+	    } else if (sourceMappingActive) {
+	      map.addMapping({
+	        generated: {
+	          line: generated.line,
+	          column: generated.column
+	        }
+	      });
+	      lastOriginalSource = null;
+	      sourceMappingActive = false;
+	    }
+	    for (var idx = 0, length = chunk.length; idx < length; idx++) {
+	      if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
+	        generated.line++;
+	        generated.column = 0;
+	        // Mappings end at eol
+	        if (idx + 1 === length) {
+	          lastOriginalSource = null;
+	          sourceMappingActive = false;
+	        } else if (sourceMappingActive) {
+	          map.addMapping({
+	            source: original.source,
+	            original: {
+	              line: original.line,
+	              column: original.column
+	            },
+	            generated: {
+	              line: generated.line,
+	              column: generated.column
+	            },
+	            name: original.name
+	          });
+	        }
+	      } else {
+	        generated.column++;
+	      }
+	    }
+	  });
+	  this.walkSourceContents(function (sourceFile, sourceContent) {
+	    map.setSourceContent(sourceFile, sourceContent);
+	  });
+
+	  return { code: generated.code, map: map };
+	};
+
+	exports.SourceNode = SourceNode;
+
+
+/***/ })
+/******/ ])
+});
+;
\ No newline at end of file
diff --git a/node_modules/@babel/generator/node_modules/source-map/dist/source-map.min.js b/node_modules/@babel/generator/node_modules/source-map/dist/source-map.min.js
new file mode 100644
index 00000000..f2a46bd0
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/source-map/dist/source-map.min.js
@@ -0,0 +1,2 @@
+!function(e,n){"object"==typeof exports&&"object"==typeof module?module.exports=n():"function"==typeof define&&define.amd?define([],n):"object"==typeof exports?exports.sourceMap=n():e.sourceMap=n()}(this,function(){return function(e){function n(t){if(r[t])return r[t].exports;var o=r[t]={exports:{},id:t,loaded:!1};return e[t].call(o.exports,o,o.exports,n),o.loaded=!0,o.exports}var r={};return n.m=e,n.c=r,n.p="",n(0)}([function(e,n,r){n.SourceMapGenerator=r(1).SourceMapGenerator,n.SourceMapConsumer=r(7).SourceMapConsumer,n.SourceNode=r(10).SourceNode},function(e,n,r){function t(e){e||(e={}),this._file=i.getArg(e,"file",null),this._sourceRoot=i.getArg(e,"sourceRoot",null),this._skipValidation=i.getArg(e,"skipValidation",!1),this._sources=new s,this._names=new s,this._mappings=new a,this._sourcesContents=null}var o=r(2),i=r(4),s=r(5).ArraySet,a=r(6).MappingList;t.prototype._version=3,t.fromSourceMap=function(e){var n=e.sourceRoot,r=new t({file:e.file,sourceRoot:n});return e.eachMapping(function(e){var t={generated:{line:e.generatedLine,column:e.generatedColumn}};null!=e.source&&(t.source=e.source,null!=n&&(t.source=i.relative(n,t.source)),t.original={line:e.originalLine,column:e.originalColumn},null!=e.name&&(t.name=e.name)),r.addMapping(t)}),e.sources.forEach(function(n){var t=e.sourceContentFor(n);null!=t&&r.setSourceContent(n,t)}),r},t.prototype.addMapping=function(e){var n=i.getArg(e,"generated"),r=i.getArg(e,"original",null),t=i.getArg(e,"source",null),o=i.getArg(e,"name",null);this._skipValidation||this._validateMapping(n,r,t,o),null!=t&&(t=String(t),this._sources.has(t)||this._sources.add(t)),null!=o&&(o=String(o),this._names.has(o)||this._names.add(o)),this._mappings.add({generatedLine:n.line,generatedColumn:n.column,originalLine:null!=r&&r.line,originalColumn:null!=r&&r.column,source:t,name:o})},t.prototype.setSourceContent=function(e,n){var r=e;null!=this._sourceRoot&&(r=i.relative(this._sourceRoot,r)),null!=n?(this._sourcesContents||(this._sourcesContents=Object.create(null)),this._sourcesContents[i.toSetString(r)]=n):this._sourcesContents&&(delete this._sourcesContents[i.toSetString(r)],0===Object.keys(this._sourcesContents).length&&(this._sourcesContents=null))},t.prototype.applySourceMap=function(e,n,r){var t=n;if(null==n){if(null==e.file)throw new Error('SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, or the source map\'s "file" property. Both were omitted.');t=e.file}var o=this._sourceRoot;null!=o&&(t=i.relative(o,t));var a=new s,u=new s;this._mappings.unsortedForEach(function(n){if(n.source===t&&null!=n.originalLine){var s=e.originalPositionFor({line:n.originalLine,column:n.originalColumn});null!=s.source&&(n.source=s.source,null!=r&&(n.source=i.join(r,n.source)),null!=o&&(n.source=i.relative(o,n.source)),n.originalLine=s.line,n.originalColumn=s.column,null!=s.name&&(n.name=s.name))}var l=n.source;null==l||a.has(l)||a.add(l);var c=n.name;null==c||u.has(c)||u.add(c)},this),this._sources=a,this._names=u,e.sources.forEach(function(n){var t=e.sourceContentFor(n);null!=t&&(null!=r&&(n=i.join(r,n)),null!=o&&(n=i.relative(o,n)),this.setSourceContent(n,t))},this)},t.prototype._validateMapping=function(e,n,r,t){if(n&&"number"!=typeof n.line&&"number"!=typeof n.column)throw new Error("original.line and original.column are not numbers -- you probably meant to omit the original mapping entirely and only map the generated position. If so, pass null for the original mapping instead of an object with empty or null values.");if((!(e&&"line"in e&&"column"in e&&e.line>0&&e.column>=0)||n||r||t)&&!(e&&"line"in e&&"column"in e&&n&&"line"in n&&"column"in n&&e.line>0&&e.column>=0&&n.line>0&&n.column>=0&&r))throw new Error("Invalid mapping: "+JSON.stringify({generated:e,source:r,original:n,name:t}))},t.prototype._serializeMappings=function(){for(var e,n,r,t,s=0,a=1,u=0,l=0,c=0,g=0,p="",h=this._mappings.toArray(),f=0,d=h.length;f<d;f++){if(n=h[f],e="",n.generatedLine!==a)for(s=0;n.generatedLine!==a;)e+=";",a++;else if(f>0){if(!i.compareByGeneratedPositionsInflated(n,h[f-1]))continue;e+=","}e+=o.encode(n.generatedColumn-s),s=n.generatedColumn,null!=n.source&&(t=this._sources.indexOf(n.source),e+=o.encode(t-g),g=t,e+=o.encode(n.originalLine-1-l),l=n.originalLine-1,e+=o.encode(n.originalColumn-u),u=n.originalColumn,null!=n.name&&(r=this._names.indexOf(n.name),e+=o.encode(r-c),c=r)),p+=e}return p},t.prototype._generateSourcesContent=function(e,n){return e.map(function(e){if(!this._sourcesContents)return null;null!=n&&(e=i.relative(n,e));var r=i.toSetString(e);return Object.prototype.hasOwnProperty.call(this._sourcesContents,r)?this._sourcesContents[r]:null},this)},t.prototype.toJSON=function(){var e={version:this._version,sources:this._sources.toArray(),names:this._names.toArray(),mappings:this._serializeMappings()};return null!=this._file&&(e.file=this._file),null!=this._sourceRoot&&(e.sourceRoot=this._sourceRoot),this._sourcesContents&&(e.sourcesContent=this._generateSourcesContent(e.sources,e.sourceRoot)),e},t.prototype.toString=function(){return JSON.stringify(this.toJSON())},n.SourceMapGenerator=t},function(e,n,r){function t(e){return e<0?(-e<<1)+1:(e<<1)+0}function o(e){var n=1===(1&e),r=e>>1;return n?-r:r}var i=r(3),s=5,a=1<<s,u=a-1,l=a;n.encode=function(e){var n,r="",o=t(e);do n=o&u,o>>>=s,o>0&&(n|=l),r+=i.encode(n);while(o>0);return r},n.decode=function(e,n,r){var t,a,c=e.length,g=0,p=0;do{if(n>=c)throw new Error("Expected more digits in base 64 VLQ value.");if(a=i.decode(e.charCodeAt(n++)),a===-1)throw new Error("Invalid base64 digit: "+e.charAt(n-1));t=!!(a&l),a&=u,g+=a<<p,p+=s}while(t);r.value=o(g),r.rest=n}},function(e,n){var r="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");n.encode=function(e){if(0<=e&&e<r.length)return r[e];throw new TypeError("Must be between 0 and 63: "+e)},n.decode=function(e){var n=65,r=90,t=97,o=122,i=48,s=57,a=43,u=47,l=26,c=52;return n<=e&&e<=r?e-n:t<=e&&e<=o?e-t+l:i<=e&&e<=s?e-i+c:e==a?62:e==u?63:-1}},function(e,n){function r(e,n,r){if(n in e)return e[n];if(3===arguments.length)return r;throw new Error('"'+n+'" is a required argument.')}function t(e){var n=e.match(m);return n?{scheme:n[1],auth:n[2],host:n[3],port:n[4],path:n[5]}:null}function o(e){var n="";return e.scheme&&(n+=e.scheme+":"),n+="//",e.auth&&(n+=e.auth+"@"),e.host&&(n+=e.host),e.port&&(n+=":"+e.port),e.path&&(n+=e.path),n}function i(e){var r=e,i=t(e);if(i){if(!i.path)return e;r=i.path}for(var s,a=n.isAbsolute(r),u=r.split(/\/+/),l=0,c=u.length-1;c>=0;c--)s=u[c],"."===s?u.splice(c,1):".."===s?l++:l>0&&(""===s?(u.splice(c+1,l),l=0):(u.splice(c,2),l--));return r=u.join("/"),""===r&&(r=a?"/":"."),i?(i.path=r,o(i)):r}function s(e,n){""===e&&(e="."),""===n&&(n=".");var r=t(n),s=t(e);if(s&&(e=s.path||"/"),r&&!r.scheme)return s&&(r.scheme=s.scheme),o(r);if(r||n.match(_))return n;if(s&&!s.host&&!s.path)return s.host=n,o(s);var a="/"===n.charAt(0)?n:i(e.replace(/\/+$/,"")+"/"+n);return s?(s.path=a,o(s)):a}function a(e,n){""===e&&(e="."),e=e.replace(/\/$/,"");for(var r=0;0!==n.indexOf(e+"/");){var t=e.lastIndexOf("/");if(t<0)return n;if(e=e.slice(0,t),e.match(/^([^\/]+:\/)?\/*$/))return n;++r}return Array(r+1).join("../")+n.substr(e.length+1)}function u(e){return e}function l(e){return g(e)?"$"+e:e}function c(e){return g(e)?e.slice(1):e}function g(e){if(!e)return!1;var n=e.length;if(n<9)return!1;if(95!==e.charCodeAt(n-1)||95!==e.charCodeAt(n-2)||111!==e.charCodeAt(n-3)||116!==e.charCodeAt(n-4)||111!==e.charCodeAt(n-5)||114!==e.charCodeAt(n-6)||112!==e.charCodeAt(n-7)||95!==e.charCodeAt(n-8)||95!==e.charCodeAt(n-9))return!1;for(var r=n-10;r>=0;r--)if(36!==e.charCodeAt(r))return!1;return!0}function p(e,n,r){var t=e.source-n.source;return 0!==t?t:(t=e.originalLine-n.originalLine,0!==t?t:(t=e.originalColumn-n.originalColumn,0!==t||r?t:(t=e.generatedColumn-n.generatedColumn,0!==t?t:(t=e.generatedLine-n.generatedLine,0!==t?t:e.name-n.name))))}function h(e,n,r){var t=e.generatedLine-n.generatedLine;return 0!==t?t:(t=e.generatedColumn-n.generatedColumn,0!==t||r?t:(t=e.source-n.source,0!==t?t:(t=e.originalLine-n.originalLine,0!==t?t:(t=e.originalColumn-n.originalColumn,0!==t?t:e.name-n.name))))}function f(e,n){return e===n?0:e>n?1:-1}function d(e,n){var r=e.generatedLine-n.generatedLine;return 0!==r?r:(r=e.generatedColumn-n.generatedColumn,0!==r?r:(r=f(e.source,n.source),0!==r?r:(r=e.originalLine-n.originalLine,0!==r?r:(r=e.originalColumn-n.originalColumn,0!==r?r:f(e.name,n.name)))))}n.getArg=r;var m=/^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.]*)(?::(\d+))?(\S*)$/,_=/^data:.+\,.+$/;n.urlParse=t,n.urlGenerate=o,n.normalize=i,n.join=s,n.isAbsolute=function(e){return"/"===e.charAt(0)||!!e.match(m)},n.relative=a;var v=function(){var e=Object.create(null);return!("__proto__"in e)}();n.toSetString=v?u:l,n.fromSetString=v?u:c,n.compareByOriginalPositions=p,n.compareByGeneratedPositionsDeflated=h,n.compareByGeneratedPositionsInflated=d},function(e,n,r){function t(){this._array=[],this._set=s?new Map:Object.create(null)}var o=r(4),i=Object.prototype.hasOwnProperty,s="undefined"!=typeof Map;t.fromArray=function(e,n){for(var r=new t,o=0,i=e.length;o<i;o++)r.add(e[o],n);return r},t.prototype.size=function(){return s?this._set.size:Object.getOwnPropertyNames(this._set).length},t.prototype.add=function(e,n){var r=s?e:o.toSetString(e),t=s?this.has(e):i.call(this._set,r),a=this._array.length;t&&!n||this._array.push(e),t||(s?this._set.set(e,a):this._set[r]=a)},t.prototype.has=function(e){if(s)return this._set.has(e);var n=o.toSetString(e);return i.call(this._set,n)},t.prototype.indexOf=function(e){if(s){var n=this._set.get(e);if(n>=0)return n}else{var r=o.toSetString(e);if(i.call(this._set,r))return this._set[r]}throw new Error('"'+e+'" is not in the set.')},t.prototype.at=function(e){if(e>=0&&e<this._array.length)return this._array[e];throw new Error("No element indexed by "+e)},t.prototype.toArray=function(){return this._array.slice()},n.ArraySet=t},function(e,n,r){function t(e,n){var r=e.generatedLine,t=n.generatedLine,o=e.generatedColumn,s=n.generatedColumn;return t>r||t==r&&s>=o||i.compareByGeneratedPositionsInflated(e,n)<=0}function o(){this._array=[],this._sorted=!0,this._last={generatedLine:-1,generatedColumn:0}}var i=r(4);o.prototype.unsortedForEach=function(e,n){this._array.forEach(e,n)},o.prototype.add=function(e){t(this._last,e)?(this._last=e,this._array.push(e)):(this._sorted=!1,this._array.push(e))},o.prototype.toArray=function(){return this._sorted||(this._array.sort(i.compareByGeneratedPositionsInflated),this._sorted=!0),this._array},n.MappingList=o},function(e,n,r){function t(e){var n=e;return"string"==typeof e&&(n=JSON.parse(e.replace(/^\)\]\}'/,""))),null!=n.sections?new s(n):new o(n)}function o(e){var n=e;"string"==typeof e&&(n=JSON.parse(e.replace(/^\)\]\}'/,"")));var r=a.getArg(n,"version"),t=a.getArg(n,"sources"),o=a.getArg(n,"names",[]),i=a.getArg(n,"sourceRoot",null),s=a.getArg(n,"sourcesContent",null),u=a.getArg(n,"mappings"),c=a.getArg(n,"file",null);if(r!=this._version)throw new Error("Unsupported version: "+r);t=t.map(String).map(a.normalize).map(function(e){return i&&a.isAbsolute(i)&&a.isAbsolute(e)?a.relative(i,e):e}),this._names=l.fromArray(o.map(String),!0),this._sources=l.fromArray(t,!0),this.sourceRoot=i,this.sourcesContent=s,this._mappings=u,this.file=c}function i(){this.generatedLine=0,this.generatedColumn=0,this.source=null,this.originalLine=null,this.originalColumn=null,this.name=null}function s(e){var n=e;"string"==typeof e&&(n=JSON.parse(e.replace(/^\)\]\}'/,"")));var r=a.getArg(n,"version"),o=a.getArg(n,"sections");if(r!=this._version)throw new Error("Unsupported version: "+r);this._sources=new l,this._names=new l;var i={line:-1,column:0};this._sections=o.map(function(e){if(e.url)throw new Error("Support for url field in sections not implemented.");var n=a.getArg(e,"offset"),r=a.getArg(n,"line"),o=a.getArg(n,"column");if(r<i.line||r===i.line&&o<i.column)throw new Error("Section offsets must be ordered and non-overlapping.");return i=n,{generatedOffset:{generatedLine:r+1,generatedColumn:o+1},consumer:new t(a.getArg(e,"map"))}})}var a=r(4),u=r(8),l=r(5).ArraySet,c=r(2),g=r(9).quickSort;t.fromSourceMap=function(e){return o.fromSourceMap(e)},t.prototype._version=3,t.prototype.__generatedMappings=null,Object.defineProperty(t.prototype,"_generatedMappings",{get:function(){return this.__generatedMappings||this._parseMappings(this._mappings,this.sourceRoot),this.__generatedMappings}}),t.prototype.__originalMappings=null,Object.defineProperty(t.prototype,"_originalMappings",{get:function(){return this.__originalMappings||this._parseMappings(this._mappings,this.sourceRoot),this.__originalMappings}}),t.prototype._charIsMappingSeparator=function(e,n){var r=e.charAt(n);return";"===r||","===r},t.prototype._parseMappings=function(e,n){throw new Error("Subclasses must implement _parseMappings")},t.GENERATED_ORDER=1,t.ORIGINAL_ORDER=2,t.GREATEST_LOWER_BOUND=1,t.LEAST_UPPER_BOUND=2,t.prototype.eachMapping=function(e,n,r){var o,i=n||null,s=r||t.GENERATED_ORDER;switch(s){case t.GENERATED_ORDER:o=this._generatedMappings;break;case t.ORIGINAL_ORDER:o=this._originalMappings;break;default:throw new Error("Unknown order of iteration.")}var u=this.sourceRoot;o.map(function(e){var n=null===e.source?null:this._sources.at(e.source);return null!=n&&null!=u&&(n=a.join(u,n)),{source:n,generatedLine:e.generatedLine,generatedColumn:e.generatedColumn,originalLine:e.originalLine,originalColumn:e.originalColumn,name:null===e.name?null:this._names.at(e.name)}},this).forEach(e,i)},t.prototype.allGeneratedPositionsFor=function(e){var n=a.getArg(e,"line"),r={source:a.getArg(e,"source"),originalLine:n,originalColumn:a.getArg(e,"column",0)};if(null!=this.sourceRoot&&(r.source=a.relative(this.sourceRoot,r.source)),!this._sources.has(r.source))return[];r.source=this._sources.indexOf(r.source);var t=[],o=this._findMapping(r,this._originalMappings,"originalLine","originalColumn",a.compareByOriginalPositions,u.LEAST_UPPER_BOUND);if(o>=0){var i=this._originalMappings[o];if(void 0===e.column)for(var s=i.originalLine;i&&i.originalLine===s;)t.push({line:a.getArg(i,"generatedLine",null),column:a.getArg(i,"generatedColumn",null),lastColumn:a.getArg(i,"lastGeneratedColumn",null)}),i=this._originalMappings[++o];else for(var l=i.originalColumn;i&&i.originalLine===n&&i.originalColumn==l;)t.push({line:a.getArg(i,"generatedLine",null),column:a.getArg(i,"generatedColumn",null),lastColumn:a.getArg(i,"lastGeneratedColumn",null)}),i=this._originalMappings[++o]}return t},n.SourceMapConsumer=t,o.prototype=Object.create(t.prototype),o.prototype.consumer=t,o.fromSourceMap=function(e){var n=Object.create(o.prototype),r=n._names=l.fromArray(e._names.toArray(),!0),t=n._sources=l.fromArray(e._sources.toArray(),!0);n.sourceRoot=e._sourceRoot,n.sourcesContent=e._generateSourcesContent(n._sources.toArray(),n.sourceRoot),n.file=e._file;for(var s=e._mappings.toArray().slice(),u=n.__generatedMappings=[],c=n.__originalMappings=[],p=0,h=s.length;p<h;p++){var f=s[p],d=new i;d.generatedLine=f.generatedLine,d.generatedColumn=f.generatedColumn,f.source&&(d.source=t.indexOf(f.source),d.originalLine=f.originalLine,d.originalColumn=f.originalColumn,f.name&&(d.name=r.indexOf(f.name)),c.push(d)),u.push(d)}return g(n.__originalMappings,a.compareByOriginalPositions),n},o.prototype._version=3,Object.defineProperty(o.prototype,"sources",{get:function(){return this._sources.toArray().map(function(e){return null!=this.sourceRoot?a.join(this.sourceRoot,e):e},this)}}),o.prototype._parseMappings=function(e,n){for(var r,t,o,s,u,l=1,p=0,h=0,f=0,d=0,m=0,_=e.length,v=0,y={},C={},A=[],S=[];v<_;)if(";"===e.charAt(v))l++,v++,p=0;else if(","===e.charAt(v))v++;else{for(r=new i,r.generatedLine=l,s=v;s<_&&!this._charIsMappingSeparator(e,s);s++);if(t=e.slice(v,s),o=y[t])v+=t.length;else{for(o=[];v<s;)c.decode(e,v,C),u=C.value,v=C.rest,o.push(u);if(2===o.length)throw new Error("Found a source, but no line and column");if(3===o.length)throw new Error("Found a source and line, but no column");y[t]=o}r.generatedColumn=p+o[0],p=r.generatedColumn,o.length>1&&(r.source=d+o[1],d+=o[1],r.originalLine=h+o[2],h=r.originalLine,r.originalLine+=1,r.originalColumn=f+o[3],f=r.originalColumn,o.length>4&&(r.name=m+o[4],m+=o[4])),S.push(r),"number"==typeof r.originalLine&&A.push(r)}g(S,a.compareByGeneratedPositionsDeflated),this.__generatedMappings=S,g(A,a.compareByOriginalPositions),this.__originalMappings=A},o.prototype._findMapping=function(e,n,r,t,o,i){if(e[r]<=0)throw new TypeError("Line must be greater than or equal to 1, got "+e[r]);if(e[t]<0)throw new TypeError("Column must be greater than or equal to 0, got "+e[t]);return u.search(e,n,o,i)},o.prototype.computeColumnSpans=function(){for(var e=0;e<this._generatedMappings.length;++e){var n=this._generatedMappings[e];if(e+1<this._generatedMappings.length){var r=this._generatedMappings[e+1];if(n.generatedLine===r.generatedLine){n.lastGeneratedColumn=r.generatedColumn-1;continue}}n.lastGeneratedColumn=1/0}},o.prototype.originalPositionFor=function(e){var n={generatedLine:a.getArg(e,"line"),generatedColumn:a.getArg(e,"column")},r=this._findMapping(n,this._generatedMappings,"generatedLine","generatedColumn",a.compareByGeneratedPositionsDeflated,a.getArg(e,"bias",t.GREATEST_LOWER_BOUND));if(r>=0){var o=this._generatedMappings[r];if(o.generatedLine===n.generatedLine){var i=a.getArg(o,"source",null);null!==i&&(i=this._sources.at(i),null!=this.sourceRoot&&(i=a.join(this.sourceRoot,i)));var s=a.getArg(o,"name",null);return null!==s&&(s=this._names.at(s)),{source:i,line:a.getArg(o,"originalLine",null),column:a.getArg(o,"originalColumn",null),name:s}}}return{source:null,line:null,column:null,name:null}},o.prototype.hasContentsOfAllSources=function(){return!!this.sourcesContent&&(this.sourcesContent.length>=this._sources.size()&&!this.sourcesContent.some(function(e){return null==e}))},o.prototype.sourceContentFor=function(e,n){if(!this.sourcesContent)return null;if(null!=this.sourceRoot&&(e=a.relative(this.sourceRoot,e)),this._sources.has(e))return this.sourcesContent[this._sources.indexOf(e)];var r;if(null!=this.sourceRoot&&(r=a.urlParse(this.sourceRoot))){var t=e.replace(/^file:\/\//,"");if("file"==r.scheme&&this._sources.has(t))return this.sourcesContent[this._sources.indexOf(t)];if((!r.path||"/"==r.path)&&this._sources.has("/"+e))return this.sourcesContent[this._sources.indexOf("/"+e)]}if(n)return null;throw new Error('"'+e+'" is not in the SourceMap.')},o.prototype.generatedPositionFor=function(e){var n=a.getArg(e,"source");if(null!=this.sourceRoot&&(n=a.relative(this.sourceRoot,n)),!this._sources.has(n))return{line:null,column:null,lastColumn:null};n=this._sources.indexOf(n);var r={source:n,originalLine:a.getArg(e,"line"),originalColumn:a.getArg(e,"column")},o=this._findMapping(r,this._originalMappings,"originalLine","originalColumn",a.compareByOriginalPositions,a.getArg(e,"bias",t.GREATEST_LOWER_BOUND));if(o>=0){var i=this._originalMappings[o];if(i.source===r.source)return{line:a.getArg(i,"generatedLine",null),column:a.getArg(i,"generatedColumn",null),lastColumn:a.getArg(i,"lastGeneratedColumn",null)}}return{line:null,column:null,lastColumn:null}},n.BasicSourceMapConsumer=o,s.prototype=Object.create(t.prototype),s.prototype.constructor=t,s.prototype._version=3,Object.defineProperty(s.prototype,"sources",{get:function(){for(var e=[],n=0;n<this._sections.length;n++)for(var r=0;r<this._sections[n].consumer.sources.length;r++)e.push(this._sections[n].consumer.sources[r]);return e}}),s.prototype.originalPositionFor=function(e){var n={generatedLine:a.getArg(e,"line"),generatedColumn:a.getArg(e,"column")},r=u.search(n,this._sections,function(e,n){var r=e.generatedLine-n.generatedOffset.generatedLine;return r?r:e.generatedColumn-n.generatedOffset.generatedColumn}),t=this._sections[r];return t?t.consumer.originalPositionFor({line:n.generatedLine-(t.generatedOffset.generatedLine-1),column:n.generatedColumn-(t.generatedOffset.generatedLine===n.generatedLine?t.generatedOffset.generatedColumn-1:0),bias:e.bias}):{source:null,line:null,column:null,name:null}},s.prototype.hasContentsOfAllSources=function(){return this._sections.every(function(e){return e.consumer.hasContentsOfAllSources()})},s.prototype.sourceContentFor=function(e,n){for(var r=0;r<this._sections.length;r++){var t=this._sections[r],o=t.consumer.sourceContentFor(e,!0);if(o)return o}if(n)return null;throw new Error('"'+e+'" is not in the SourceMap.')},s.prototype.generatedPositionFor=function(e){for(var n=0;n<this._sections.length;n++){var r=this._sections[n];if(r.consumer.sources.indexOf(a.getArg(e,"source"))!==-1){var t=r.consumer.generatedPositionFor(e);if(t){var o={line:t.line+(r.generatedOffset.generatedLine-1),column:t.column+(r.generatedOffset.generatedLine===t.line?r.generatedOffset.generatedColumn-1:0)};return o}}}return{line:null,column:null}},s.prototype._parseMappings=function(e,n){this.__generatedMappings=[],this.__originalMappings=[];for(var r=0;r<this._sections.length;r++)for(var t=this._sections[r],o=t.consumer._generatedMappings,i=0;i<o.length;i++){var s=o[i],u=t.consumer._sources.at(s.source);null!==t.consumer.sourceRoot&&(u=a.join(t.consumer.sourceRoot,u)),this._sources.add(u),u=this._sources.indexOf(u);var l=t.consumer._names.at(s.name);this._names.add(l),l=this._names.indexOf(l);var c={source:u,generatedLine:s.generatedLine+(t.generatedOffset.generatedLine-1),generatedColumn:s.generatedColumn+(t.generatedOffset.generatedLine===s.generatedLine?t.generatedOffset.generatedColumn-1:0),originalLine:s.originalLine,originalColumn:s.originalColumn,name:l};this.__generatedMappings.push(c),"number"==typeof c.originalLine&&this.__originalMappings.push(c)}g(this.__generatedMappings,a.compareByGeneratedPositionsDeflated),g(this.__originalMappings,a.compareByOriginalPositions)},n.IndexedSourceMapConsumer=s},function(e,n){function r(e,t,o,i,s,a){var u=Math.floor((t-e)/2)+e,l=s(o,i[u],!0);return 0===l?u:l>0?t-u>1?r(u,t,o,i,s,a):a==n.LEAST_UPPER_BOUND?t<i.length?t:-1:u:u-e>1?r(e,u,o,i,s,a):a==n.LEAST_UPPER_BOUND?u:e<0?-1:e}n.GREATEST_LOWER_BOUND=1,n.LEAST_UPPER_BOUND=2,n.search=function(e,t,o,i){if(0===t.length)return-1;var s=r(-1,t.length,e,t,o,i||n.GREATEST_LOWER_BOUND);if(s<0)return-1;for(;s-1>=0&&0===o(t[s],t[s-1],!0);)--s;return s}},function(e,n){function r(e,n,r){var t=e[n];e[n]=e[r],e[r]=t}function t(e,n){return Math.round(e+Math.random()*(n-e))}function o(e,n,i,s){if(i<s){var a=t(i,s),u=i-1;r(e,a,s);for(var l=e[s],c=i;c<s;c++)n(e[c],l)<=0&&(u+=1,r(e,u,c));r(e,u+1,c);var g=u+1;o(e,n,i,g-1),o(e,n,g+1,s)}}n.quickSort=function(e,n){o(e,n,0,e.length-1)}},function(e,n,r){function t(e,n,r,t,o){this.children=[],this.sourceContents={},this.line=null==e?null:e,this.column=null==n?null:n,this.source=null==r?null:r,this.name=null==o?null:o,this[u]=!0,null!=t&&this.add(t)}var o=r(1).SourceMapGenerator,i=r(4),s=/(\r?\n)/,a=10,u="$$$isSourceNode$$$";t.fromStringWithSourceMap=function(e,n,r){function o(e,n){if(null===e||void 0===e.source)a.add(n);else{var o=r?i.join(r,e.source):e.source;a.add(new t(e.originalLine,e.originalColumn,o,n,e.name))}}var a=new t,u=e.split(s),l=0,c=function(){function e(){return l<u.length?u[l++]:void 0}var n=e(),r=e()||"";return n+r},g=1,p=0,h=null;return n.eachMapping(function(e){if(null!==h){if(!(g<e.generatedLine)){var n=u[l],r=n.substr(0,e.generatedColumn-p);return u[l]=n.substr(e.generatedColumn-p),p=e.generatedColumn,o(h,r),void(h=e)}o(h,c()),g++,p=0}for(;g<e.generatedLine;)a.add(c()),g++;if(p<e.generatedColumn){var n=u[l];a.add(n.substr(0,e.generatedColumn)),u[l]=n.substr(e.generatedColumn),p=e.generatedColumn}h=e},this),l<u.length&&(h&&o(h,c()),a.add(u.splice(l).join(""))),n.sources.forEach(function(e){var t=n.sourceContentFor(e);null!=t&&(null!=r&&(e=i.join(r,e)),a.setSourceContent(e,t))}),a},t.prototype.add=function(e){if(Array.isArray(e))e.forEach(function(e){this.add(e)},this);else{if(!e[u]&&"string"!=typeof e)throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got "+e);e&&this.children.push(e)}return this},t.prototype.prepend=function(e){if(Array.isArray(e))for(var n=e.length-1;n>=0;n--)this.prepend(e[n]);else{if(!e[u]&&"string"!=typeof e)throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got "+e);this.children.unshift(e)}return this},t.prototype.walk=function(e){for(var n,r=0,t=this.children.length;r<t;r++)n=this.children[r],n[u]?n.walk(e):""!==n&&e(n,{source:this.source,line:this.line,column:this.column,name:this.name})},t.prototype.join=function(e){var n,r,t=this.children.length;if(t>0){for(n=[],r=0;r<t-1;r++)n.push(this.children[r]),n.push(e);n.push(this.children[r]),this.children=n}return this},t.prototype.replaceRight=function(e,n){var r=this.children[this.children.length-1];return r[u]?r.replaceRight(e,n):"string"==typeof r?this.children[this.children.length-1]=r.replace(e,n):this.children.push("".replace(e,n)),this},t.prototype.setSourceContent=function(e,n){this.sourceContents[i.toSetString(e)]=n},t.prototype.walkSourceContents=function(e){for(var n=0,r=this.children.length;n<r;n++)this.children[n][u]&&this.children[n].walkSourceContents(e);for(var t=Object.keys(this.sourceContents),n=0,r=t.length;n<r;n++)e(i.fromSetString(t[n]),this.sourceContents[t[n]])},t.prototype.toString=function(){var e="";return this.walk(function(n){e+=n}),e},t.prototype.toStringWithSourceMap=function(e){var n={code:"",line:1,column:0},r=new o(e),t=!1,i=null,s=null,u=null,l=null;return this.walk(function(e,o){n.code+=e,null!==o.source&&null!==o.line&&null!==o.column?(i===o.source&&s===o.line&&u===o.column&&l===o.name||r.addMapping({source:o.source,original:{line:o.line,column:o.column},generated:{line:n.line,column:n.column},name:o.name}),i=o.source,s=o.line,u=o.column,l=o.name,t=!0):t&&(r.addMapping({generated:{line:n.line,column:n.column}}),i=null,t=!1);for(var c=0,g=e.length;c<g;c++)e.charCodeAt(c)===a?(n.line++,n.column=0,c+1===g?(i=null,t=!1):t&&r.addMapping({source:o.source,original:{line:o.line,column:o.column},generated:{line:n.line,column:n.column},name:o.name})):n.column++}),this.walkSourceContents(function(e,n){r.setSourceContent(e,n)}),{code:n.code,map:r}},n.SourceNode=t}])});
+//# sourceMappingURL=source-map.min.js.map
\ No newline at end of file
diff --git a/node_modules/@babel/generator/node_modules/source-map/dist/source-map.min.js.map b/node_modules/@babel/generator/node_modules/source-map/dist/source-map.min.js.map
new file mode 100644
index 00000000..588b70cb
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/source-map/dist/source-map.min.js.map
@@ -0,0 +1 @@
+{"version":3,"sources":["webpack:///webpack/universalModuleDefinition","webpack:///source-map.min.js","webpack:///webpack/bootstrap 42c329f865e32e011afb","webpack:///./source-map.js","webpack:///./lib/source-map-generator.js","webpack:///./lib/base64-vlq.js","webpack:///./lib/base64.js","webpack:///./lib/util.js","webpack:///./lib/array-set.js","webpack:///./lib/mapping-list.js","webpack:///./lib/source-map-consumer.js","webpack:///./lib/binary-search.js","webpack:///./lib/quick-sort.js","webpack:///./lib/source-node.js"],"names":["root","factory","exports","module","define","amd","this","modules","__webpack_require__","moduleId","installedModules","id","loaded","call","m","c","p","SourceMapGenerator","SourceMapConsumer","SourceNode","aArgs","_file","util","getArg","_sourceRoot","_skipValidation","_sources","ArraySet","_names","_mappings","MappingList","_sourcesContents","base64VLQ","prototype","_version","fromSourceMap","aSourceMapConsumer","sourceRoot","generator","file","eachMapping","mapping","newMapping","generated","line","generatedLine","column","generatedColumn","source","relative","original","originalLine","originalColumn","name","addMapping","sources","forEach","sourceFile","content","sourceContentFor","setSourceContent","_validateMapping","String","has","add","aSourceFile","aSourceContent","Object","create","toSetString","keys","length","applySourceMap","aSourceMapPath","Error","newSources","newNames","unsortedForEach","originalPositionFor","join","aGenerated","aOriginal","aSource","aName","JSON","stringify","_serializeMappings","next","nameIdx","sourceIdx","previousGeneratedColumn","previousGeneratedLine","previousOriginalColumn","previousOriginalLine","previousName","previousSource","result","mappings","toArray","i","len","compareByGeneratedPositionsInflated","encode","indexOf","_generateSourcesContent","aSources","aSourceRoot","map","key","hasOwnProperty","toJSON","version","names","sourcesContent","toString","toVLQSigned","aValue","fromVLQSigned","isNegative","shifted","base64","VLQ_BASE_SHIFT","VLQ_BASE","VLQ_BASE_MASK","VLQ_CONTINUATION_BIT","digit","encoded","vlq","decode","aStr","aIndex","aOutParam","continuation","strLen","shift","charCodeAt","charAt","value","rest","intToCharMap","split","number","TypeError","charCode","bigA","bigZ","littleA","littleZ","zero","nine","plus","slash","littleOffset","numberOffset","aDefaultValue","arguments","urlParse","aUrl","match","urlRegexp","scheme","auth","host","port","path","urlGenerate","aParsedUrl","url","normalize","aPath","part","isAbsolute","parts","up","splice","aRoot","aPathUrl","aRootUrl","dataUrlRegexp","joined","replace","level","index","lastIndexOf","slice","Array","substr","identity","s","isProtoString","fromSetString","compareByOriginalPositions","mappingA","mappingB","onlyCompareOriginal","cmp","compareByGeneratedPositionsDeflated","onlyCompareGenerated","strcmp","aStr1","aStr2","supportsNullProto","obj","_array","_set","hasNativeMap","Map","fromArray","aArray","aAllowDuplicates","set","size","getOwnPropertyNames","sStr","isDuplicate","idx","push","get","at","aIdx","generatedPositionAfter","lineA","lineB","columnA","columnB","_sorted","_last","aCallback","aThisArg","aMapping","sort","aSourceMap","sourceMap","parse","sections","IndexedSourceMapConsumer","BasicSourceMapConsumer","Mapping","lastOffset","_sections","offset","offsetLine","offsetColumn","generatedOffset","consumer","binarySearch","quickSort","__generatedMappings","defineProperty","_parseMappings","__originalMappings","_charIsMappingSeparator","GENERATED_ORDER","ORIGINAL_ORDER","GREATEST_LOWER_BOUND","LEAST_UPPER_BOUND","aContext","aOrder","context","order","_generatedMappings","_originalMappings","allGeneratedPositionsFor","needle","_findMapping","undefined","lastColumn","smc","generatedMappings","destGeneratedMappings","destOriginalMappings","srcMapping","destMapping","str","segment","end","cachedSegments","temp","originalMappings","aNeedle","aMappings","aLineName","aColumnName","aComparator","aBias","search","computeColumnSpans","nextMapping","lastGeneratedColumn","Infinity","hasContentsOfAllSources","some","sc","nullOnMissing","fileUriAbsPath","generatedPositionFor","constructor","j","sectionIndex","section","bias","every","generatedPosition","ret","sectionMappings","adjustedMapping","recursiveSearch","aLow","aHigh","aHaystack","aCompare","mid","Math","floor","swap","ary","x","y","randomIntInRange","low","high","round","random","doQuickSort","comparator","r","pivotIndex","pivot","q","aLine","aColumn","aChunks","children","sourceContents","isSourceNode","REGEX_NEWLINE","NEWLINE_CODE","fromStringWithSourceMap","aGeneratedCode","aRelativePath","addMappingWithCode","code","node","remainingLines","remainingLinesIndex","shiftNextLine","getNextLine","lineContents","newLine","lastGeneratedLine","lastMapping","nextLine","aChunk","isArray","chunk","prepend","unshift","walk","aFn","aSep","newChildren","replaceRight","aPattern","aReplacement","lastChild","walkSourceContents","toStringWithSourceMap","sourceMappingActive","lastOriginalSource","lastOriginalLine","lastOriginalColumn","lastOriginalName","sourceContent"],"mappings":"CAAA,SAAAA,EAAAC,GACA,gBAAAC,UAAA,gBAAAC,QACAA,OAAAD,QAAAD,IACA,kBAAAG,gBAAAC,IACAD,UAAAH,GACA,gBAAAC,SACAA,QAAA,UAAAD,IAEAD,EAAA,UAAAC,KACCK,KAAA,WACD,MCAgB,UAAUC,GCN1B,QAAAC,GAAAC,GAGA,GAAAC,EAAAD,GACA,MAAAC,GAAAD,GAAAP,OAGA,IAAAC,GAAAO,EAAAD,IACAP,WACAS,GAAAF,EACAG,QAAA,EAUA,OANAL,GAAAE,GAAAI,KAAAV,EAAAD,QAAAC,IAAAD,QAAAM,GAGAL,EAAAS,QAAA,EAGAT,EAAAD,QAvBA,GAAAQ,KAqCA,OATAF,GAAAM,EAAAP,EAGAC,EAAAO,EAAAL,EAGAF,EAAAQ,EAAA,GAGAR,EAAA,KDgBM,SAAUL,EAAQD,EAASM,GEjDjCN,EAAAe,mBAAAT,EAAA,GAAAS,mBACAf,EAAAgB,kBAAAV,EAAA,GAAAU,kBACAhB,EAAAiB,WAAAX,EAAA,IAAAW,YF6DM,SAAUhB,EAAQD,EAASM,GGhDjC,QAAAS,GAAAG,GACAA,IACAA,MAEAd,KAAAe,MAAAC,EAAAC,OAAAH,EAAA,aACAd,KAAAkB,YAAAF,EAAAC,OAAAH,EAAA,mBACAd,KAAAmB,gBAAAH,EAAAC,OAAAH,EAAA,qBACAd,KAAAoB,SAAA,GAAAC,GACArB,KAAAsB,OAAA,GAAAD,GACArB,KAAAuB,UAAA,GAAAC,GACAxB,KAAAyB,iBAAA,KAvBA,GAAAC,GAAAxB,EAAA,GACAc,EAAAd,EAAA,GACAmB,EAAAnB,EAAA,GAAAmB,SACAG,EAAAtB,EAAA,GAAAsB,WAuBAb,GAAAgB,UAAAC,SAAA,EAOAjB,EAAAkB,cACA,SAAAC,GACA,GAAAC,GAAAD,EAAAC,WACAC,EAAA,GAAArB,IACAsB,KAAAH,EAAAG,KACAF,cAkCA,OAhCAD,GAAAI,YAAA,SAAAC,GACA,GAAAC,IACAC,WACAC,KAAAH,EAAAI,cACAC,OAAAL,EAAAM,iBAIA,OAAAN,EAAAO,SACAN,EAAAM,OAAAP,EAAAO,OACA,MAAAX,IACAK,EAAAM,OAAA1B,EAAA2B,SAAAZ,EAAAK,EAAAM,SAGAN,EAAAQ,UACAN,KAAAH,EAAAU,aACAL,OAAAL,EAAAW,gBAGA,MAAAX,EAAAY,OACAX,EAAAW,KAAAZ,EAAAY,OAIAf,EAAAgB,WAAAZ,KAEAN,EAAAmB,QAAAC,QAAA,SAAAC,GACA,GAAAC,GAAAtB,EAAAuB,iBAAAF,EACA,OAAAC,GACApB,EAAAsB,iBAAAH,EAAAC,KAGApB,GAaArB,EAAAgB,UAAAqB,WACA,SAAAlC,GACA,GAAAuB,GAAArB,EAAAC,OAAAH,EAAA,aACA8B,EAAA5B,EAAAC,OAAAH,EAAA,iBACA4B,EAAA1B,EAAAC,OAAAH,EAAA,eACAiC,EAAA/B,EAAAC,OAAAH,EAAA,YAEAd,MAAAmB,iBACAnB,KAAAuD,iBAAAlB,EAAAO,EAAAF,EAAAK,GAGA,MAAAL,IACAA,EAAAc,OAAAd,GACA1C,KAAAoB,SAAAqC,IAAAf,IACA1C,KAAAoB,SAAAsC,IAAAhB,IAIA,MAAAK,IACAA,EAAAS,OAAAT,GACA/C,KAAAsB,OAAAmC,IAAAV,IACA/C,KAAAsB,OAAAoC,IAAAX,IAIA/C,KAAAuB,UAAAmC,KACAnB,cAAAF,EAAAC,KACAG,gBAAAJ,EAAAG,OACAK,aAAA,MAAAD,KAAAN,KACAQ,eAAA,MAAAF,KAAAJ,OACAE,SACAK,UAOApC,EAAAgB,UAAA2B,iBACA,SAAAK,EAAAC,GACA,GAAAlB,GAAAiB,CACA,OAAA3D,KAAAkB,cACAwB,EAAA1B,EAAA2B,SAAA3C,KAAAkB,YAAAwB,IAGA,MAAAkB,GAGA5D,KAAAyB,mBACAzB,KAAAyB,iBAAAoC,OAAAC,OAAA,OAEA9D,KAAAyB,iBAAAT,EAAA+C,YAAArB,IAAAkB,GACK5D,KAAAyB,yBAGLzB,MAAAyB,iBAAAT,EAAA+C,YAAArB,IACA,IAAAmB,OAAAG,KAAAhE,KAAAyB,kBAAAwC,SACAjE,KAAAyB,iBAAA,QAqBAd,EAAAgB,UAAAuC,eACA,SAAApC,EAAA6B,EAAAQ,GACA,GAAAhB,GAAAQ,CAEA,UAAAA,EAAA,CACA,SAAA7B,EAAAG,KACA,SAAAmC,OACA,gJAIAjB,GAAArB,EAAAG,KAEA,GAAAF,GAAA/B,KAAAkB,WAEA,OAAAa,IACAoB,EAAAnC,EAAA2B,SAAAZ,EAAAoB,GAIA,IAAAkB,GAAA,GAAAhD,GACAiD,EAAA,GAAAjD,EAGArB,MAAAuB,UAAAgD,gBAAA,SAAApC,GACA,GAAAA,EAAAO,SAAAS,GAAA,MAAAhB,EAAAU,aAAA,CAEA,GAAAD,GAAAd,EAAA0C,qBACAlC,KAAAH,EAAAU,aACAL,OAAAL,EAAAW,gBAEA,OAAAF,EAAAF,SAEAP,EAAAO,OAAAE,EAAAF,OACA,MAAAyB,IACAhC,EAAAO,OAAA1B,EAAAyD,KAAAN,EAAAhC,EAAAO,SAEA,MAAAX,IACAI,EAAAO,OAAA1B,EAAA2B,SAAAZ,EAAAI,EAAAO,SAEAP,EAAAU,aAAAD,EAAAN,KACAH,EAAAW,eAAAF,EAAAJ,OACA,MAAAI,EAAAG,OACAZ,EAAAY,KAAAH,EAAAG,OAKA,GAAAL,GAAAP,EAAAO,MACA,OAAAA,GAAA2B,EAAAZ,IAAAf,IACA2B,EAAAX,IAAAhB,EAGA,IAAAK,GAAAZ,EAAAY,IACA,OAAAA,GAAAuB,EAAAb,IAAAV,IACAuB,EAAAZ,IAAAX,IAGK/C,MACLA,KAAAoB,SAAAiD,EACArE,KAAAsB,OAAAgD,EAGAxC,EAAAmB,QAAAC,QAAA,SAAAC,GACA,GAAAC,GAAAtB,EAAAuB,iBAAAF,EACA,OAAAC,IACA,MAAAe,IACAhB,EAAAnC,EAAAyD,KAAAN,EAAAhB,IAEA,MAAApB,IACAoB,EAAAnC,EAAA2B,SAAAZ,EAAAoB,IAEAnD,KAAAsD,iBAAAH,EAAAC,KAEKpD,OAcLW,EAAAgB,UAAA4B,iBACA,SAAAmB,EAAAC,EAAAC,EACAC,GAKA,GAAAF,GAAA,gBAAAA,GAAArC,MAAA,gBAAAqC,GAAAnC,OACA,SAAA4B,OACA,+OAMA,OAAAM,GAAA,QAAAA,IAAA,UAAAA,IACAA,EAAApC,KAAA,GAAAoC,EAAAlC,QAAA,IACAmC,GAAAC,GAAAC,MAIAH,GAAA,QAAAA,IAAA,UAAAA,IACAC,GAAA,QAAAA,IAAA,UAAAA,IACAD,EAAApC,KAAA,GAAAoC,EAAAlC,QAAA,GACAmC,EAAArC,KAAA,GAAAqC,EAAAnC,QAAA,GACAoC,GAKA,SAAAR,OAAA,oBAAAU,KAAAC,WACA1C,UAAAqC,EACAhC,OAAAkC,EACAhC,SAAA+B,EACA5B,KAAA8B,MASAlE,EAAAgB,UAAAqD,mBACA,WAcA,OANAC,GACA9C,EACA+C,EACAC,EAVAC,EAAA,EACAC,EAAA,EACAC,EAAA,EACAC,EAAA,EACAC,EAAA,EACAC,EAAA,EACAC,EAAA,GAMAC,EAAA3F,KAAAuB,UAAAqE,UACAC,EAAA,EAAAC,EAAAH,EAAA1B,OAA0C4B,EAAAC,EAASD,IAAA,CAInD,GAHA1D,EAAAwD,EAAAE,GACAZ,EAAA,GAEA9C,EAAAI,gBAAA8C,EAEA,IADAD,EAAA,EACAjD,EAAAI,gBAAA8C,GACAJ,GAAA,IACAI,QAIA,IAAAQ,EAAA,GACA,IAAA7E,EAAA+E,oCAAA5D,EAAAwD,EAAAE,EAAA,IACA,QAEAZ,IAAA,IAIAA,GAAAvD,EAAAsE,OAAA7D,EAAAM,gBACA2C,GACAA,EAAAjD,EAAAM,gBAEA,MAAAN,EAAAO,SACAyC,EAAAnF,KAAAoB,SAAA6E,QAAA9D,EAAAO,QACAuC,GAAAvD,EAAAsE,OAAAb,EAAAM,GACAA,EAAAN,EAGAF,GAAAvD,EAAAsE,OAAA7D,EAAAU,aAAA,EACA0C,GACAA,EAAApD,EAAAU,aAAA,EAEAoC,GAAAvD,EAAAsE,OAAA7D,EAAAW,eACAwC,GACAA,EAAAnD,EAAAW,eAEA,MAAAX,EAAAY,OACAmC,EAAAlF,KAAAsB,OAAA2E,QAAA9D,EAAAY,MACAkC,GAAAvD,EAAAsE,OAAAd,EAAAM,GACAA,EAAAN,IAIAQ,GAAAT,EAGA,MAAAS,IAGA/E,EAAAgB,UAAAuE,wBACA,SAAAC,EAAAC,GACA,MAAAD,GAAAE,IAAA,SAAA3D,GACA,IAAA1C,KAAAyB,iBACA,WAEA,OAAA2E,IACA1D,EAAA1B,EAAA2B,SAAAyD,EAAA1D,GAEA,IAAA4D,GAAAtF,EAAA+C,YAAArB,EACA,OAAAmB,QAAAlC,UAAA4E,eAAAhG,KAAAP,KAAAyB,iBAAA6E,GACAtG,KAAAyB,iBAAA6E,GACA,MACKtG,OAMLW,EAAAgB,UAAA6E,OACA,WACA,GAAAH,IACAI,QAAAzG,KAAA4B,SACAqB,QAAAjD,KAAAoB,SAAAwE,UACAc,MAAA1G,KAAAsB,OAAAsE,UACAD,SAAA3F,KAAAgF,qBAYA,OAVA,OAAAhF,KAAAe,QACAsF,EAAApE,KAAAjC,KAAAe,OAEA,MAAAf,KAAAkB,cACAmF,EAAAtE,WAAA/B,KAAAkB,aAEAlB,KAAAyB,mBACA4E,EAAAM,eAAA3G,KAAAkG,wBAAAG,EAAApD,QAAAoD,EAAAtE,aAGAsE,GAMA1F,EAAAgB,UAAAiF,SACA,WACA,MAAA9B,MAAAC,UAAA/E,KAAAwG,WAGA5G,EAAAe,sBH2EM,SAAUd,EAAQD,EAASM,GItajC,QAAA2G,GAAAC,GACA,MAAAA,GAAA,IACAA,GAAA,MACAA,GAAA,KASA,QAAAC,GAAAD,GACA,GAAAE,GAAA,OAAAF,GACAG,EAAAH,GAAA,CACA,OAAAE,IACAC,EACAA,EAhDA,GAAAC,GAAAhH,EAAA,GAcAiH,EAAA,EAGAC,EAAA,GAAAD,EAGAE,EAAAD,EAAA,EAGAE,EAAAF,CA+BAxH,GAAAoG,OAAA,SAAAc,GACA,GACAS,GADAC,EAAA,GAGAC,EAAAZ,EAAAC,EAEA,GACAS,GAAAE,EAAAJ,EACAI,KAAAN,EACAM,EAAA,IAGAF,GAAAD,GAEAE,GAAAN,EAAAlB,OAAAuB,SACGE,EAAA,EAEH,OAAAD,IAOA5H,EAAA8H,OAAA,SAAAC,EAAAC,EAAAC,GACA,GAGAC,GAAAP,EAHAQ,EAAAJ,EAAA1D,OACAyB,EAAA,EACAsC,EAAA,CAGA,IACA,GAAAJ,GAAAG,EACA,SAAA3D,OAAA,6CAIA,IADAmD,EAAAL,EAAAQ,OAAAC,EAAAM,WAAAL,MACAL,KAAA,EACA,SAAAnD,OAAA,yBAAAuD,EAAAO,OAAAN,EAAA,GAGAE,MAAAP,EAAAD,GACAC,GAAAF,EACA3B,GAAA6B,GAAAS,EACAA,GAAAb,QACGW,EAEHD,GAAAM,MAAApB,EAAArB,GACAmC,EAAAO,KAAAR,IJkfM,SAAU/H,EAAQD,GKrnBxB,GAAAyI,GAAA,mEAAAC,MAAA,GAKA1I,GAAAoG,OAAA,SAAAuC,GACA,MAAAA,KAAAF,EAAApE,OACA,MAAAoE,GAAAE,EAEA,UAAAC,WAAA,6BAAAD,IAOA3I,EAAA8H,OAAA,SAAAe,GACA,GAAAC,GAAA,GACAC,EAAA,GAEAC,EAAA,GACAC,EAAA,IAEAC,EAAA,GACAC,EAAA,GAEAC,EAAA,GACAC,EAAA,GAEAC,EAAA,GACAC,EAAA,EAGA,OAAAT,IAAAD,MAAAE,EACAF,EAAAC,EAIAE,GAAAH,MAAAI,EACAJ,EAAAG,EAAAM,EAIAJ,GAAAL,MAAAM,EACAN,EAAAK,EAAAK,EAIAV,GAAAO,EACA,GAIAP,GAAAQ,EACA,IAIA,ILooBM,SAAUpJ,EAAQD,GMprBxB,QAAAqB,GAAAH,EAAA+D,EAAAuE,GACA,GAAAvE,IAAA/D,GACA,MAAAA,GAAA+D,EACG,QAAAwE,UAAApF,OACH,MAAAmF,EAEA,UAAAhF,OAAA,IAAAS,EAAA,6BAQA,QAAAyE,GAAAC,GACA,GAAAC,GAAAD,EAAAC,MAAAC,EACA,OAAAD,IAIAE,OAAAF,EAAA,GACAG,KAAAH,EAAA,GACAI,KAAAJ,EAAA,GACAK,KAAAL,EAAA,GACAM,KAAAN,EAAA,IAPA,KAYA,QAAAO,GAAAC,GACA,GAAAC,GAAA,EAiBA,OAhBAD,GAAAN,SACAO,GAAAD,EAAAN,OAAA,KAEAO,GAAA,KACAD,EAAAL,OACAM,GAAAD,EAAAL,KAAA,KAEAK,EAAAJ,OACAK,GAAAD,EAAAJ,MAEAI,EAAAH,OACAI,GAAA,IAAAD,EAAAH,MAEAG,EAAAF,OACAG,GAAAD,EAAAF,MAEAG,EAeA,QAAAC,GAAAC,GACA,GAAAL,GAAAK,EACAF,EAAAX,EAAAa,EACA,IAAAF,EAAA,CACA,IAAAA,EAAAH,KACA,MAAAK,EAEAL,GAAAG,EAAAH,KAKA,OAAAM,GAHAC,EAAAzK,EAAAyK,WAAAP,GAEAQ,EAAAR,EAAAxB,MAAA,OACAiC,EAAA,EAAA1E,EAAAyE,EAAArG,OAAA,EAA8C4B,GAAA,EAAQA,IACtDuE,EAAAE,EAAAzE,GACA,MAAAuE,EACAE,EAAAE,OAAA3E,EAAA,GACK,OAAAuE,EACLG,IACKA,EAAA,IACL,KAAAH,GAIAE,EAAAE,OAAA3E,EAAA,EAAA0E,GACAA,EAAA,IAEAD,EAAAE,OAAA3E,EAAA,GACA0E,KAUA,OANAT,GAAAQ,EAAA7F,KAAA,KAEA,KAAAqF,IACAA,EAAAO,EAAA,SAGAJ,GACAA,EAAAH,OACAC,EAAAE,IAEAH,EAoBA,QAAArF,GAAAgG,EAAAN,GACA,KAAAM,IACAA,EAAA,KAEA,KAAAN,IACAA,EAAA,IAEA,IAAAO,GAAApB,EAAAa,GACAQ,EAAArB,EAAAmB,EAMA,IALAE,IACAF,EAAAE,EAAAb,MAAA,KAIAY,MAAAhB,OAIA,MAHAiB,KACAD,EAAAhB,OAAAiB,EAAAjB,QAEAK,EAAAW,EAGA,IAAAA,GAAAP,EAAAX,MAAAoB,GACA,MAAAT,EAIA,IAAAQ,MAAAf,OAAAe,EAAAb,KAEA,MADAa,GAAAf,KAAAO,EACAJ,EAAAY,EAGA,IAAAE,GAAA,MAAAV,EAAAjC,OAAA,GACAiC,EACAD,EAAAO,EAAAK,QAAA,eAAAX,EAEA,OAAAQ,IACAA,EAAAb,KAAAe,EACAd,EAAAY,IAEAE,EAcA,QAAAlI,GAAA8H,EAAAN,GACA,KAAAM,IACAA,EAAA,KAGAA,IAAAK,QAAA,SAOA,KADA,GAAAC,GAAA,EACA,IAAAZ,EAAAlE,QAAAwE,EAAA,OACA,GAAAO,GAAAP,EAAAQ,YAAA,IACA,IAAAD,EAAA,EACA,MAAAb,EAOA,IADAM,IAAAS,MAAA,EAAAF,GACAP,EAAAjB,MAAA,qBACA,MAAAW,KAGAY,EAIA,MAAAI,OAAAJ,EAAA,GAAAtG,KAAA,OAAA0F,EAAAiB,OAAAX,EAAAxG,OAAA,GASA,QAAAoH,GAAAC,GACA,MAAAA,GAYA,QAAAvH,GAAA4D,GACA,MAAA4D,GAAA5D,GACA,IAAAA,EAGAA,EAIA,QAAA6D,GAAA7D,GACA,MAAA4D,GAAA5D,GACAA,EAAAuD,MAAA,GAGAvD,EAIA,QAAA4D,GAAAD,GACA,IAAAA,EACA,QAGA,IAAArH,GAAAqH,EAAArH,MAEA,IAAAA,EAAA,EACA,QAGA,SAAAqH,EAAArD,WAAAhE,EAAA,IACA,KAAAqH,EAAArD,WAAAhE,EAAA,IACA,MAAAqH,EAAArD,WAAAhE,EAAA,IACA,MAAAqH,EAAArD,WAAAhE,EAAA,IACA,MAAAqH,EAAArD,WAAAhE,EAAA,IACA,MAAAqH,EAAArD,WAAAhE,EAAA,IACA,MAAAqH,EAAArD,WAAAhE,EAAA,IACA,KAAAqH,EAAArD,WAAAhE,EAAA,IACA,KAAAqH,EAAArD,WAAAhE,EAAA,GACA,QAGA,QAAA4B,GAAA5B,EAAA,GAA2B4B,GAAA,EAAQA,IACnC,QAAAyF,EAAArD,WAAApC,GACA,QAIA,UAWA,QAAA4F,GAAAC,EAAAC,EAAAC,GACA,GAAAC,GAAAH,EAAAhJ,OAAAiJ,EAAAjJ,MACA,YAAAmJ,EACAA,GAGAA,EAAAH,EAAA7I,aAAA8I,EAAA9I,aACA,IAAAgJ,EACAA,GAGAA,EAAAH,EAAA5I,eAAA6I,EAAA7I,eACA,IAAA+I,GAAAD,EACAC,GAGAA,EAAAH,EAAAjJ,gBAAAkJ,EAAAlJ,gBACA,IAAAoJ,EACAA,GAGAA,EAAAH,EAAAnJ,cAAAoJ,EAAApJ,cACA,IAAAsJ,EACAA,EAGAH,EAAA3I,KAAA4I,EAAA5I,SAaA,QAAA+I,GAAAJ,EAAAC,EAAAI,GACA,GAAAF,GAAAH,EAAAnJ,cAAAoJ,EAAApJ,aACA,YAAAsJ,EACAA,GAGAA,EAAAH,EAAAjJ,gBAAAkJ,EAAAlJ,gBACA,IAAAoJ,GAAAE,EACAF,GAGAA,EAAAH,EAAAhJ,OAAAiJ,EAAAjJ,OACA,IAAAmJ,EACAA,GAGAA,EAAAH,EAAA7I,aAAA8I,EAAA9I,aACA,IAAAgJ,EACAA,GAGAA,EAAAH,EAAA5I,eAAA6I,EAAA7I,eACA,IAAA+I,EACAA,EAGAH,EAAA3I,KAAA4I,EAAA5I,SAIA,QAAAiJ,GAAAC,EAAAC,GACA,MAAAD,KAAAC,EACA,EAGAD,EAAAC,EACA,GAGA,EAOA,QAAAnG,GAAA2F,EAAAC,GACA,GAAAE,GAAAH,EAAAnJ,cAAAoJ,EAAApJ,aACA,YAAAsJ,EACAA,GAGAA,EAAAH,EAAAjJ,gBAAAkJ,EAAAlJ,gBACA,IAAAoJ,EACAA,GAGAA,EAAAG,EAAAN,EAAAhJ,OAAAiJ,EAAAjJ,QACA,IAAAmJ,EACAA,GAGAA,EAAAH,EAAA7I,aAAA8I,EAAA9I,aACA,IAAAgJ,EACAA,GAGAA,EAAAH,EAAA5I,eAAA6I,EAAA7I,eACA,IAAA+I,EACAA,EAGAG,EAAAN,EAAA3I,KAAA4I,EAAA5I,UApYAnD,EAAAqB,QAEA,IAAAwI,GAAA,iEACAmB,EAAA,eAeAhL,GAAA0J,WAsBA1J,EAAAmK,cAwDAnK,EAAAsK,YA2DAtK,EAAA6E,OAEA7E,EAAAyK,WAAA,SAAAF,GACA,YAAAA,EAAAjC,OAAA,MAAAiC,EAAAX,MAAAC,IAyCA7J,EAAA+C,UAEA,IAAAwJ,GAAA,WACA,GAAAC,GAAAvI,OAAAC,OAAA,KACA,sBAAAsI,MAuBAxM,GAAAmE,YAAAoI,EAAAd,EAAAtH,EASAnE,EAAA4L,cAAAW,EAAAd,EAAAG,EAsEA5L,EAAA6L,6BAuCA7L,EAAAkM,sCA8CAlM,EAAAmG,uCN4sBM,SAAUlG,EAAQD,EAASM,GO3lCjC,QAAAmB,KACArB,KAAAqM,UACArM,KAAAsM,KAAAC,EAAA,GAAAC,KAAA3I,OAAAC,OAAA,MAZA,GAAA9C,GAAAd,EAAA,GACAuD,EAAAI,OAAAlC,UAAA4E,eACAgG,EAAA,mBAAAC,IAgBAnL,GAAAoL,UAAA,SAAAC,EAAAC,GAEA,OADAC,GAAA,GAAAvL,GACAwE,EAAA,EAAAC,EAAA4G,EAAAzI,OAAsC4B,EAAAC,EAASD,IAC/C+G,EAAAlJ,IAAAgJ,EAAA7G,GAAA8G,EAEA,OAAAC,IASAvL,EAAAM,UAAAkL,KAAA,WACA,MAAAN,GAAAvM,KAAAsM,KAAAO,KAAAhJ,OAAAiJ,oBAAA9M,KAAAsM,MAAArI,QAQA5C,EAAAM,UAAA+B,IAAA,SAAAiE,EAAAgF,GACA,GAAAI,GAAAR,EAAA5E,EAAA3G,EAAA+C,YAAA4D,GACAqF,EAAAT,EAAAvM,KAAAyD,IAAAkE,GAAAlE,EAAAlD,KAAAP,KAAAsM,KAAAS,GACAE,EAAAjN,KAAAqM,OAAApI,MACA+I,KAAAL,GACA3M,KAAAqM,OAAAa,KAAAvF,GAEAqF,IACAT,EACAvM,KAAAsM,KAAAM,IAAAjF,EAAAsF,GAEAjN,KAAAsM,KAAAS,GAAAE,IAUA5L,EAAAM,UAAA8B,IAAA,SAAAkE,GACA,GAAA4E,EACA,MAAAvM,MAAAsM,KAAA7I,IAAAkE,EAEA,IAAAoF,GAAA/L,EAAA+C,YAAA4D,EACA,OAAAlE,GAAAlD,KAAAP,KAAAsM,KAAAS,IASA1L,EAAAM,UAAAsE,QAAA,SAAA0B,GACA,GAAA4E,EAAA,CACA,GAAAU,GAAAjN,KAAAsM,KAAAa,IAAAxF,EACA,IAAAsF,GAAA,EACA,MAAAA,OAEG,CACH,GAAAF,GAAA/L,EAAA+C,YAAA4D,EACA,IAAAlE,EAAAlD,KAAAP,KAAAsM,KAAAS,GACA,MAAA/M,MAAAsM,KAAAS,GAIA,SAAA3I,OAAA,IAAAuD,EAAA,yBAQAtG,EAAAM,UAAAyL,GAAA,SAAAC,GACA,GAAAA,GAAA,GAAAA,EAAArN,KAAAqM,OAAApI,OACA,MAAAjE,MAAAqM,OAAAgB,EAEA,UAAAjJ,OAAA,yBAAAiJ,IAQAhM,EAAAM,UAAAiE,QAAA,WACA,MAAA5F,MAAAqM,OAAAnB,SAGAtL,EAAAyB,YPmnCM,SAAUxB,EAAQD,EAASM,GQ9tCjC,QAAAoN,GAAA5B,EAAAC,GAEA,GAAA4B,GAAA7B,EAAAnJ,cACAiL,EAAA7B,EAAApJ,cACAkL,EAAA/B,EAAAjJ,gBACAiL,EAAA/B,EAAAlJ,eACA,OAAA+K,GAAAD,GAAAC,GAAAD,GAAAG,GAAAD,GACAzM,EAAA+E,oCAAA2F,EAAAC,IAAA,EAQA,QAAAnK,KACAxB,KAAAqM,UACArM,KAAA2N,SAAA,EAEA3N,KAAA4N,OAAgBrL,eAAA,EAAAE,gBAAA,GAzBhB,GAAAzB,GAAAd,EAAA,EAkCAsB,GAAAG,UAAA4C,gBACA,SAAAsJ,EAAAC,GACA9N,KAAAqM,OAAAnJ,QAAA2K,EAAAC,IAQAtM,EAAAG,UAAA+B,IAAA,SAAAqK,GACAT,EAAAtN,KAAA4N,MAAAG,IACA/N,KAAA4N,MAAAG,EACA/N,KAAAqM,OAAAa,KAAAa,KAEA/N,KAAA2N,SAAA,EACA3N,KAAAqM,OAAAa,KAAAa,KAaAvM,EAAAG,UAAAiE,QAAA,WAKA,MAJA5F,MAAA2N,UACA3N,KAAAqM,OAAA2B,KAAAhN,EAAA+E,qCACA/F,KAAA2N,SAAA,GAEA3N,KAAAqM,QAGAzM,EAAA4B,eRkvCM,SAAU3B,EAAQD,EAASM,GSnzCjC,QAAAU,GAAAqN,GACA,GAAAC,GAAAD,CAKA,OAJA,gBAAAA,KACAC,EAAApJ,KAAAqJ,MAAAF,EAAAnD,QAAA,WAAsD,MAGtD,MAAAoD,EAAAE,SACA,GAAAC,GAAAH,GACA,GAAAI,GAAAJ,GAoQA,QAAAI,GAAAL,GACA,GAAAC,GAAAD,CACA,iBAAAA,KACAC,EAAApJ,KAAAqJ,MAAAF,EAAAnD,QAAA,WAAsD,KAGtD,IAAArE,GAAAzF,EAAAC,OAAAiN,EAAA,WACAjL,EAAAjC,EAAAC,OAAAiN,EAAA,WAGAxH,EAAA1F,EAAAC,OAAAiN,EAAA,YACAnM,EAAAf,EAAAC,OAAAiN,EAAA,mBACAvH,EAAA3F,EAAAC,OAAAiN,EAAA,uBACAvI,EAAA3E,EAAAC,OAAAiN,EAAA,YACAjM,EAAAjB,EAAAC,OAAAiN,EAAA,YAIA,IAAAzH,GAAAzG,KAAA4B,SACA,SAAAwC,OAAA,wBAAAqC,EAGAxD,KACAoD,IAAA7C,QAIA6C,IAAArF,EAAAkJ,WAKA7D,IAAA,SAAA3D,GACA,MAAAX,IAAAf,EAAAqJ,WAAAtI,IAAAf,EAAAqJ,WAAA3H,GACA1B,EAAA2B,SAAAZ,EAAAW,GACAA,IAOA1C,KAAAsB,OAAAD,EAAAoL,UAAA/F,EAAAL,IAAA7C,SAAA,GACAxD,KAAAoB,SAAAC,EAAAoL,UAAAxJ,GAAA,GAEAjD,KAAA+B,aACA/B,KAAA2G,iBACA3G,KAAAuB,UAAAoE,EACA3F,KAAAiC,OA8EA,QAAAsM,KACAvO,KAAAuC,cAAA,EACAvC,KAAAyC,gBAAA,EACAzC,KAAA0C,OAAA,KACA1C,KAAA6C,aAAA,KACA7C,KAAA8C,eAAA,KACA9C,KAAA+C,KAAA,KAyZA,QAAAsL,GAAAJ,GACA,GAAAC,GAAAD,CACA,iBAAAA,KACAC,EAAApJ,KAAAqJ,MAAAF,EAAAnD,QAAA,WAAsD,KAGtD,IAAArE,GAAAzF,EAAAC,OAAAiN,EAAA,WACAE,EAAApN,EAAAC,OAAAiN,EAAA,WAEA,IAAAzH,GAAAzG,KAAA4B,SACA,SAAAwC,OAAA,wBAAAqC,EAGAzG,MAAAoB,SAAA,GAAAC,GACArB,KAAAsB,OAAA,GAAAD,EAEA,IAAAmN,IACAlM,MAAA,EACAE,OAAA,EAEAxC,MAAAyO,UAAAL,EAAA/H,IAAA,SAAAiF,GACA,GAAAA,EAAArB,IAGA,SAAA7F,OAAA,qDAEA,IAAAsK,GAAA1N,EAAAC,OAAAqK,EAAA,UACAqD,EAAA3N,EAAAC,OAAAyN,EAAA,QACAE,EAAA5N,EAAAC,OAAAyN,EAAA,SAEA,IAAAC,EAAAH,EAAAlM,MACAqM,IAAAH,EAAAlM,MAAAsM,EAAAJ,EAAAhM,OACA,SAAA4B,OAAA,uDAIA,OAFAoK,GAAAE,GAGAG,iBAGAtM,cAAAoM,EAAA,EACAlM,gBAAAmM,EAAA,GAEAE,SAAA,GAAAlO,GAAAI,EAAAC,OAAAqK,EAAA,WA11BA,GAAAtK,GAAAd,EAAA,GACA6O,EAAA7O,EAAA,GACAmB,EAAAnB,EAAA,GAAAmB,SACAK,EAAAxB,EAAA,GACA8O,EAAA9O,EAAA,GAAA8O,SAaApO,GAAAiB,cAAA,SAAAoM,GACA,MAAAK,GAAAzM,cAAAoM,IAMArN,EAAAe,UAAAC,SAAA,EAgCAhB,EAAAe,UAAAsN,oBAAA,KACApL,OAAAqL,eAAAtO,EAAAe,UAAA,sBACAwL,IAAA,WAKA,MAJAnN,MAAAiP,qBACAjP,KAAAmP,eAAAnP,KAAAuB,UAAAvB,KAAA+B,YAGA/B,KAAAiP,uBAIArO,EAAAe,UAAAyN,mBAAA,KACAvL,OAAAqL,eAAAtO,EAAAe,UAAA,qBACAwL,IAAA,WAKA,MAJAnN,MAAAoP,oBACApP,KAAAmP,eAAAnP,KAAAuB,UAAAvB,KAAA+B,YAGA/B,KAAAoP,sBAIAxO,EAAAe,UAAA0N,wBACA,SAAA1H,EAAAqD,GACA,GAAAvK,GAAAkH,EAAAO,OAAA8C,EACA,aAAAvK,GAAmB,MAAAA,GAQnBG,EAAAe,UAAAwN,eACA,SAAAxH,EAAAvB,GACA,SAAAhC,OAAA,6CAGAxD,EAAA0O,gBAAA,EACA1O,EAAA2O,eAAA,EAEA3O,EAAA4O,qBAAA,EACA5O,EAAA6O,kBAAA,EAkBA7O,EAAAe,UAAAO,YACA,SAAA2L,EAAA6B,EAAAC,GACA,GAGAhK,GAHAiK,EAAAF,GAAA,KACAG,EAAAF,GAAA/O,EAAA0O,eAGA,QAAAO,GACA,IAAAjP,GAAA0O,gBACA3J,EAAA3F,KAAA8P,kBACA,MACA,KAAAlP,GAAA2O,eACA5J,EAAA3F,KAAA+P,iBACA,MACA,SACA,SAAA3L,OAAA,+BAGA,GAAArC,GAAA/B,KAAA+B,UACA4D,GAAAU,IAAA,SAAAlE,GACA,GAAAO,GAAA,OAAAP,EAAAO,OAAA,KAAA1C,KAAAoB,SAAAgM,GAAAjL,EAAAO,OAIA,OAHA,OAAAA,GAAA,MAAAX,IACAW,EAAA1B,EAAAyD,KAAA1C,EAAAW,KAGAA,SACAH,cAAAJ,EAAAI,cACAE,gBAAAN,EAAAM,gBACAI,aAAAV,EAAAU,aACAC,eAAAX,EAAAW,eACAC,KAAA,OAAAZ,EAAAY,KAAA,KAAA/C,KAAAsB,OAAA8L,GAAAjL,EAAAY,QAEK/C,MAAAkD,QAAA2K,EAAA+B,IAsBLhP,EAAAe,UAAAqO,yBACA,SAAAlP,GACA,GAAAwB,GAAAtB,EAAAC,OAAAH,EAAA,QAMAmP,GACAvN,OAAA1B,EAAAC,OAAAH,EAAA,UACA+B,aAAAP,EACAQ,eAAA9B,EAAAC,OAAAH,EAAA,YAMA,IAHA,MAAAd,KAAA+B,aACAkO,EAAAvN,OAAA1B,EAAA2B,SAAA3C,KAAA+B,WAAAkO,EAAAvN,UAEA1C,KAAAoB,SAAAqC,IAAAwM,EAAAvN,QACA,QAEAuN,GAAAvN,OAAA1C,KAAAoB,SAAA6E,QAAAgK,EAAAvN,OAEA,IAAAiD,MAEAqF,EAAAhL,KAAAkQ,aAAAD,EACAjQ,KAAA+P,kBACA,eACA,iBACA/O,EAAAyK,2BACAsD,EAAAU,kBACA,IAAAzE,GAAA,GACA,GAAA7I,GAAAnC,KAAA+P,kBAAA/E,EAEA,IAAAmF,SAAArP,EAAA0B,OAOA,IANA,GAAAK,GAAAV,EAAAU,aAMAV,KAAAU,kBACA8C,EAAAuH,MACA5K,KAAAtB,EAAAC,OAAAkB,EAAA,sBACAK,OAAAxB,EAAAC,OAAAkB,EAAA,wBACAiO,WAAApP,EAAAC,OAAAkB,EAAA,8BAGAA,EAAAnC,KAAA+P,oBAAA/E,OASA,KANA,GAAAlI,GAAAX,EAAAW,eAMAX,GACAA,EAAAU,eAAAP,GACAH,EAAAW,mBACA6C,EAAAuH,MACA5K,KAAAtB,EAAAC,OAAAkB,EAAA,sBACAK,OAAAxB,EAAAC,OAAAkB,EAAA,wBACAiO,WAAApP,EAAAC,OAAAkB,EAAA,8BAGAA,EAAAnC,KAAA+P,oBAAA/E,GAKA,MAAArF,IAGA/F,EAAAgB,oBAmFA0N,EAAA3M,UAAAkC,OAAAC,OAAAlD,EAAAe,WACA2M,EAAA3M,UAAAmN,SAAAlO,EASA0N,EAAAzM,cACA,SAAAoM,GACA,GAAAoC,GAAAxM,OAAAC,OAAAwK,EAAA3M,WAEA+E,EAAA2J,EAAA/O,OAAAD,EAAAoL,UAAAwB,EAAA3M,OAAAsE,WAAA,GACA3C,EAAAoN,EAAAjP,SAAAC,EAAAoL,UAAAwB,EAAA7M,SAAAwE,WAAA,EACAyK,GAAAtO,WAAAkM,EAAA/M,YACAmP,EAAA1J,eAAAsH,EAAA/H,wBAAAmK,EAAAjP,SAAAwE,UACAyK,EAAAtO,YACAsO,EAAApO,KAAAgM,EAAAlN,KAWA,QAJAuP,GAAArC,EAAA1M,UAAAqE,UAAAsF,QACAqF,EAAAF,EAAApB,uBACAuB,EAAAH,EAAAjB,sBAEAvJ,EAAA,EAAA5B,EAAAqM,EAAArM,OAAsD4B,EAAA5B,EAAY4B,IAAA,CAClE,GAAA4K,GAAAH,EAAAzK,GACA6K,EAAA,GAAAnC,EACAmC,GAAAnO,cAAAkO,EAAAlO,cACAmO,EAAAjO,gBAAAgO,EAAAhO,gBAEAgO,EAAA/N,SACAgO,EAAAhO,OAAAO,EAAAgD,QAAAwK,EAAA/N,QACAgO,EAAA7N,aAAA4N,EAAA5N,aACA6N,EAAA5N,eAAA2N,EAAA3N,eAEA2N,EAAA1N,OACA2N,EAAA3N,KAAA2D,EAAAT,QAAAwK,EAAA1N,OAGAyN,EAAAtD,KAAAwD,IAGAH,EAAArD,KAAAwD,GAKA,MAFA1B,GAAAqB,EAAAjB,mBAAApO,EAAAyK,4BAEA4E,GAMA/B,EAAA3M,UAAAC,SAAA,EAKAiC,OAAAqL,eAAAZ,EAAA3M,UAAA,WACAwL,IAAA,WACA,MAAAnN,MAAAoB,SAAAwE,UAAAS,IAAA,SAAAiF,GACA,aAAAtL,KAAA+B,WAAAf,EAAAyD,KAAAzE,KAAA+B,WAAAuJ,MACKtL,SAqBLsO,EAAA3M,UAAAwN,eACA,SAAAxH,EAAAvB,GAeA,IAdA,GAYAjE,GAAAwO,EAAAC,EAAAC,EAAA1I,EAZA5F,EAAA,EACA6C,EAAA,EACAG,EAAA,EACAD,EAAA,EACAG,EAAA,EACAD,EAAA,EACAvB,EAAA0D,EAAA1D,OACA+G,EAAA,EACA8F,KACAC,KACAC,KACAV,KAGAtF,EAAA/G,GACA,SAAA0D,EAAAO,OAAA8C,GACAzI,IACAyI,IACA5F,EAAA,MAEA,UAAAuC,EAAAO,OAAA8C,GACAA,QAEA,CASA,IARA7I,EAAA,GAAAoM,GACApM,EAAAI,gBAOAsO,EAAA7F,EAAyB6F,EAAA5M,IACzBjE,KAAAqP,wBAAA1H,EAAAkJ,GADuCA,KAQvC,GAHAF,EAAAhJ,EAAAuD,MAAAF,EAAA6F,GAEAD,EAAAE,EAAAH,GAEA3F,GAAA2F,EAAA1M,WACS,CAET,IADA2M,KACA5F,EAAA6F,GACAnP,EAAAgG,OAAAC,EAAAqD,EAAA+F,GACA5I,EAAA4I,EAAA5I,MACA6C,EAAA+F,EAAA3I,KACAwI,EAAA1D,KAAA/E,EAGA,QAAAyI,EAAA3M,OACA,SAAAG,OAAA,yCAGA,QAAAwM,EAAA3M,OACA,SAAAG,OAAA,yCAGA0M,GAAAH,GAAAC,EAIAzO,EAAAM,gBAAA2C,EAAAwL,EAAA,GACAxL,EAAAjD,EAAAM,gBAEAmO,EAAA3M,OAAA,IAEA9B,EAAAO,OAAA+C,EAAAmL,EAAA,GACAnL,GAAAmL,EAAA,GAGAzO,EAAAU,aAAA0C,EAAAqL,EAAA,GACArL,EAAApD,EAAAU,aAEAV,EAAAU,cAAA,EAGAV,EAAAW,eAAAwC,EAAAsL,EAAA,GACAtL,EAAAnD,EAAAW,eAEA8N,EAAA3M,OAAA,IAEA9B,EAAAY,KAAAyC,EAAAoL,EAAA,GACApL,GAAAoL,EAAA,KAIAN,EAAApD,KAAA/K,GACA,gBAAAA,GAAAU,cACAmO,EAAA9D,KAAA/K,GAKA6M,EAAAsB,EAAAtP,EAAA8K,qCACA9L,KAAAiP,oBAAAqB,EAEAtB,EAAAgC,EAAAhQ,EAAAyK,4BACAzL,KAAAoP,mBAAA4B,GAOA1C,EAAA3M,UAAAuO,aACA,SAAAe,EAAAC,EAAAC,EACAC,EAAAC,EAAAC,GAMA,GAAAL,EAAAE,IAAA,EACA,SAAA3I,WAAA,gDACAyI,EAAAE,GAEA,IAAAF,EAAAG,GAAA,EACA,SAAA5I,WAAA,kDACAyI,EAAAG,GAGA,OAAArC,GAAAwC,OAAAN,EAAAC,EAAAG,EAAAC,IAOAhD,EAAA3M,UAAA6P,mBACA,WACA,OAAAxG,GAAA,EAAuBA,EAAAhL,KAAA8P,mBAAA7L,SAAwC+G,EAAA,CAC/D,GAAA7I,GAAAnC,KAAA8P,mBAAA9E,EAMA,IAAAA,EAAA,EAAAhL,KAAA8P,mBAAA7L,OAAA,CACA,GAAAwN,GAAAzR,KAAA8P,mBAAA9E,EAAA,EAEA,IAAA7I,EAAAI,gBAAAkP,EAAAlP,cAAA,CACAJ,EAAAuP,oBAAAD,EAAAhP,gBAAA,CACA,WAKAN,EAAAuP,oBAAAC,MAwBArD,EAAA3M,UAAA6C,oBACA,SAAA1D,GACA,GAAAmP,IACA1N,cAAAvB,EAAAC,OAAAH,EAAA,QACA2B,gBAAAzB,EAAAC,OAAAH,EAAA,WAGAkK,EAAAhL,KAAAkQ,aACAD,EACAjQ,KAAA8P,mBACA,gBACA,kBACA9O,EAAA8K,oCACA9K,EAAAC,OAAAH,EAAA,OAAAF,EAAA4O,sBAGA,IAAAxE,GAAA,GACA,GAAA7I,GAAAnC,KAAA8P,mBAAA9E,EAEA,IAAA7I,EAAAI,gBAAA0N,EAAA1N,cAAA,CACA,GAAAG,GAAA1B,EAAAC,OAAAkB,EAAA,cACA,QAAAO,IACAA,EAAA1C,KAAAoB,SAAAgM,GAAA1K,GACA,MAAA1C,KAAA+B,aACAW,EAAA1B,EAAAyD,KAAAzE,KAAA+B,WAAAW,IAGA,IAAAK,GAAA/B,EAAAC,OAAAkB,EAAA,YAIA,OAHA,QAAAY,IACAA,EAAA/C,KAAAsB,OAAA8L,GAAArK,KAGAL,SACAJ,KAAAtB,EAAAC,OAAAkB,EAAA,qBACAK,OAAAxB,EAAAC,OAAAkB,EAAA,uBACAY,SAKA,OACAL,OAAA,KACAJ,KAAA,KACAE,OAAA,KACAO,KAAA,OAQAuL,EAAA3M,UAAAiQ,wBACA,WACA,QAAA5R,KAAA2G,iBAGA3G,KAAA2G,eAAA1C,QAAAjE,KAAAoB,SAAAyL,SACA7M,KAAA2G,eAAAkL,KAAA,SAAAC,GAA+C,aAAAA,MAQ/CxD,EAAA3M,UAAA0B,iBACA,SAAAuB,EAAAmN,GACA,IAAA/R,KAAA2G,eACA,WAOA,IAJA,MAAA3G,KAAA+B,aACA6C,EAAA5D,EAAA2B,SAAA3C,KAAA+B,WAAA6C,IAGA5E,KAAAoB,SAAAqC,IAAAmB,GACA,MAAA5E,MAAA2G,eAAA3G,KAAAoB,SAAA6E,QAAArB,GAGA,IAAAqF,EACA,UAAAjK,KAAA+B,aACAkI,EAAAjJ,EAAAsI,SAAAtJ,KAAA+B,aAAA,CAKA,GAAAiQ,GAAApN,EAAAkG,QAAA,gBACA,YAAAb,EAAAP,QACA1J,KAAAoB,SAAAqC,IAAAuO,GACA,MAAAhS,MAAA2G,eAAA3G,KAAAoB,SAAA6E,QAAA+L,GAGA,MAAA/H,EAAAH,MAAA,KAAAG,EAAAH,OACA9J,KAAAoB,SAAAqC,IAAA,IAAAmB,GACA,MAAA5E,MAAA2G,eAAA3G,KAAAoB,SAAA6E,QAAA,IAAArB,IAQA,GAAAmN,EACA,WAGA,UAAA3N,OAAA,IAAAQ,EAAA,+BAuBA0J,EAAA3M,UAAAsQ,qBACA,SAAAnR,GACA,GAAA4B,GAAA1B,EAAAC,OAAAH,EAAA,SAIA,IAHA,MAAAd,KAAA+B,aACAW,EAAA1B,EAAA2B,SAAA3C,KAAA+B,WAAAW,KAEA1C,KAAAoB,SAAAqC,IAAAf,GACA,OACAJ,KAAA,KACAE,OAAA,KACA4N,WAAA,KAGA1N,GAAA1C,KAAAoB,SAAA6E,QAAAvD,EAEA,IAAAuN,IACAvN,SACAG,aAAA7B,EAAAC,OAAAH,EAAA,QACAgC,eAAA9B,EAAAC,OAAAH,EAAA,WAGAkK,EAAAhL,KAAAkQ,aACAD,EACAjQ,KAAA+P,kBACA,eACA,iBACA/O,EAAAyK,2BACAzK,EAAAC,OAAAH,EAAA,OAAAF,EAAA4O,sBAGA,IAAAxE,GAAA,GACA,GAAA7I,GAAAnC,KAAA+P,kBAAA/E,EAEA,IAAA7I,EAAAO,SAAAuN,EAAAvN,OACA,OACAJ,KAAAtB,EAAAC,OAAAkB,EAAA,sBACAK,OAAAxB,EAAAC,OAAAkB,EAAA,wBACAiO,WAAApP,EAAAC,OAAAkB,EAAA,6BAKA,OACAG,KAAA,KACAE,OAAA,KACA4N,WAAA,OAIAxQ,EAAA0O,yBA+FAD,EAAA1M,UAAAkC,OAAAC,OAAAlD,EAAAe,WACA0M,EAAA1M,UAAAuQ,YAAAtR,EAKAyN,EAAA1M,UAAAC,SAAA,EAKAiC,OAAAqL,eAAAb,EAAA1M,UAAA,WACAwL,IAAA,WAEA,OADAlK,MACA4C,EAAA,EAAmBA,EAAA7F,KAAAyO,UAAAxK,OAA2B4B,IAC9C,OAAAsM,GAAA,EAAqBA,EAAAnS,KAAAyO,UAAA5I,GAAAiJ,SAAA7L,QAAAgB,OAA+CkO,IACpElP,EAAAiK,KAAAlN,KAAAyO,UAAA5I,GAAAiJ,SAAA7L,QAAAkP,GAGA,OAAAlP,MAmBAoL,EAAA1M,UAAA6C,oBACA,SAAA1D,GACA,GAAAmP,IACA1N,cAAAvB,EAAAC,OAAAH,EAAA,QACA2B,gBAAAzB,EAAAC,OAAAH,EAAA,WAKAsR,EAAArD,EAAAwC,OAAAtB,EAAAjQ,KAAAyO,UACA,SAAAwB,EAAAoC,GACA,GAAAxG,GAAAoE,EAAA1N,cAAA8P,EAAAxD,gBAAAtM,aACA,OAAAsJ,GACAA,EAGAoE,EAAAxN,gBACA4P,EAAAxD,gBAAApM,kBAEA4P,EAAArS,KAAAyO,UAAA2D,EAEA,OAAAC,GASAA,EAAAvD,SAAAtK,qBACAlC,KAAA2N,EAAA1N,eACA8P,EAAAxD,gBAAAtM,cAAA,GACAC,OAAAyN,EAAAxN,iBACA4P,EAAAxD,gBAAAtM,gBAAA0N,EAAA1N,cACA8P,EAAAxD,gBAAApM,gBAAA,EACA,GACA6P,KAAAxR,EAAAwR,QAdA5P,OAAA,KACAJ,KAAA,KACAE,OAAA,KACAO,KAAA,OAmBAsL,EAAA1M,UAAAiQ,wBACA,WACA,MAAA5R,MAAAyO,UAAA8D,MAAA,SAAAjH,GACA,MAAAA,GAAAwD,SAAA8C,6BASAvD,EAAA1M,UAAA0B,iBACA,SAAAuB,EAAAmN,GACA,OAAAlM,GAAA,EAAmBA,EAAA7F,KAAAyO,UAAAxK,OAA2B4B,IAAA,CAC9C,GAAAwM,GAAArS,KAAAyO,UAAA5I,GAEAzC,EAAAiP,EAAAvD,SAAAzL,iBAAAuB,GAAA,EACA,IAAAxB,EACA,MAAAA,GAGA,GAAA2O,EACA,WAGA,UAAA3N,OAAA,IAAAQ,EAAA,+BAkBAyJ,EAAA1M,UAAAsQ,qBACA,SAAAnR,GACA,OAAA+E,GAAA,EAAmBA,EAAA7F,KAAAyO,UAAAxK,OAA2B4B,IAAA,CAC9C,GAAAwM,GAAArS,KAAAyO,UAAA5I,EAIA,IAAAwM,EAAAvD,SAAA7L,QAAAgD,QAAAjF,EAAAC,OAAAH,EAAA,iBAGA,GAAA0R,GAAAH,EAAAvD,SAAAmD,qBAAAnR,EACA,IAAA0R,EAAA,CACA,GAAAC,IACAnQ,KAAAkQ,EAAAlQ,MACA+P,EAAAxD,gBAAAtM,cAAA,GACAC,OAAAgQ,EAAAhQ,QACA6P,EAAAxD,gBAAAtM,gBAAAiQ,EAAAlQ,KACA+P,EAAAxD,gBAAApM,gBAAA,EACA,GAEA,OAAAgQ,KAIA,OACAnQ,KAAA,KACAE,OAAA,OASA6L,EAAA1M,UAAAwN,eACA,SAAAxH,EAAAvB,GACApG,KAAAiP,uBACAjP,KAAAoP,qBACA,QAAAvJ,GAAA,EAAmBA,EAAA7F,KAAAyO,UAAAxK,OAA2B4B,IAG9C,OAFAwM,GAAArS,KAAAyO,UAAA5I,GACA6M,EAAAL,EAAAvD,SAAAgB,mBACAqC,EAAA,EAAqBA,EAAAO,EAAAzO,OAA4BkO,IAAA,CACjD,GAAAhQ,GAAAuQ,EAAAP,GAEAzP,EAAA2P,EAAAvD,SAAA1N,SAAAgM,GAAAjL,EAAAO,OACA,QAAA2P,EAAAvD,SAAA/M,aACAW,EAAA1B,EAAAyD,KAAA4N,EAAAvD,SAAA/M,WAAAW,IAEA1C,KAAAoB,SAAAsC,IAAAhB,GACAA,EAAA1C,KAAAoB,SAAA6E,QAAAvD,EAEA,IAAAK,GAAAsP,EAAAvD,SAAAxN,OAAA8L,GAAAjL,EAAAY,KACA/C,MAAAsB,OAAAoC,IAAAX,GACAA,EAAA/C,KAAAsB,OAAA2E,QAAAlD,EAMA,IAAA4P,IACAjQ,SACAH,cAAAJ,EAAAI,eACA8P,EAAAxD,gBAAAtM,cAAA,GACAE,gBAAAN,EAAAM,iBACA4P,EAAAxD,gBAAAtM,gBAAAJ,EAAAI,cACA8P,EAAAxD,gBAAApM,gBAAA,EACA,GACAI,aAAAV,EAAAU,aACAC,eAAAX,EAAAW,eACAC,OAGA/C,MAAAiP,oBAAA/B,KAAAyF,GACA,gBAAAA,GAAA9P,cACA7C,KAAAoP,mBAAAlC,KAAAyF,GAKA3D,EAAAhP,KAAAiP,oBAAAjO,EAAA8K,qCACAkD,EAAAhP,KAAAoP,mBAAApO,EAAAyK,6BAGA7L,EAAAyO,4BTu0CM,SAAUxO,EAAQD,GUz2ExB,QAAAgT,GAAAC,EAAAC,EAAA7B,EAAA8B,EAAAC,EAAA1B,GAUA,GAAA2B,GAAAC,KAAAC,OAAAL,EAAAD,GAAA,GAAAA,EACAhH,EAAAmH,EAAA/B,EAAA8B,EAAAE,IAAA,EACA,YAAApH,EAEAoH,EAEApH,EAAA,EAEAiH,EAAAG,EAAA,EAEAL,EAAAK,EAAAH,EAAA7B,EAAA8B,EAAAC,EAAA1B,GAKAA,GAAA1R,EAAA6P,kBACAqD,EAAAC,EAAA9O,OAAA6O,GAAA,EAEAG,EAKAA,EAAAJ,EAAA,EAEAD,EAAAC,EAAAI,EAAAhC,EAAA8B,EAAAC,EAAA1B,GAIAA,GAAA1R,EAAA6P,kBACAwD,EAEAJ,EAAA,KAAAA,EA1DAjT,EAAA4P,qBAAA,EACA5P,EAAA6P,kBAAA,EAgFA7P,EAAA2R,OAAA,SAAAN,EAAA8B,EAAAC,EAAA1B,GACA,OAAAyB,EAAA9O,OACA,QAGA,IAAA+G,GAAA4H,GAAA,EAAAG,EAAA9O,OAAAgN,EAAA8B,EACAC,EAAA1B,GAAA1R,EAAA4P,qBACA,IAAAxE,EAAA,EACA,QAMA,MAAAA,EAAA,MACA,IAAAgI,EAAAD,EAAA/H,GAAA+H,EAAA/H,EAAA,UAGAA,CAGA,OAAAA,KVw4EM,SAAUnL,EAAQD,GW19ExB,QAAAwT,GAAAC,EAAAC,EAAAC,GACA,GAAAxC,GAAAsC,EAAAC,EACAD,GAAAC,GAAAD,EAAAE,GACAF,EAAAE,GAAAxC,EAWA,QAAAyC,GAAAC,EAAAC,GACA,MAAAR,MAAAS,MAAAF,EAAAP,KAAAU,UAAAF,EAAAD,IAeA,QAAAI,GAAAR,EAAAS,EAAApT,EAAAqT,GAKA,GAAArT,EAAAqT,EAAA,CAYA,GAAAC,GAAAR,EAAA9S,EAAAqT,GACAlO,EAAAnF,EAAA,CAEA0S,GAAAC,EAAAW,EAAAD,EASA,QARAE,GAAAZ,EAAAU,GAQA5B,EAAAzR,EAAmByR,EAAA4B,EAAO5B,IAC1B2B,EAAAT,EAAAlB,GAAA8B,IAAA,IACApO,GAAA,EACAuN,EAAAC,EAAAxN,EAAAsM,GAIAiB,GAAAC,EAAAxN,EAAA,EAAAsM,EACA,IAAA+B,GAAArO,EAAA,CAIAgO,GAAAR,EAAAS,EAAApT,EAAAwT,EAAA,GACAL,EAAAR,EAAAS,EAAAI,EAAA,EAAAH,IAYAnU,EAAAoP,UAAA,SAAAqE,EAAAS,GACAD,EAAAR,EAAAS,EAAA,EAAAT,EAAApP,OAAA,KX6/EM,SAAUpE,EAAQD,EAASM,GY3kFjC,QAAAW,GAAAsT,EAAAC,EAAAxP,EAAAyP,EAAAxP,GACA7E,KAAAsU,YACAtU,KAAAuU,kBACAvU,KAAAsC,KAAA,MAAA6R,EAAA,KAAAA,EACAnU,KAAAwC,OAAA,MAAA4R,EAAA,KAAAA,EACApU,KAAA0C,OAAA,MAAAkC,EAAA,KAAAA,EACA5E,KAAA+C,KAAA,MAAA8B,EAAA,KAAAA,EACA7E,KAAAwU,IAAA,EACA,MAAAH,GAAArU,KAAA0D,IAAA2Q,GAnCA,GAAA1T,GAAAT,EAAA,GAAAS,mBACAK,EAAAd,EAAA,GAIAuU,EAAA,UAGAC,EAAA,GAKAF,EAAA,oBAiCA3T,GAAA8T,wBACA,SAAAC,EAAA9S,EAAA+S,GA+FA,QAAAC,GAAA3S,EAAA4S,GACA,UAAA5S,GAAAgO,SAAAhO,EAAAO,OACAsS,EAAAtR,IAAAqR,OACO,CACP,GAAArS,GAAAmS,EACA7T,EAAAyD,KAAAoQ,EAAA1S,EAAAO,QACAP,EAAAO,MACAsS,GAAAtR,IAAA,GAAA7C,GAAAsB,EAAAU,aACAV,EAAAW,eACAJ,EACAqS,EACA5S,EAAAY,QAvGA,GAAAiS,GAAA,GAAAnU,GAMAoU,EAAAL,EAAAtM,MAAAmM,GACAS,EAAA,EACAC,EAAA,WAMA,QAAAC,KACA,MAAAF,GAAAD,EAAAhR,OACAgR,EAAAC,KAAA/E,OAPA,GAAAkF,GAAAD,IAEAE,EAAAF,KAAA,EACA,OAAAC,GAAAC,GASAC,EAAA,EAAA7D,EAAA,EAKA8D,EAAA,IAgEA,OA9DA1T,GAAAI,YAAA,SAAAC,GACA,UAAAqT,EAAA,CAGA,KAAAD,EAAApT,EAAAI,eAMS,CAIT,GAAAkT,GAAAR,EAAAC,GACAH,EAAAU,EAAArK,OAAA,EAAAjJ,EAAAM,gBACAiP,EAOA,OANAuD,GAAAC,GAAAO,EAAArK,OAAAjJ,EAAAM,gBACAiP,GACAA,EAAAvP,EAAAM,gBACAqS,EAAAU,EAAAT,QAEAS,EAAArT,GAhBA2S,EAAAU,EAAAL,KACAI,IACA7D,EAAA,EAqBA,KAAA6D,EAAApT,EAAAI,eACAyS,EAAAtR,IAAAyR,KACAI,GAEA,IAAA7D,EAAAvP,EAAAM,gBAAA,CACA,GAAAgT,GAAAR,EAAAC,EACAF,GAAAtR,IAAA+R,EAAArK,OAAA,EAAAjJ,EAAAM,kBACAwS,EAAAC,GAAAO,EAAArK,OAAAjJ,EAAAM,iBACAiP,EAAAvP,EAAAM,gBAEA+S,EAAArT,GACKnC,MAELkV,EAAAD,EAAAhR,SACAuR,GAEAV,EAAAU,EAAAL,KAGAH,EAAAtR,IAAAuR,EAAAzK,OAAA0K,GAAAzQ,KAAA,MAIA3C,EAAAmB,QAAAC,QAAA,SAAAC,GACA,GAAAC,GAAAtB,EAAAuB,iBAAAF,EACA,OAAAC,IACA,MAAAyR,IACA1R,EAAAnC,EAAAyD,KAAAoQ,EAAA1R,IAEA6R,EAAA1R,iBAAAH,EAAAC,MAIA4R,GAwBAnU,EAAAc,UAAA+B,IAAA,SAAAgS,GACA,GAAAvK,MAAAwK,QAAAD,GACAA,EAAAxS,QAAA,SAAA0S,GACA5V,KAAA0D,IAAAkS,IACK5V,UAEL,KAAA0V,EAAAlB,IAAA,gBAAAkB,GAMA,SAAAlN,WACA,8EAAAkN,EANAA,IACA1V,KAAAsU,SAAApH,KAAAwI,GAQA,MAAA1V,OASAa,EAAAc,UAAAkU,QAAA,SAAAH,GACA,GAAAvK,MAAAwK,QAAAD,GACA,OAAA7P,GAAA6P,EAAAzR,OAAA,EAAiC4B,GAAA,EAAQA,IACzC7F,KAAA6V,QAAAH,EAAA7P,QAGA,KAAA6P,EAAAlB,IAAA,gBAAAkB,GAIA,SAAAlN,WACA,8EAAAkN,EAJA1V,MAAAsU,SAAAwB,QAAAJ,GAOA,MAAA1V,OAUAa,EAAAc,UAAAoU,KAAA,SAAAC,GAEA,OADAJ,GACA/P,EAAA,EAAAC,EAAA9F,KAAAsU,SAAArQ,OAA6C4B,EAAAC,EAASD,IACtD+P,EAAA5V,KAAAsU,SAAAzO,GACA+P,EAAApB,GACAoB,EAAAG,KAAAC,GAGA,KAAAJ,GACAI,EAAAJ,GAAoBlT,OAAA1C,KAAA0C,OACpBJ,KAAAtC,KAAAsC,KACAE,OAAAxC,KAAAwC,OACAO,KAAA/C,KAAA+C,QAYAlC,EAAAc,UAAA8C,KAAA,SAAAwR,GACA,GAAAC,GACArQ,EACAC,EAAA9F,KAAAsU,SAAArQ,MACA,IAAA6B,EAAA,GAEA,IADAoQ,KACArQ,EAAA,EAAeA,EAAAC,EAAA,EAAWD,IAC1BqQ,EAAAhJ,KAAAlN,KAAAsU,SAAAzO,IACAqQ,EAAAhJ,KAAA+I,EAEAC,GAAAhJ,KAAAlN,KAAAsU,SAAAzO,IACA7F,KAAAsU,SAAA4B,EAEA,MAAAlW,OAUAa,EAAAc,UAAAwU,aAAA,SAAAC,EAAAC,GACA,GAAAC,GAAAtW,KAAAsU,SAAAtU,KAAAsU,SAAArQ,OAAA,EAUA,OATAqS,GAAA9B,GACA8B,EAAAH,aAAAC,EAAAC,GAEA,gBAAAC,GACAtW,KAAAsU,SAAAtU,KAAAsU,SAAArQ,OAAA,GAAAqS,EAAAxL,QAAAsL,EAAAC,GAGArW,KAAAsU,SAAApH,KAAA,GAAApC,QAAAsL,EAAAC,IAEArW,MAUAa,EAAAc,UAAA2B,iBACA,SAAAK,EAAAC,GACA5D,KAAAuU,eAAAvT,EAAA+C,YAAAJ,IAAAC,GASA/C,EAAAc,UAAA4U,mBACA,SAAAP,GACA,OAAAnQ,GAAA,EAAAC,EAAA9F,KAAAsU,SAAArQ,OAA+C4B,EAAAC,EAASD,IACxD7F,KAAAsU,SAAAzO,GAAA2O,IACAxU,KAAAsU,SAAAzO,GAAA0Q,mBAAAP,EAKA,QADA/S,GAAAY,OAAAG,KAAAhE,KAAAuU,gBACA1O,EAAA,EAAAC,EAAA7C,EAAAgB,OAAyC4B,EAAAC,EAASD,IAClDmQ,EAAAhV,EAAAwK,cAAAvI,EAAA4C,IAAA7F,KAAAuU,eAAAtR,EAAA4C,MAQAhF,EAAAc,UAAAiF,SAAA,WACA,GAAA+J,GAAA,EAIA,OAHA3Q,MAAA+V,KAAA,SAAAH,GACAjF,GAAAiF,IAEAjF,GAOA9P,EAAAc,UAAA6U,sBAAA,SAAA1V,GACA,GAAAuB,IACA0S,KAAA,GACAzS,KAAA,EACAE,OAAA,GAEA6D,EAAA,GAAA1F,GAAAG,GACA2V,GAAA,EACAC,EAAA,KACAC,EAAA,KACAC,EAAA,KACAC,EAAA,IAqEA,OApEA7W,MAAA+V,KAAA,SAAAH,EAAAhT,GACAP,EAAA0S,MAAAa,EACA,OAAAhT,EAAAF,QACA,OAAAE,EAAAN,MACA,OAAAM,EAAAJ,QACAkU,IAAA9T,EAAAF,QACAiU,IAAA/T,EAAAN,MACAsU,IAAAhU,EAAAJ,QACAqU,IAAAjU,EAAAG,MACAsD,EAAArD,YACAN,OAAAE,EAAAF,OACAE,UACAN,KAAAM,EAAAN,KACAE,OAAAI,EAAAJ,QAEAH,WACAC,KAAAD,EAAAC,KACAE,OAAAH,EAAAG,QAEAO,KAAAH,EAAAG,OAGA2T,EAAA9T,EAAAF,OACAiU,EAAA/T,EAAAN,KACAsU,EAAAhU,EAAAJ,OACAqU,EAAAjU,EAAAG,KACA0T,GAAA,GACKA,IACLpQ,EAAArD,YACAX,WACAC,KAAAD,EAAAC,KACAE,OAAAH,EAAAG,UAGAkU,EAAA,KACAD,GAAA,EAEA,QAAAxJ,GAAA,EAAAhJ,EAAA2R,EAAA3R,OAA4CgJ,EAAAhJ,EAAcgJ,IAC1D2I,EAAA3N,WAAAgF,KAAAyH,GACArS,EAAAC,OACAD,EAAAG,OAAA,EAEAyK,EAAA,IAAAhJ,GACAyS,EAAA,KACAD,GAAA,GACSA,GACTpQ,EAAArD,YACAN,OAAAE,EAAAF,OACAE,UACAN,KAAAM,EAAAN,KACAE,OAAAI,EAAAJ,QAEAH,WACAC,KAAAD,EAAAC,KACAE,OAAAH,EAAAG,QAEAO,KAAAH,EAAAG,QAIAV,EAAAG,WAIAxC,KAAAuW,mBAAA,SAAApT,EAAA2T,GACAzQ,EAAA/C,iBAAAH,EAAA2T,MAGU/B,KAAA1S,EAAA0S,KAAA1O,QAGVzG,EAAAiB","file":"source-map.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"sourceMap\"] = factory();\n\telse\n\t\troot[\"sourceMap\"] = factory();\n})(this, function() {\nreturn \n\n\n// WEBPACK FOOTER //\n// webpack/universalModuleDefinition","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"sourceMap\"] = factory();\n\telse\n\t\troot[\"sourceMap\"] = factory();\n})(this, function() {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t/*\n\t * Copyright 2009-2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE.txt or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\texports.SourceMapGenerator = __webpack_require__(1).SourceMapGenerator;\n\texports.SourceMapConsumer = __webpack_require__(7).SourceMapConsumer;\n\texports.SourceNode = __webpack_require__(10).SourceNode;\n\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\t\n\tvar base64VLQ = __webpack_require__(2);\n\tvar util = __webpack_require__(4);\n\tvar ArraySet = __webpack_require__(5).ArraySet;\n\tvar MappingList = __webpack_require__(6).MappingList;\n\t\n\t/**\n\t * An instance of the SourceMapGenerator represents a source map which is\n\t * being built incrementally. You may pass an object with the following\n\t * properties:\n\t *\n\t *   - file: The filename of the generated source.\n\t *   - sourceRoot: A root for all relative URLs in this source map.\n\t */\n\tfunction SourceMapGenerator(aArgs) {\n\t  if (!aArgs) {\n\t    aArgs = {};\n\t  }\n\t  this._file = util.getArg(aArgs, 'file', null);\n\t  this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);\n\t  this._skipValidation = util.getArg(aArgs, 'skipValidation', false);\n\t  this._sources = new ArraySet();\n\t  this._names = new ArraySet();\n\t  this._mappings = new MappingList();\n\t  this._sourcesContents = null;\n\t}\n\t\n\tSourceMapGenerator.prototype._version = 3;\n\t\n\t/**\n\t * Creates a new SourceMapGenerator based on a SourceMapConsumer\n\t *\n\t * @param aSourceMapConsumer The SourceMap.\n\t */\n\tSourceMapGenerator.fromSourceMap =\n\t  function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {\n\t    var sourceRoot = aSourceMapConsumer.sourceRoot;\n\t    var generator = new SourceMapGenerator({\n\t      file: aSourceMapConsumer.file,\n\t      sourceRoot: sourceRoot\n\t    });\n\t    aSourceMapConsumer.eachMapping(function (mapping) {\n\t      var newMapping = {\n\t        generated: {\n\t          line: mapping.generatedLine,\n\t          column: mapping.generatedColumn\n\t        }\n\t      };\n\t\n\t      if (mapping.source != null) {\n\t        newMapping.source = mapping.source;\n\t        if (sourceRoot != null) {\n\t          newMapping.source = util.relative(sourceRoot, newMapping.source);\n\t        }\n\t\n\t        newMapping.original = {\n\t          line: mapping.originalLine,\n\t          column: mapping.originalColumn\n\t        };\n\t\n\t        if (mapping.name != null) {\n\t          newMapping.name = mapping.name;\n\t        }\n\t      }\n\t\n\t      generator.addMapping(newMapping);\n\t    });\n\t    aSourceMapConsumer.sources.forEach(function (sourceFile) {\n\t      var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n\t      if (content != null) {\n\t        generator.setSourceContent(sourceFile, content);\n\t      }\n\t    });\n\t    return generator;\n\t  };\n\t\n\t/**\n\t * Add a single mapping from original source line and column to the generated\n\t * source's line and column for this source map being created. The mapping\n\t * object should have the following properties:\n\t *\n\t *   - generated: An object with the generated line and column positions.\n\t *   - original: An object with the original line and column positions.\n\t *   - source: The original source file (relative to the sourceRoot).\n\t *   - name: An optional original token name for this mapping.\n\t */\n\tSourceMapGenerator.prototype.addMapping =\n\t  function SourceMapGenerator_addMapping(aArgs) {\n\t    var generated = util.getArg(aArgs, 'generated');\n\t    var original = util.getArg(aArgs, 'original', null);\n\t    var source = util.getArg(aArgs, 'source', null);\n\t    var name = util.getArg(aArgs, 'name', null);\n\t\n\t    if (!this._skipValidation) {\n\t      this._validateMapping(generated, original, source, name);\n\t    }\n\t\n\t    if (source != null) {\n\t      source = String(source);\n\t      if (!this._sources.has(source)) {\n\t        this._sources.add(source);\n\t      }\n\t    }\n\t\n\t    if (name != null) {\n\t      name = String(name);\n\t      if (!this._names.has(name)) {\n\t        this._names.add(name);\n\t      }\n\t    }\n\t\n\t    this._mappings.add({\n\t      generatedLine: generated.line,\n\t      generatedColumn: generated.column,\n\t      originalLine: original != null && original.line,\n\t      originalColumn: original != null && original.column,\n\t      source: source,\n\t      name: name\n\t    });\n\t  };\n\t\n\t/**\n\t * Set the source content for a source file.\n\t */\n\tSourceMapGenerator.prototype.setSourceContent =\n\t  function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {\n\t    var source = aSourceFile;\n\t    if (this._sourceRoot != null) {\n\t      source = util.relative(this._sourceRoot, source);\n\t    }\n\t\n\t    if (aSourceContent != null) {\n\t      // Add the source content to the _sourcesContents map.\n\t      // Create a new _sourcesContents map if the property is null.\n\t      if (!this._sourcesContents) {\n\t        this._sourcesContents = Object.create(null);\n\t      }\n\t      this._sourcesContents[util.toSetString(source)] = aSourceContent;\n\t    } else if (this._sourcesContents) {\n\t      // Remove the source file from the _sourcesContents map.\n\t      // If the _sourcesContents map is empty, set the property to null.\n\t      delete this._sourcesContents[util.toSetString(source)];\n\t      if (Object.keys(this._sourcesContents).length === 0) {\n\t        this._sourcesContents = null;\n\t      }\n\t    }\n\t  };\n\t\n\t/**\n\t * Applies the mappings of a sub-source-map for a specific source file to the\n\t * source map being generated. Each mapping to the supplied source file is\n\t * rewritten using the supplied source map. Note: The resolution for the\n\t * resulting mappings is the minimium of this map and the supplied map.\n\t *\n\t * @param aSourceMapConsumer The source map to be applied.\n\t * @param aSourceFile Optional. The filename of the source file.\n\t *        If omitted, SourceMapConsumer's file property will be used.\n\t * @param aSourceMapPath Optional. The dirname of the path to the source map\n\t *        to be applied. If relative, it is relative to the SourceMapConsumer.\n\t *        This parameter is needed when the two source maps aren't in the same\n\t *        directory, and the source map to be applied contains relative source\n\t *        paths. If so, those relative source paths need to be rewritten\n\t *        relative to the SourceMapGenerator.\n\t */\n\tSourceMapGenerator.prototype.applySourceMap =\n\t  function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {\n\t    var sourceFile = aSourceFile;\n\t    // If aSourceFile is omitted, we will use the file property of the SourceMap\n\t    if (aSourceFile == null) {\n\t      if (aSourceMapConsumer.file == null) {\n\t        throw new Error(\n\t          'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +\n\t          'or the source map\\'s \"file\" property. Both were omitted.'\n\t        );\n\t      }\n\t      sourceFile = aSourceMapConsumer.file;\n\t    }\n\t    var sourceRoot = this._sourceRoot;\n\t    // Make \"sourceFile\" relative if an absolute Url is passed.\n\t    if (sourceRoot != null) {\n\t      sourceFile = util.relative(sourceRoot, sourceFile);\n\t    }\n\t    // Applying the SourceMap can add and remove items from the sources and\n\t    // the names array.\n\t    var newSources = new ArraySet();\n\t    var newNames = new ArraySet();\n\t\n\t    // Find mappings for the \"sourceFile\"\n\t    this._mappings.unsortedForEach(function (mapping) {\n\t      if (mapping.source === sourceFile && mapping.originalLine != null) {\n\t        // Check if it can be mapped by the source map, then update the mapping.\n\t        var original = aSourceMapConsumer.originalPositionFor({\n\t          line: mapping.originalLine,\n\t          column: mapping.originalColumn\n\t        });\n\t        if (original.source != null) {\n\t          // Copy mapping\n\t          mapping.source = original.source;\n\t          if (aSourceMapPath != null) {\n\t            mapping.source = util.join(aSourceMapPath, mapping.source)\n\t          }\n\t          if (sourceRoot != null) {\n\t            mapping.source = util.relative(sourceRoot, mapping.source);\n\t          }\n\t          mapping.originalLine = original.line;\n\t          mapping.originalColumn = original.column;\n\t          if (original.name != null) {\n\t            mapping.name = original.name;\n\t          }\n\t        }\n\t      }\n\t\n\t      var source = mapping.source;\n\t      if (source != null && !newSources.has(source)) {\n\t        newSources.add(source);\n\t      }\n\t\n\t      var name = mapping.name;\n\t      if (name != null && !newNames.has(name)) {\n\t        newNames.add(name);\n\t      }\n\t\n\t    }, this);\n\t    this._sources = newSources;\n\t    this._names = newNames;\n\t\n\t    // Copy sourcesContents of applied map.\n\t    aSourceMapConsumer.sources.forEach(function (sourceFile) {\n\t      var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n\t      if (content != null) {\n\t        if (aSourceMapPath != null) {\n\t          sourceFile = util.join(aSourceMapPath, sourceFile);\n\t        }\n\t        if (sourceRoot != null) {\n\t          sourceFile = util.relative(sourceRoot, sourceFile);\n\t        }\n\t        this.setSourceContent(sourceFile, content);\n\t      }\n\t    }, this);\n\t  };\n\t\n\t/**\n\t * A mapping can have one of the three levels of data:\n\t *\n\t *   1. Just the generated position.\n\t *   2. The Generated position, original position, and original source.\n\t *   3. Generated and original position, original source, as well as a name\n\t *      token.\n\t *\n\t * To maintain consistency, we validate that any new mapping being added falls\n\t * in to one of these categories.\n\t */\n\tSourceMapGenerator.prototype._validateMapping =\n\t  function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,\n\t                                              aName) {\n\t    // When aOriginal is truthy but has empty values for .line and .column,\n\t    // it is most likely a programmer error. In this case we throw a very\n\t    // specific error message to try to guide them the right way.\n\t    // For example: https://github.com/Polymer/polymer-bundler/pull/519\n\t    if (aOriginal && typeof aOriginal.line !== 'number' && typeof aOriginal.column !== 'number') {\n\t        throw new Error(\n\t            'original.line and original.column are not numbers -- you probably meant to omit ' +\n\t            'the original mapping entirely and only map the generated position. If so, pass ' +\n\t            'null for the original mapping instead of an object with empty or null values.'\n\t        );\n\t    }\n\t\n\t    if (aGenerated && 'line' in aGenerated && 'column' in aGenerated\n\t        && aGenerated.line > 0 && aGenerated.column >= 0\n\t        && !aOriginal && !aSource && !aName) {\n\t      // Case 1.\n\t      return;\n\t    }\n\t    else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated\n\t             && aOriginal && 'line' in aOriginal && 'column' in aOriginal\n\t             && aGenerated.line > 0 && aGenerated.column >= 0\n\t             && aOriginal.line > 0 && aOriginal.column >= 0\n\t             && aSource) {\n\t      // Cases 2 and 3.\n\t      return;\n\t    }\n\t    else {\n\t      throw new Error('Invalid mapping: ' + JSON.stringify({\n\t        generated: aGenerated,\n\t        source: aSource,\n\t        original: aOriginal,\n\t        name: aName\n\t      }));\n\t    }\n\t  };\n\t\n\t/**\n\t * Serialize the accumulated mappings in to the stream of base 64 VLQs\n\t * specified by the source map format.\n\t */\n\tSourceMapGenerator.prototype._serializeMappings =\n\t  function SourceMapGenerator_serializeMappings() {\n\t    var previousGeneratedColumn = 0;\n\t    var previousGeneratedLine = 1;\n\t    var previousOriginalColumn = 0;\n\t    var previousOriginalLine = 0;\n\t    var previousName = 0;\n\t    var previousSource = 0;\n\t    var result = '';\n\t    var next;\n\t    var mapping;\n\t    var nameIdx;\n\t    var sourceIdx;\n\t\n\t    var mappings = this._mappings.toArray();\n\t    for (var i = 0, len = mappings.length; i < len; i++) {\n\t      mapping = mappings[i];\n\t      next = ''\n\t\n\t      if (mapping.generatedLine !== previousGeneratedLine) {\n\t        previousGeneratedColumn = 0;\n\t        while (mapping.generatedLine !== previousGeneratedLine) {\n\t          next += ';';\n\t          previousGeneratedLine++;\n\t        }\n\t      }\n\t      else {\n\t        if (i > 0) {\n\t          if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {\n\t            continue;\n\t          }\n\t          next += ',';\n\t        }\n\t      }\n\t\n\t      next += base64VLQ.encode(mapping.generatedColumn\n\t                                 - previousGeneratedColumn);\n\t      previousGeneratedColumn = mapping.generatedColumn;\n\t\n\t      if (mapping.source != null) {\n\t        sourceIdx = this._sources.indexOf(mapping.source);\n\t        next += base64VLQ.encode(sourceIdx - previousSource);\n\t        previousSource = sourceIdx;\n\t\n\t        // lines are stored 0-based in SourceMap spec version 3\n\t        next += base64VLQ.encode(mapping.originalLine - 1\n\t                                   - previousOriginalLine);\n\t        previousOriginalLine = mapping.originalLine - 1;\n\t\n\t        next += base64VLQ.encode(mapping.originalColumn\n\t                                   - previousOriginalColumn);\n\t        previousOriginalColumn = mapping.originalColumn;\n\t\n\t        if (mapping.name != null) {\n\t          nameIdx = this._names.indexOf(mapping.name);\n\t          next += base64VLQ.encode(nameIdx - previousName);\n\t          previousName = nameIdx;\n\t        }\n\t      }\n\t\n\t      result += next;\n\t    }\n\t\n\t    return result;\n\t  };\n\t\n\tSourceMapGenerator.prototype._generateSourcesContent =\n\t  function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {\n\t    return aSources.map(function (source) {\n\t      if (!this._sourcesContents) {\n\t        return null;\n\t      }\n\t      if (aSourceRoot != null) {\n\t        source = util.relative(aSourceRoot, source);\n\t      }\n\t      var key = util.toSetString(source);\n\t      return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)\n\t        ? this._sourcesContents[key]\n\t        : null;\n\t    }, this);\n\t  };\n\t\n\t/**\n\t * Externalize the source map.\n\t */\n\tSourceMapGenerator.prototype.toJSON =\n\t  function SourceMapGenerator_toJSON() {\n\t    var map = {\n\t      version: this._version,\n\t      sources: this._sources.toArray(),\n\t      names: this._names.toArray(),\n\t      mappings: this._serializeMappings()\n\t    };\n\t    if (this._file != null) {\n\t      map.file = this._file;\n\t    }\n\t    if (this._sourceRoot != null) {\n\t      map.sourceRoot = this._sourceRoot;\n\t    }\n\t    if (this._sourcesContents) {\n\t      map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);\n\t    }\n\t\n\t    return map;\n\t  };\n\t\n\t/**\n\t * Render the source map being generated to a string.\n\t */\n\tSourceMapGenerator.prototype.toString =\n\t  function SourceMapGenerator_toString() {\n\t    return JSON.stringify(this.toJSON());\n\t  };\n\t\n\texports.SourceMapGenerator = SourceMapGenerator;\n\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t *\n\t * Based on the Base 64 VLQ implementation in Closure Compiler:\n\t * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java\n\t *\n\t * Copyright 2011 The Closure Compiler Authors. All rights reserved.\n\t * Redistribution and use in source and binary forms, with or without\n\t * modification, are permitted provided that the following conditions are\n\t * met:\n\t *\n\t *  * Redistributions of source code must retain the above copyright\n\t *    notice, this list of conditions and the following disclaimer.\n\t *  * Redistributions in binary form must reproduce the above\n\t *    copyright notice, this list of conditions and the following\n\t *    disclaimer in the documentation and/or other materials provided\n\t *    with the distribution.\n\t *  * Neither the name of Google Inc. nor the names of its\n\t *    contributors may be used to endorse or promote products derived\n\t *    from this software without specific prior written permission.\n\t *\n\t * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n\t * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n\t * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n\t * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n\t * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n\t * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n\t * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n\t * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n\t * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n\t * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n\t * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\t */\n\t\n\tvar base64 = __webpack_require__(3);\n\t\n\t// A single base 64 digit can contain 6 bits of data. For the base 64 variable\n\t// length quantities we use in the source map spec, the first bit is the sign,\n\t// the next four bits are the actual value, and the 6th bit is the\n\t// continuation bit. The continuation bit tells us whether there are more\n\t// digits in this value following this digit.\n\t//\n\t//   Continuation\n\t//   |    Sign\n\t//   |    |\n\t//   V    V\n\t//   101011\n\t\n\tvar VLQ_BASE_SHIFT = 5;\n\t\n\t// binary: 100000\n\tvar VLQ_BASE = 1 << VLQ_BASE_SHIFT;\n\t\n\t// binary: 011111\n\tvar VLQ_BASE_MASK = VLQ_BASE - 1;\n\t\n\t// binary: 100000\n\tvar VLQ_CONTINUATION_BIT = VLQ_BASE;\n\t\n\t/**\n\t * Converts from a two-complement value to a value where the sign bit is\n\t * placed in the least significant bit.  For example, as decimals:\n\t *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)\n\t *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)\n\t */\n\tfunction toVLQSigned(aValue) {\n\t  return aValue < 0\n\t    ? ((-aValue) << 1) + 1\n\t    : (aValue << 1) + 0;\n\t}\n\t\n\t/**\n\t * Converts to a two-complement value from a value where the sign bit is\n\t * placed in the least significant bit.  For example, as decimals:\n\t *   2 (10 binary) becomes 1, 3 (11 binary) becomes -1\n\t *   4 (100 binary) becomes 2, 5 (101 binary) becomes -2\n\t */\n\tfunction fromVLQSigned(aValue) {\n\t  var isNegative = (aValue & 1) === 1;\n\t  var shifted = aValue >> 1;\n\t  return isNegative\n\t    ? -shifted\n\t    : shifted;\n\t}\n\t\n\t/**\n\t * Returns the base 64 VLQ encoded value.\n\t */\n\texports.encode = function base64VLQ_encode(aValue) {\n\t  var encoded = \"\";\n\t  var digit;\n\t\n\t  var vlq = toVLQSigned(aValue);\n\t\n\t  do {\n\t    digit = vlq & VLQ_BASE_MASK;\n\t    vlq >>>= VLQ_BASE_SHIFT;\n\t    if (vlq > 0) {\n\t      // There are still more digits in this value, so we must make sure the\n\t      // continuation bit is marked.\n\t      digit |= VLQ_CONTINUATION_BIT;\n\t    }\n\t    encoded += base64.encode(digit);\n\t  } while (vlq > 0);\n\t\n\t  return encoded;\n\t};\n\t\n\t/**\n\t * Decodes the next base 64 VLQ value from the given string and returns the\n\t * value and the rest of the string via the out parameter.\n\t */\n\texports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {\n\t  var strLen = aStr.length;\n\t  var result = 0;\n\t  var shift = 0;\n\t  var continuation, digit;\n\t\n\t  do {\n\t    if (aIndex >= strLen) {\n\t      throw new Error(\"Expected more digits in base 64 VLQ value.\");\n\t    }\n\t\n\t    digit = base64.decode(aStr.charCodeAt(aIndex++));\n\t    if (digit === -1) {\n\t      throw new Error(\"Invalid base64 digit: \" + aStr.charAt(aIndex - 1));\n\t    }\n\t\n\t    continuation = !!(digit & VLQ_CONTINUATION_BIT);\n\t    digit &= VLQ_BASE_MASK;\n\t    result = result + (digit << shift);\n\t    shift += VLQ_BASE_SHIFT;\n\t  } while (continuation);\n\t\n\t  aOutParam.value = fromVLQSigned(result);\n\t  aOutParam.rest = aIndex;\n\t};\n\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\t\n\tvar intToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');\n\t\n\t/**\n\t * Encode an integer in the range of 0 to 63 to a single base 64 digit.\n\t */\n\texports.encode = function (number) {\n\t  if (0 <= number && number < intToCharMap.length) {\n\t    return intToCharMap[number];\n\t  }\n\t  throw new TypeError(\"Must be between 0 and 63: \" + number);\n\t};\n\t\n\t/**\n\t * Decode a single base 64 character code digit to an integer. Returns -1 on\n\t * failure.\n\t */\n\texports.decode = function (charCode) {\n\t  var bigA = 65;     // 'A'\n\t  var bigZ = 90;     // 'Z'\n\t\n\t  var littleA = 97;  // 'a'\n\t  var littleZ = 122; // 'z'\n\t\n\t  var zero = 48;     // '0'\n\t  var nine = 57;     // '9'\n\t\n\t  var plus = 43;     // '+'\n\t  var slash = 47;    // '/'\n\t\n\t  var littleOffset = 26;\n\t  var numberOffset = 52;\n\t\n\t  // 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ\n\t  if (bigA <= charCode && charCode <= bigZ) {\n\t    return (charCode - bigA);\n\t  }\n\t\n\t  // 26 - 51: abcdefghijklmnopqrstuvwxyz\n\t  if (littleA <= charCode && charCode <= littleZ) {\n\t    return (charCode - littleA + littleOffset);\n\t  }\n\t\n\t  // 52 - 61: 0123456789\n\t  if (zero <= charCode && charCode <= nine) {\n\t    return (charCode - zero + numberOffset);\n\t  }\n\t\n\t  // 62: +\n\t  if (charCode == plus) {\n\t    return 62;\n\t  }\n\t\n\t  // 63: /\n\t  if (charCode == slash) {\n\t    return 63;\n\t  }\n\t\n\t  // Invalid base64 digit.\n\t  return -1;\n\t};\n\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\t\n\t/**\n\t * This is a helper function for getting values from parameter/options\n\t * objects.\n\t *\n\t * @param args The object we are extracting values from\n\t * @param name The name of the property we are getting.\n\t * @param defaultValue An optional value to return if the property is missing\n\t * from the object. If this is not specified and the property is missing, an\n\t * error will be thrown.\n\t */\n\tfunction getArg(aArgs, aName, aDefaultValue) {\n\t  if (aName in aArgs) {\n\t    return aArgs[aName];\n\t  } else if (arguments.length === 3) {\n\t    return aDefaultValue;\n\t  } else {\n\t    throw new Error('\"' + aName + '\" is a required argument.');\n\t  }\n\t}\n\texports.getArg = getArg;\n\t\n\tvar urlRegexp = /^(?:([\\w+\\-.]+):)?\\/\\/(?:(\\w+:\\w+)@)?([\\w.]*)(?::(\\d+))?(\\S*)$/;\n\tvar dataUrlRegexp = /^data:.+\\,.+$/;\n\t\n\tfunction urlParse(aUrl) {\n\t  var match = aUrl.match(urlRegexp);\n\t  if (!match) {\n\t    return null;\n\t  }\n\t  return {\n\t    scheme: match[1],\n\t    auth: match[2],\n\t    host: match[3],\n\t    port: match[4],\n\t    path: match[5]\n\t  };\n\t}\n\texports.urlParse = urlParse;\n\t\n\tfunction urlGenerate(aParsedUrl) {\n\t  var url = '';\n\t  if (aParsedUrl.scheme) {\n\t    url += aParsedUrl.scheme + ':';\n\t  }\n\t  url += '//';\n\t  if (aParsedUrl.auth) {\n\t    url += aParsedUrl.auth + '@';\n\t  }\n\t  if (aParsedUrl.host) {\n\t    url += aParsedUrl.host;\n\t  }\n\t  if (aParsedUrl.port) {\n\t    url += \":\" + aParsedUrl.port\n\t  }\n\t  if (aParsedUrl.path) {\n\t    url += aParsedUrl.path;\n\t  }\n\t  return url;\n\t}\n\texports.urlGenerate = urlGenerate;\n\t\n\t/**\n\t * Normalizes a path, or the path portion of a URL:\n\t *\n\t * - Replaces consecutive slashes with one slash.\n\t * - Removes unnecessary '.' parts.\n\t * - Removes unnecessary '<dir>/..' parts.\n\t *\n\t * Based on code in the Node.js 'path' core module.\n\t *\n\t * @param aPath The path or url to normalize.\n\t */\n\tfunction normalize(aPath) {\n\t  var path = aPath;\n\t  var url = urlParse(aPath);\n\t  if (url) {\n\t    if (!url.path) {\n\t      return aPath;\n\t    }\n\t    path = url.path;\n\t  }\n\t  var isAbsolute = exports.isAbsolute(path);\n\t\n\t  var parts = path.split(/\\/+/);\n\t  for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {\n\t    part = parts[i];\n\t    if (part === '.') {\n\t      parts.splice(i, 1);\n\t    } else if (part === '..') {\n\t      up++;\n\t    } else if (up > 0) {\n\t      if (part === '') {\n\t        // The first part is blank if the path is absolute. Trying to go\n\t        // above the root is a no-op. Therefore we can remove all '..' parts\n\t        // directly after the root.\n\t        parts.splice(i + 1, up);\n\t        up = 0;\n\t      } else {\n\t        parts.splice(i, 2);\n\t        up--;\n\t      }\n\t    }\n\t  }\n\t  path = parts.join('/');\n\t\n\t  if (path === '') {\n\t    path = isAbsolute ? '/' : '.';\n\t  }\n\t\n\t  if (url) {\n\t    url.path = path;\n\t    return urlGenerate(url);\n\t  }\n\t  return path;\n\t}\n\texports.normalize = normalize;\n\t\n\t/**\n\t * Joins two paths/URLs.\n\t *\n\t * @param aRoot The root path or URL.\n\t * @param aPath The path or URL to be joined with the root.\n\t *\n\t * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a\n\t *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended\n\t *   first.\n\t * - Otherwise aPath is a path. If aRoot is a URL, then its path portion\n\t *   is updated with the result and aRoot is returned. Otherwise the result\n\t *   is returned.\n\t *   - If aPath is absolute, the result is aPath.\n\t *   - Otherwise the two paths are joined with a slash.\n\t * - Joining for example 'http://' and 'www.example.com' is also supported.\n\t */\n\tfunction join(aRoot, aPath) {\n\t  if (aRoot === \"\") {\n\t    aRoot = \".\";\n\t  }\n\t  if (aPath === \"\") {\n\t    aPath = \".\";\n\t  }\n\t  var aPathUrl = urlParse(aPath);\n\t  var aRootUrl = urlParse(aRoot);\n\t  if (aRootUrl) {\n\t    aRoot = aRootUrl.path || '/';\n\t  }\n\t\n\t  // `join(foo, '//www.example.org')`\n\t  if (aPathUrl && !aPathUrl.scheme) {\n\t    if (aRootUrl) {\n\t      aPathUrl.scheme = aRootUrl.scheme;\n\t    }\n\t    return urlGenerate(aPathUrl);\n\t  }\n\t\n\t  if (aPathUrl || aPath.match(dataUrlRegexp)) {\n\t    return aPath;\n\t  }\n\t\n\t  // `join('http://', 'www.example.com')`\n\t  if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {\n\t    aRootUrl.host = aPath;\n\t    return urlGenerate(aRootUrl);\n\t  }\n\t\n\t  var joined = aPath.charAt(0) === '/'\n\t    ? aPath\n\t    : normalize(aRoot.replace(/\\/+$/, '') + '/' + aPath);\n\t\n\t  if (aRootUrl) {\n\t    aRootUrl.path = joined;\n\t    return urlGenerate(aRootUrl);\n\t  }\n\t  return joined;\n\t}\n\texports.join = join;\n\t\n\texports.isAbsolute = function (aPath) {\n\t  return aPath.charAt(0) === '/' || !!aPath.match(urlRegexp);\n\t};\n\t\n\t/**\n\t * Make a path relative to a URL or another path.\n\t *\n\t * @param aRoot The root path or URL.\n\t * @param aPath The path or URL to be made relative to aRoot.\n\t */\n\tfunction relative(aRoot, aPath) {\n\t  if (aRoot === \"\") {\n\t    aRoot = \".\";\n\t  }\n\t\n\t  aRoot = aRoot.replace(/\\/$/, '');\n\t\n\t  // It is possible for the path to be above the root. In this case, simply\n\t  // checking whether the root is a prefix of the path won't work. Instead, we\n\t  // need to remove components from the root one by one, until either we find\n\t  // a prefix that fits, or we run out of components to remove.\n\t  var level = 0;\n\t  while (aPath.indexOf(aRoot + '/') !== 0) {\n\t    var index = aRoot.lastIndexOf(\"/\");\n\t    if (index < 0) {\n\t      return aPath;\n\t    }\n\t\n\t    // If the only part of the root that is left is the scheme (i.e. http://,\n\t    // file:///, etc.), one or more slashes (/), or simply nothing at all, we\n\t    // have exhausted all components, so the path is not relative to the root.\n\t    aRoot = aRoot.slice(0, index);\n\t    if (aRoot.match(/^([^\\/]+:\\/)?\\/*$/)) {\n\t      return aPath;\n\t    }\n\t\n\t    ++level;\n\t  }\n\t\n\t  // Make sure we add a \"../\" for each component we removed from the root.\n\t  return Array(level + 1).join(\"../\") + aPath.substr(aRoot.length + 1);\n\t}\n\texports.relative = relative;\n\t\n\tvar supportsNullProto = (function () {\n\t  var obj = Object.create(null);\n\t  return !('__proto__' in obj);\n\t}());\n\t\n\tfunction identity (s) {\n\t  return s;\n\t}\n\t\n\t/**\n\t * Because behavior goes wacky when you set `__proto__` on objects, we\n\t * have to prefix all the strings in our set with an arbitrary character.\n\t *\n\t * See https://github.com/mozilla/source-map/pull/31 and\n\t * https://github.com/mozilla/source-map/issues/30\n\t *\n\t * @param String aStr\n\t */\n\tfunction toSetString(aStr) {\n\t  if (isProtoString(aStr)) {\n\t    return '$' + aStr;\n\t  }\n\t\n\t  return aStr;\n\t}\n\texports.toSetString = supportsNullProto ? identity : toSetString;\n\t\n\tfunction fromSetString(aStr) {\n\t  if (isProtoString(aStr)) {\n\t    return aStr.slice(1);\n\t  }\n\t\n\t  return aStr;\n\t}\n\texports.fromSetString = supportsNullProto ? identity : fromSetString;\n\t\n\tfunction isProtoString(s) {\n\t  if (!s) {\n\t    return false;\n\t  }\n\t\n\t  var length = s.length;\n\t\n\t  if (length < 9 /* \"__proto__\".length */) {\n\t    return false;\n\t  }\n\t\n\t  if (s.charCodeAt(length - 1) !== 95  /* '_' */ ||\n\t      s.charCodeAt(length - 2) !== 95  /* '_' */ ||\n\t      s.charCodeAt(length - 3) !== 111 /* 'o' */ ||\n\t      s.charCodeAt(length - 4) !== 116 /* 't' */ ||\n\t      s.charCodeAt(length - 5) !== 111 /* 'o' */ ||\n\t      s.charCodeAt(length - 6) !== 114 /* 'r' */ ||\n\t      s.charCodeAt(length - 7) !== 112 /* 'p' */ ||\n\t      s.charCodeAt(length - 8) !== 95  /* '_' */ ||\n\t      s.charCodeAt(length - 9) !== 95  /* '_' */) {\n\t    return false;\n\t  }\n\t\n\t  for (var i = length - 10; i >= 0; i--) {\n\t    if (s.charCodeAt(i) !== 36 /* '$' */) {\n\t      return false;\n\t    }\n\t  }\n\t\n\t  return true;\n\t}\n\t\n\t/**\n\t * Comparator between two mappings where the original positions are compared.\n\t *\n\t * Optionally pass in `true` as `onlyCompareGenerated` to consider two\n\t * mappings with the same original source/line/column, but different generated\n\t * line and column the same. Useful when searching for a mapping with a\n\t * stubbed out mapping.\n\t */\n\tfunction compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {\n\t  var cmp = mappingA.source - mappingB.source;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\t\n\t  cmp = mappingA.originalLine - mappingB.originalLine;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\t\n\t  cmp = mappingA.originalColumn - mappingB.originalColumn;\n\t  if (cmp !== 0 || onlyCompareOriginal) {\n\t    return cmp;\n\t  }\n\t\n\t  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\t\n\t  cmp = mappingA.generatedLine - mappingB.generatedLine;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\t\n\t  return mappingA.name - mappingB.name;\n\t}\n\texports.compareByOriginalPositions = compareByOriginalPositions;\n\t\n\t/**\n\t * Comparator between two mappings with deflated source and name indices where\n\t * the generated positions are compared.\n\t *\n\t * Optionally pass in `true` as `onlyCompareGenerated` to consider two\n\t * mappings with the same generated line and column, but different\n\t * source/name/original line and column the same. Useful when searching for a\n\t * mapping with a stubbed out mapping.\n\t */\n\tfunction compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {\n\t  var cmp = mappingA.generatedLine - mappingB.generatedLine;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\t\n\t  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n\t  if (cmp !== 0 || onlyCompareGenerated) {\n\t    return cmp;\n\t  }\n\t\n\t  cmp = mappingA.source - mappingB.source;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\t\n\t  cmp = mappingA.originalLine - mappingB.originalLine;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\t\n\t  cmp = mappingA.originalColumn - mappingB.originalColumn;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\t\n\t  return mappingA.name - mappingB.name;\n\t}\n\texports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;\n\t\n\tfunction strcmp(aStr1, aStr2) {\n\t  if (aStr1 === aStr2) {\n\t    return 0;\n\t  }\n\t\n\t  if (aStr1 > aStr2) {\n\t    return 1;\n\t  }\n\t\n\t  return -1;\n\t}\n\t\n\t/**\n\t * Comparator between two mappings with inflated source and name strings where\n\t * the generated positions are compared.\n\t */\n\tfunction compareByGeneratedPositionsInflated(mappingA, mappingB) {\n\t  var cmp = mappingA.generatedLine - mappingB.generatedLine;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\t\n\t  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\t\n\t  cmp = strcmp(mappingA.source, mappingB.source);\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\t\n\t  cmp = mappingA.originalLine - mappingB.originalLine;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\t\n\t  cmp = mappingA.originalColumn - mappingB.originalColumn;\n\t  if (cmp !== 0) {\n\t    return cmp;\n\t  }\n\t\n\t  return strcmp(mappingA.name, mappingB.name);\n\t}\n\texports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;\n\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\t\n\tvar util = __webpack_require__(4);\n\tvar has = Object.prototype.hasOwnProperty;\n\tvar hasNativeMap = typeof Map !== \"undefined\";\n\t\n\t/**\n\t * A data structure which is a combination of an array and a set. Adding a new\n\t * member is O(1), testing for membership is O(1), and finding the index of an\n\t * element is O(1). Removing elements from the set is not supported. Only\n\t * strings are supported for membership.\n\t */\n\tfunction ArraySet() {\n\t  this._array = [];\n\t  this._set = hasNativeMap ? new Map() : Object.create(null);\n\t}\n\t\n\t/**\n\t * Static method for creating ArraySet instances from an existing array.\n\t */\n\tArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {\n\t  var set = new ArraySet();\n\t  for (var i = 0, len = aArray.length; i < len; i++) {\n\t    set.add(aArray[i], aAllowDuplicates);\n\t  }\n\t  return set;\n\t};\n\t\n\t/**\n\t * Return how many unique items are in this ArraySet. If duplicates have been\n\t * added, than those do not count towards the size.\n\t *\n\t * @returns Number\n\t */\n\tArraySet.prototype.size = function ArraySet_size() {\n\t  return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;\n\t};\n\t\n\t/**\n\t * Add the given string to this set.\n\t *\n\t * @param String aStr\n\t */\n\tArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {\n\t  var sStr = hasNativeMap ? aStr : util.toSetString(aStr);\n\t  var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);\n\t  var idx = this._array.length;\n\t  if (!isDuplicate || aAllowDuplicates) {\n\t    this._array.push(aStr);\n\t  }\n\t  if (!isDuplicate) {\n\t    if (hasNativeMap) {\n\t      this._set.set(aStr, idx);\n\t    } else {\n\t      this._set[sStr] = idx;\n\t    }\n\t  }\n\t};\n\t\n\t/**\n\t * Is the given string a member of this set?\n\t *\n\t * @param String aStr\n\t */\n\tArraySet.prototype.has = function ArraySet_has(aStr) {\n\t  if (hasNativeMap) {\n\t    return this._set.has(aStr);\n\t  } else {\n\t    var sStr = util.toSetString(aStr);\n\t    return has.call(this._set, sStr);\n\t  }\n\t};\n\t\n\t/**\n\t * What is the index of the given string in the array?\n\t *\n\t * @param String aStr\n\t */\n\tArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {\n\t  if (hasNativeMap) {\n\t    var idx = this._set.get(aStr);\n\t    if (idx >= 0) {\n\t        return idx;\n\t    }\n\t  } else {\n\t    var sStr = util.toSetString(aStr);\n\t    if (has.call(this._set, sStr)) {\n\t      return this._set[sStr];\n\t    }\n\t  }\n\t\n\t  throw new Error('\"' + aStr + '\" is not in the set.');\n\t};\n\t\n\t/**\n\t * What is the element at the given index?\n\t *\n\t * @param Number aIdx\n\t */\n\tArraySet.prototype.at = function ArraySet_at(aIdx) {\n\t  if (aIdx >= 0 && aIdx < this._array.length) {\n\t    return this._array[aIdx];\n\t  }\n\t  throw new Error('No element indexed by ' + aIdx);\n\t};\n\t\n\t/**\n\t * Returns the array representation of this set (which has the proper indices\n\t * indicated by indexOf). Note that this is a copy of the internal array used\n\t * for storing the members so that no one can mess with internal state.\n\t */\n\tArraySet.prototype.toArray = function ArraySet_toArray() {\n\t  return this._array.slice();\n\t};\n\t\n\texports.ArraySet = ArraySet;\n\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2014 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\t\n\tvar util = __webpack_require__(4);\n\t\n\t/**\n\t * Determine whether mappingB is after mappingA with respect to generated\n\t * position.\n\t */\n\tfunction generatedPositionAfter(mappingA, mappingB) {\n\t  // Optimized for most common case\n\t  var lineA = mappingA.generatedLine;\n\t  var lineB = mappingB.generatedLine;\n\t  var columnA = mappingA.generatedColumn;\n\t  var columnB = mappingB.generatedColumn;\n\t  return lineB > lineA || lineB == lineA && columnB >= columnA ||\n\t         util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;\n\t}\n\t\n\t/**\n\t * A data structure to provide a sorted view of accumulated mappings in a\n\t * performance conscious manner. It trades a neglibable overhead in general\n\t * case for a large speedup in case of mappings being added in order.\n\t */\n\tfunction MappingList() {\n\t  this._array = [];\n\t  this._sorted = true;\n\t  // Serves as infimum\n\t  this._last = {generatedLine: -1, generatedColumn: 0};\n\t}\n\t\n\t/**\n\t * Iterate through internal items. This method takes the same arguments that\n\t * `Array.prototype.forEach` takes.\n\t *\n\t * NOTE: The order of the mappings is NOT guaranteed.\n\t */\n\tMappingList.prototype.unsortedForEach =\n\t  function MappingList_forEach(aCallback, aThisArg) {\n\t    this._array.forEach(aCallback, aThisArg);\n\t  };\n\t\n\t/**\n\t * Add the given source mapping.\n\t *\n\t * @param Object aMapping\n\t */\n\tMappingList.prototype.add = function MappingList_add(aMapping) {\n\t  if (generatedPositionAfter(this._last, aMapping)) {\n\t    this._last = aMapping;\n\t    this._array.push(aMapping);\n\t  } else {\n\t    this._sorted = false;\n\t    this._array.push(aMapping);\n\t  }\n\t};\n\t\n\t/**\n\t * Returns the flat, sorted array of mappings. The mappings are sorted by\n\t * generated position.\n\t *\n\t * WARNING: This method returns internal data without copying, for\n\t * performance. The return value must NOT be mutated, and should be treated as\n\t * an immutable borrow. If you want to take ownership, you must make your own\n\t * copy.\n\t */\n\tMappingList.prototype.toArray = function MappingList_toArray() {\n\t  if (!this._sorted) {\n\t    this._array.sort(util.compareByGeneratedPositionsInflated);\n\t    this._sorted = true;\n\t  }\n\t  return this._array;\n\t};\n\t\n\texports.MappingList = MappingList;\n\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\t\n\tvar util = __webpack_require__(4);\n\tvar binarySearch = __webpack_require__(8);\n\tvar ArraySet = __webpack_require__(5).ArraySet;\n\tvar base64VLQ = __webpack_require__(2);\n\tvar quickSort = __webpack_require__(9).quickSort;\n\t\n\tfunction SourceMapConsumer(aSourceMap) {\n\t  var sourceMap = aSourceMap;\n\t  if (typeof aSourceMap === 'string') {\n\t    sourceMap = JSON.parse(aSourceMap.replace(/^\\)\\]\\}'/, ''));\n\t  }\n\t\n\t  return sourceMap.sections != null\n\t    ? new IndexedSourceMapConsumer(sourceMap)\n\t    : new BasicSourceMapConsumer(sourceMap);\n\t}\n\t\n\tSourceMapConsumer.fromSourceMap = function(aSourceMap) {\n\t  return BasicSourceMapConsumer.fromSourceMap(aSourceMap);\n\t}\n\t\n\t/**\n\t * The version of the source mapping spec that we are consuming.\n\t */\n\tSourceMapConsumer.prototype._version = 3;\n\t\n\t// `__generatedMappings` and `__originalMappings` are arrays that hold the\n\t// parsed mapping coordinates from the source map's \"mappings\" attribute. They\n\t// are lazily instantiated, accessed via the `_generatedMappings` and\n\t// `_originalMappings` getters respectively, and we only parse the mappings\n\t// and create these arrays once queried for a source location. We jump through\n\t// these hoops because there can be many thousands of mappings, and parsing\n\t// them is expensive, so we only want to do it if we must.\n\t//\n\t// Each object in the arrays is of the form:\n\t//\n\t//     {\n\t//       generatedLine: The line number in the generated code,\n\t//       generatedColumn: The column number in the generated code,\n\t//       source: The path to the original source file that generated this\n\t//               chunk of code,\n\t//       originalLine: The line number in the original source that\n\t//                     corresponds to this chunk of generated code,\n\t//       originalColumn: The column number in the original source that\n\t//                       corresponds to this chunk of generated code,\n\t//       name: The name of the original symbol which generated this chunk of\n\t//             code.\n\t//     }\n\t//\n\t// All properties except for `generatedLine` and `generatedColumn` can be\n\t// `null`.\n\t//\n\t// `_generatedMappings` is ordered by the generated positions.\n\t//\n\t// `_originalMappings` is ordered by the original positions.\n\t\n\tSourceMapConsumer.prototype.__generatedMappings = null;\n\tObject.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {\n\t  get: function () {\n\t    if (!this.__generatedMappings) {\n\t      this._parseMappings(this._mappings, this.sourceRoot);\n\t    }\n\t\n\t    return this.__generatedMappings;\n\t  }\n\t});\n\t\n\tSourceMapConsumer.prototype.__originalMappings = null;\n\tObject.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {\n\t  get: function () {\n\t    if (!this.__originalMappings) {\n\t      this._parseMappings(this._mappings, this.sourceRoot);\n\t    }\n\t\n\t    return this.__originalMappings;\n\t  }\n\t});\n\t\n\tSourceMapConsumer.prototype._charIsMappingSeparator =\n\t  function SourceMapConsumer_charIsMappingSeparator(aStr, index) {\n\t    var c = aStr.charAt(index);\n\t    return c === \";\" || c === \",\";\n\t  };\n\t\n\t/**\n\t * Parse the mappings in a string in to a data structure which we can easily\n\t * query (the ordered arrays in the `this.__generatedMappings` and\n\t * `this.__originalMappings` properties).\n\t */\n\tSourceMapConsumer.prototype._parseMappings =\n\t  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n\t    throw new Error(\"Subclasses must implement _parseMappings\");\n\t  };\n\t\n\tSourceMapConsumer.GENERATED_ORDER = 1;\n\tSourceMapConsumer.ORIGINAL_ORDER = 2;\n\t\n\tSourceMapConsumer.GREATEST_LOWER_BOUND = 1;\n\tSourceMapConsumer.LEAST_UPPER_BOUND = 2;\n\t\n\t/**\n\t * Iterate over each mapping between an original source/line/column and a\n\t * generated line/column in this source map.\n\t *\n\t * @param Function aCallback\n\t *        The function that is called with each mapping.\n\t * @param Object aContext\n\t *        Optional. If specified, this object will be the value of `this` every\n\t *        time that `aCallback` is called.\n\t * @param aOrder\n\t *        Either `SourceMapConsumer.GENERATED_ORDER` or\n\t *        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to\n\t *        iterate over the mappings sorted by the generated file's line/column\n\t *        order or the original's source/line/column order, respectively. Defaults to\n\t *        `SourceMapConsumer.GENERATED_ORDER`.\n\t */\n\tSourceMapConsumer.prototype.eachMapping =\n\t  function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {\n\t    var context = aContext || null;\n\t    var order = aOrder || SourceMapConsumer.GENERATED_ORDER;\n\t\n\t    var mappings;\n\t    switch (order) {\n\t    case SourceMapConsumer.GENERATED_ORDER:\n\t      mappings = this._generatedMappings;\n\t      break;\n\t    case SourceMapConsumer.ORIGINAL_ORDER:\n\t      mappings = this._originalMappings;\n\t      break;\n\t    default:\n\t      throw new Error(\"Unknown order of iteration.\");\n\t    }\n\t\n\t    var sourceRoot = this.sourceRoot;\n\t    mappings.map(function (mapping) {\n\t      var source = mapping.source === null ? null : this._sources.at(mapping.source);\n\t      if (source != null && sourceRoot != null) {\n\t        source = util.join(sourceRoot, source);\n\t      }\n\t      return {\n\t        source: source,\n\t        generatedLine: mapping.generatedLine,\n\t        generatedColumn: mapping.generatedColumn,\n\t        originalLine: mapping.originalLine,\n\t        originalColumn: mapping.originalColumn,\n\t        name: mapping.name === null ? null : this._names.at(mapping.name)\n\t      };\n\t    }, this).forEach(aCallback, context);\n\t  };\n\t\n\t/**\n\t * Returns all generated line and column information for the original source,\n\t * line, and column provided. If no column is provided, returns all mappings\n\t * corresponding to a either the line we are searching for or the next\n\t * closest line that has any mappings. Otherwise, returns all mappings\n\t * corresponding to the given line and either the column we are searching for\n\t * or the next closest column that has any offsets.\n\t *\n\t * The only argument is an object with the following properties:\n\t *\n\t *   - source: The filename of the original source.\n\t *   - line: The line number in the original source.\n\t *   - column: Optional. the column number in the original source.\n\t *\n\t * and an array of objects is returned, each with the following properties:\n\t *\n\t *   - line: The line number in the generated source, or null.\n\t *   - column: The column number in the generated source, or null.\n\t */\n\tSourceMapConsumer.prototype.allGeneratedPositionsFor =\n\t  function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {\n\t    var line = util.getArg(aArgs, 'line');\n\t\n\t    // When there is no exact match, BasicSourceMapConsumer.prototype._findMapping\n\t    // returns the index of the closest mapping less than the needle. By\n\t    // setting needle.originalColumn to 0, we thus find the last mapping for\n\t    // the given line, provided such a mapping exists.\n\t    var needle = {\n\t      source: util.getArg(aArgs, 'source'),\n\t      originalLine: line,\n\t      originalColumn: util.getArg(aArgs, 'column', 0)\n\t    };\n\t\n\t    if (this.sourceRoot != null) {\n\t      needle.source = util.relative(this.sourceRoot, needle.source);\n\t    }\n\t    if (!this._sources.has(needle.source)) {\n\t      return [];\n\t    }\n\t    needle.source = this._sources.indexOf(needle.source);\n\t\n\t    var mappings = [];\n\t\n\t    var index = this._findMapping(needle,\n\t                                  this._originalMappings,\n\t                                  \"originalLine\",\n\t                                  \"originalColumn\",\n\t                                  util.compareByOriginalPositions,\n\t                                  binarySearch.LEAST_UPPER_BOUND);\n\t    if (index >= 0) {\n\t      var mapping = this._originalMappings[index];\n\t\n\t      if (aArgs.column === undefined) {\n\t        var originalLine = mapping.originalLine;\n\t\n\t        // Iterate until either we run out of mappings, or we run into\n\t        // a mapping for a different line than the one we found. Since\n\t        // mappings are sorted, this is guaranteed to find all mappings for\n\t        // the line we found.\n\t        while (mapping && mapping.originalLine === originalLine) {\n\t          mappings.push({\n\t            line: util.getArg(mapping, 'generatedLine', null),\n\t            column: util.getArg(mapping, 'generatedColumn', null),\n\t            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n\t          });\n\t\n\t          mapping = this._originalMappings[++index];\n\t        }\n\t      } else {\n\t        var originalColumn = mapping.originalColumn;\n\t\n\t        // Iterate until either we run out of mappings, or we run into\n\t        // a mapping for a different line than the one we were searching for.\n\t        // Since mappings are sorted, this is guaranteed to find all mappings for\n\t        // the line we are searching for.\n\t        while (mapping &&\n\t               mapping.originalLine === line &&\n\t               mapping.originalColumn == originalColumn) {\n\t          mappings.push({\n\t            line: util.getArg(mapping, 'generatedLine', null),\n\t            column: util.getArg(mapping, 'generatedColumn', null),\n\t            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n\t          });\n\t\n\t          mapping = this._originalMappings[++index];\n\t        }\n\t      }\n\t    }\n\t\n\t    return mappings;\n\t  };\n\t\n\texports.SourceMapConsumer = SourceMapConsumer;\n\t\n\t/**\n\t * A BasicSourceMapConsumer instance represents a parsed source map which we can\n\t * query for information about the original file positions by giving it a file\n\t * position in the generated source.\n\t *\n\t * The only parameter is the raw source map (either as a JSON string, or\n\t * already parsed to an object). According to the spec, source maps have the\n\t * following attributes:\n\t *\n\t *   - version: Which version of the source map spec this map is following.\n\t *   - sources: An array of URLs to the original source files.\n\t *   - names: An array of identifiers which can be referrenced by individual mappings.\n\t *   - sourceRoot: Optional. The URL root from which all sources are relative.\n\t *   - sourcesContent: Optional. An array of contents of the original source files.\n\t *   - mappings: A string of base64 VLQs which contain the actual mappings.\n\t *   - file: Optional. The generated file this source map is associated with.\n\t *\n\t * Here is an example source map, taken from the source map spec[0]:\n\t *\n\t *     {\n\t *       version : 3,\n\t *       file: \"out.js\",\n\t *       sourceRoot : \"\",\n\t *       sources: [\"foo.js\", \"bar.js\"],\n\t *       names: [\"src\", \"maps\", \"are\", \"fun\"],\n\t *       mappings: \"AA,AB;;ABCDE;\"\n\t *     }\n\t *\n\t * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#\n\t */\n\tfunction BasicSourceMapConsumer(aSourceMap) {\n\t  var sourceMap = aSourceMap;\n\t  if (typeof aSourceMap === 'string') {\n\t    sourceMap = JSON.parse(aSourceMap.replace(/^\\)\\]\\}'/, ''));\n\t  }\n\t\n\t  var version = util.getArg(sourceMap, 'version');\n\t  var sources = util.getArg(sourceMap, 'sources');\n\t  // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which\n\t  // requires the array) to play nice here.\n\t  var names = util.getArg(sourceMap, 'names', []);\n\t  var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);\n\t  var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);\n\t  var mappings = util.getArg(sourceMap, 'mappings');\n\t  var file = util.getArg(sourceMap, 'file', null);\n\t\n\t  // Once again, Sass deviates from the spec and supplies the version as a\n\t  // string rather than a number, so we use loose equality checking here.\n\t  if (version != this._version) {\n\t    throw new Error('Unsupported version: ' + version);\n\t  }\n\t\n\t  sources = sources\n\t    .map(String)\n\t    // Some source maps produce relative source paths like \"./foo.js\" instead of\n\t    // \"foo.js\".  Normalize these first so that future comparisons will succeed.\n\t    // See bugzil.la/1090768.\n\t    .map(util.normalize)\n\t    // Always ensure that absolute sources are internally stored relative to\n\t    // the source root, if the source root is absolute. Not doing this would\n\t    // be particularly problematic when the source root is a prefix of the\n\t    // source (valid, but why??). See github issue #199 and bugzil.la/1188982.\n\t    .map(function (source) {\n\t      return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source)\n\t        ? util.relative(sourceRoot, source)\n\t        : source;\n\t    });\n\t\n\t  // Pass `true` below to allow duplicate names and sources. While source maps\n\t  // are intended to be compressed and deduplicated, the TypeScript compiler\n\t  // sometimes generates source maps with duplicates in them. See Github issue\n\t  // #72 and bugzil.la/889492.\n\t  this._names = ArraySet.fromArray(names.map(String), true);\n\t  this._sources = ArraySet.fromArray(sources, true);\n\t\n\t  this.sourceRoot = sourceRoot;\n\t  this.sourcesContent = sourcesContent;\n\t  this._mappings = mappings;\n\t  this.file = file;\n\t}\n\t\n\tBasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);\n\tBasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;\n\t\n\t/**\n\t * Create a BasicSourceMapConsumer from a SourceMapGenerator.\n\t *\n\t * @param SourceMapGenerator aSourceMap\n\t *        The source map that will be consumed.\n\t * @returns BasicSourceMapConsumer\n\t */\n\tBasicSourceMapConsumer.fromSourceMap =\n\t  function SourceMapConsumer_fromSourceMap(aSourceMap) {\n\t    var smc = Object.create(BasicSourceMapConsumer.prototype);\n\t\n\t    var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);\n\t    var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);\n\t    smc.sourceRoot = aSourceMap._sourceRoot;\n\t    smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),\n\t                                                            smc.sourceRoot);\n\t    smc.file = aSourceMap._file;\n\t\n\t    // Because we are modifying the entries (by converting string sources and\n\t    // names to indices into the sources and names ArraySets), we have to make\n\t    // a copy of the entry or else bad things happen. Shared mutable state\n\t    // strikes again! See github issue #191.\n\t\n\t    var generatedMappings = aSourceMap._mappings.toArray().slice();\n\t    var destGeneratedMappings = smc.__generatedMappings = [];\n\t    var destOriginalMappings = smc.__originalMappings = [];\n\t\n\t    for (var i = 0, length = generatedMappings.length; i < length; i++) {\n\t      var srcMapping = generatedMappings[i];\n\t      var destMapping = new Mapping;\n\t      destMapping.generatedLine = srcMapping.generatedLine;\n\t      destMapping.generatedColumn = srcMapping.generatedColumn;\n\t\n\t      if (srcMapping.source) {\n\t        destMapping.source = sources.indexOf(srcMapping.source);\n\t        destMapping.originalLine = srcMapping.originalLine;\n\t        destMapping.originalColumn = srcMapping.originalColumn;\n\t\n\t        if (srcMapping.name) {\n\t          destMapping.name = names.indexOf(srcMapping.name);\n\t        }\n\t\n\t        destOriginalMappings.push(destMapping);\n\t      }\n\t\n\t      destGeneratedMappings.push(destMapping);\n\t    }\n\t\n\t    quickSort(smc.__originalMappings, util.compareByOriginalPositions);\n\t\n\t    return smc;\n\t  };\n\t\n\t/**\n\t * The version of the source mapping spec that we are consuming.\n\t */\n\tBasicSourceMapConsumer.prototype._version = 3;\n\t\n\t/**\n\t * The list of original sources.\n\t */\n\tObject.defineProperty(BasicSourceMapConsumer.prototype, 'sources', {\n\t  get: function () {\n\t    return this._sources.toArray().map(function (s) {\n\t      return this.sourceRoot != null ? util.join(this.sourceRoot, s) : s;\n\t    }, this);\n\t  }\n\t});\n\t\n\t/**\n\t * Provide the JIT with a nice shape / hidden class.\n\t */\n\tfunction Mapping() {\n\t  this.generatedLine = 0;\n\t  this.generatedColumn = 0;\n\t  this.source = null;\n\t  this.originalLine = null;\n\t  this.originalColumn = null;\n\t  this.name = null;\n\t}\n\t\n\t/**\n\t * Parse the mappings in a string in to a data structure which we can easily\n\t * query (the ordered arrays in the `this.__generatedMappings` and\n\t * `this.__originalMappings` properties).\n\t */\n\tBasicSourceMapConsumer.prototype._parseMappings =\n\t  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n\t    var generatedLine = 1;\n\t    var previousGeneratedColumn = 0;\n\t    var previousOriginalLine = 0;\n\t    var previousOriginalColumn = 0;\n\t    var previousSource = 0;\n\t    var previousName = 0;\n\t    var length = aStr.length;\n\t    var index = 0;\n\t    var cachedSegments = {};\n\t    var temp = {};\n\t    var originalMappings = [];\n\t    var generatedMappings = [];\n\t    var mapping, str, segment, end, value;\n\t\n\t    while (index < length) {\n\t      if (aStr.charAt(index) === ';') {\n\t        generatedLine++;\n\t        index++;\n\t        previousGeneratedColumn = 0;\n\t      }\n\t      else if (aStr.charAt(index) === ',') {\n\t        index++;\n\t      }\n\t      else {\n\t        mapping = new Mapping();\n\t        mapping.generatedLine = generatedLine;\n\t\n\t        // Because each offset is encoded relative to the previous one,\n\t        // many segments often have the same encoding. We can exploit this\n\t        // fact by caching the parsed variable length fields of each segment,\n\t        // allowing us to avoid a second parse if we encounter the same\n\t        // segment again.\n\t        for (end = index; end < length; end++) {\n\t          if (this._charIsMappingSeparator(aStr, end)) {\n\t            break;\n\t          }\n\t        }\n\t        str = aStr.slice(index, end);\n\t\n\t        segment = cachedSegments[str];\n\t        if (segment) {\n\t          index += str.length;\n\t        } else {\n\t          segment = [];\n\t          while (index < end) {\n\t            base64VLQ.decode(aStr, index, temp);\n\t            value = temp.value;\n\t            index = temp.rest;\n\t            segment.push(value);\n\t          }\n\t\n\t          if (segment.length === 2) {\n\t            throw new Error('Found a source, but no line and column');\n\t          }\n\t\n\t          if (segment.length === 3) {\n\t            throw new Error('Found a source and line, but no column');\n\t          }\n\t\n\t          cachedSegments[str] = segment;\n\t        }\n\t\n\t        // Generated column.\n\t        mapping.generatedColumn = previousGeneratedColumn + segment[0];\n\t        previousGeneratedColumn = mapping.generatedColumn;\n\t\n\t        if (segment.length > 1) {\n\t          // Original source.\n\t          mapping.source = previousSource + segment[1];\n\t          previousSource += segment[1];\n\t\n\t          // Original line.\n\t          mapping.originalLine = previousOriginalLine + segment[2];\n\t          previousOriginalLine = mapping.originalLine;\n\t          // Lines are stored 0-based\n\t          mapping.originalLine += 1;\n\t\n\t          // Original column.\n\t          mapping.originalColumn = previousOriginalColumn + segment[3];\n\t          previousOriginalColumn = mapping.originalColumn;\n\t\n\t          if (segment.length > 4) {\n\t            // Original name.\n\t            mapping.name = previousName + segment[4];\n\t            previousName += segment[4];\n\t          }\n\t        }\n\t\n\t        generatedMappings.push(mapping);\n\t        if (typeof mapping.originalLine === 'number') {\n\t          originalMappings.push(mapping);\n\t        }\n\t      }\n\t    }\n\t\n\t    quickSort(generatedMappings, util.compareByGeneratedPositionsDeflated);\n\t    this.__generatedMappings = generatedMappings;\n\t\n\t    quickSort(originalMappings, util.compareByOriginalPositions);\n\t    this.__originalMappings = originalMappings;\n\t  };\n\t\n\t/**\n\t * Find the mapping that best matches the hypothetical \"needle\" mapping that\n\t * we are searching for in the given \"haystack\" of mappings.\n\t */\n\tBasicSourceMapConsumer.prototype._findMapping =\n\t  function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,\n\t                                         aColumnName, aComparator, aBias) {\n\t    // To return the position we are searching for, we must first find the\n\t    // mapping for the given position and then return the opposite position it\n\t    // points to. Because the mappings are sorted, we can use binary search to\n\t    // find the best mapping.\n\t\n\t    if (aNeedle[aLineName] <= 0) {\n\t      throw new TypeError('Line must be greater than or equal to 1, got '\n\t                          + aNeedle[aLineName]);\n\t    }\n\t    if (aNeedle[aColumnName] < 0) {\n\t      throw new TypeError('Column must be greater than or equal to 0, got '\n\t                          + aNeedle[aColumnName]);\n\t    }\n\t\n\t    return binarySearch.search(aNeedle, aMappings, aComparator, aBias);\n\t  };\n\t\n\t/**\n\t * Compute the last column for each generated mapping. The last column is\n\t * inclusive.\n\t */\n\tBasicSourceMapConsumer.prototype.computeColumnSpans =\n\t  function SourceMapConsumer_computeColumnSpans() {\n\t    for (var index = 0; index < this._generatedMappings.length; ++index) {\n\t      var mapping = this._generatedMappings[index];\n\t\n\t      // Mappings do not contain a field for the last generated columnt. We\n\t      // can come up with an optimistic estimate, however, by assuming that\n\t      // mappings are contiguous (i.e. given two consecutive mappings, the\n\t      // first mapping ends where the second one starts).\n\t      if (index + 1 < this._generatedMappings.length) {\n\t        var nextMapping = this._generatedMappings[index + 1];\n\t\n\t        if (mapping.generatedLine === nextMapping.generatedLine) {\n\t          mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;\n\t          continue;\n\t        }\n\t      }\n\t\n\t      // The last mapping for each line spans the entire line.\n\t      mapping.lastGeneratedColumn = Infinity;\n\t    }\n\t  };\n\t\n\t/**\n\t * Returns the original source, line, and column information for the generated\n\t * source's line and column positions provided. The only argument is an object\n\t * with the following properties:\n\t *\n\t *   - line: The line number in the generated source.\n\t *   - column: The column number in the generated source.\n\t *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or\n\t *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the\n\t *     closest element that is smaller than or greater than the one we are\n\t *     searching for, respectively, if the exact element cannot be found.\n\t *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.\n\t *\n\t * and an object is returned with the following properties:\n\t *\n\t *   - source: The original source file, or null.\n\t *   - line: The line number in the original source, or null.\n\t *   - column: The column number in the original source, or null.\n\t *   - name: The original identifier, or null.\n\t */\n\tBasicSourceMapConsumer.prototype.originalPositionFor =\n\t  function SourceMapConsumer_originalPositionFor(aArgs) {\n\t    var needle = {\n\t      generatedLine: util.getArg(aArgs, 'line'),\n\t      generatedColumn: util.getArg(aArgs, 'column')\n\t    };\n\t\n\t    var index = this._findMapping(\n\t      needle,\n\t      this._generatedMappings,\n\t      \"generatedLine\",\n\t      \"generatedColumn\",\n\t      util.compareByGeneratedPositionsDeflated,\n\t      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)\n\t    );\n\t\n\t    if (index >= 0) {\n\t      var mapping = this._generatedMappings[index];\n\t\n\t      if (mapping.generatedLine === needle.generatedLine) {\n\t        var source = util.getArg(mapping, 'source', null);\n\t        if (source !== null) {\n\t          source = this._sources.at(source);\n\t          if (this.sourceRoot != null) {\n\t            source = util.join(this.sourceRoot, source);\n\t          }\n\t        }\n\t        var name = util.getArg(mapping, 'name', null);\n\t        if (name !== null) {\n\t          name = this._names.at(name);\n\t        }\n\t        return {\n\t          source: source,\n\t          line: util.getArg(mapping, 'originalLine', null),\n\t          column: util.getArg(mapping, 'originalColumn', null),\n\t          name: name\n\t        };\n\t      }\n\t    }\n\t\n\t    return {\n\t      source: null,\n\t      line: null,\n\t      column: null,\n\t      name: null\n\t    };\n\t  };\n\t\n\t/**\n\t * Return true if we have the source content for every source in the source\n\t * map, false otherwise.\n\t */\n\tBasicSourceMapConsumer.prototype.hasContentsOfAllSources =\n\t  function BasicSourceMapConsumer_hasContentsOfAllSources() {\n\t    if (!this.sourcesContent) {\n\t      return false;\n\t    }\n\t    return this.sourcesContent.length >= this._sources.size() &&\n\t      !this.sourcesContent.some(function (sc) { return sc == null; });\n\t  };\n\t\n\t/**\n\t * Returns the original source content. The only argument is the url of the\n\t * original source file. Returns null if no original source content is\n\t * available.\n\t */\n\tBasicSourceMapConsumer.prototype.sourceContentFor =\n\t  function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {\n\t    if (!this.sourcesContent) {\n\t      return null;\n\t    }\n\t\n\t    if (this.sourceRoot != null) {\n\t      aSource = util.relative(this.sourceRoot, aSource);\n\t    }\n\t\n\t    if (this._sources.has(aSource)) {\n\t      return this.sourcesContent[this._sources.indexOf(aSource)];\n\t    }\n\t\n\t    var url;\n\t    if (this.sourceRoot != null\n\t        && (url = util.urlParse(this.sourceRoot))) {\n\t      // XXX: file:// URIs and absolute paths lead to unexpected behavior for\n\t      // many users. We can help them out when they expect file:// URIs to\n\t      // behave like it would if they were running a local HTTP server. See\n\t      // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.\n\t      var fileUriAbsPath = aSource.replace(/^file:\\/\\//, \"\");\n\t      if (url.scheme == \"file\"\n\t          && this._sources.has(fileUriAbsPath)) {\n\t        return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]\n\t      }\n\t\n\t      if ((!url.path || url.path == \"/\")\n\t          && this._sources.has(\"/\" + aSource)) {\n\t        return this.sourcesContent[this._sources.indexOf(\"/\" + aSource)];\n\t      }\n\t    }\n\t\n\t    // This function is used recursively from\n\t    // IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we\n\t    // don't want to throw if we can't find the source - we just want to\n\t    // return null, so we provide a flag to exit gracefully.\n\t    if (nullOnMissing) {\n\t      return null;\n\t    }\n\t    else {\n\t      throw new Error('\"' + aSource + '\" is not in the SourceMap.');\n\t    }\n\t  };\n\t\n\t/**\n\t * Returns the generated line and column information for the original source,\n\t * line, and column positions provided. The only argument is an object with\n\t * the following properties:\n\t *\n\t *   - source: The filename of the original source.\n\t *   - line: The line number in the original source.\n\t *   - column: The column number in the original source.\n\t *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or\n\t *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the\n\t *     closest element that is smaller than or greater than the one we are\n\t *     searching for, respectively, if the exact element cannot be found.\n\t *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.\n\t *\n\t * and an object is returned with the following properties:\n\t *\n\t *   - line: The line number in the generated source, or null.\n\t *   - column: The column number in the generated source, or null.\n\t */\n\tBasicSourceMapConsumer.prototype.generatedPositionFor =\n\t  function SourceMapConsumer_generatedPositionFor(aArgs) {\n\t    var source = util.getArg(aArgs, 'source');\n\t    if (this.sourceRoot != null) {\n\t      source = util.relative(this.sourceRoot, source);\n\t    }\n\t    if (!this._sources.has(source)) {\n\t      return {\n\t        line: null,\n\t        column: null,\n\t        lastColumn: null\n\t      };\n\t    }\n\t    source = this._sources.indexOf(source);\n\t\n\t    var needle = {\n\t      source: source,\n\t      originalLine: util.getArg(aArgs, 'line'),\n\t      originalColumn: util.getArg(aArgs, 'column')\n\t    };\n\t\n\t    var index = this._findMapping(\n\t      needle,\n\t      this._originalMappings,\n\t      \"originalLine\",\n\t      \"originalColumn\",\n\t      util.compareByOriginalPositions,\n\t      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)\n\t    );\n\t\n\t    if (index >= 0) {\n\t      var mapping = this._originalMappings[index];\n\t\n\t      if (mapping.source === needle.source) {\n\t        return {\n\t          line: util.getArg(mapping, 'generatedLine', null),\n\t          column: util.getArg(mapping, 'generatedColumn', null),\n\t          lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n\t        };\n\t      }\n\t    }\n\t\n\t    return {\n\t      line: null,\n\t      column: null,\n\t      lastColumn: null\n\t    };\n\t  };\n\t\n\texports.BasicSourceMapConsumer = BasicSourceMapConsumer;\n\t\n\t/**\n\t * An IndexedSourceMapConsumer instance represents a parsed source map which\n\t * we can query for information. It differs from BasicSourceMapConsumer in\n\t * that it takes \"indexed\" source maps (i.e. ones with a \"sections\" field) as\n\t * input.\n\t *\n\t * The only parameter is a raw source map (either as a JSON string, or already\n\t * parsed to an object). According to the spec for indexed source maps, they\n\t * have the following attributes:\n\t *\n\t *   - version: Which version of the source map spec this map is following.\n\t *   - file: Optional. The generated file this source map is associated with.\n\t *   - sections: A list of section definitions.\n\t *\n\t * Each value under the \"sections\" field has two fields:\n\t *   - offset: The offset into the original specified at which this section\n\t *       begins to apply, defined as an object with a \"line\" and \"column\"\n\t *       field.\n\t *   - map: A source map definition. This source map could also be indexed,\n\t *       but doesn't have to be.\n\t *\n\t * Instead of the \"map\" field, it's also possible to have a \"url\" field\n\t * specifying a URL to retrieve a source map from, but that's currently\n\t * unsupported.\n\t *\n\t * Here's an example source map, taken from the source map spec[0], but\n\t * modified to omit a section which uses the \"url\" field.\n\t *\n\t *  {\n\t *    version : 3,\n\t *    file: \"app.js\",\n\t *    sections: [{\n\t *      offset: {line:100, column:10},\n\t *      map: {\n\t *        version : 3,\n\t *        file: \"section.js\",\n\t *        sources: [\"foo.js\", \"bar.js\"],\n\t *        names: [\"src\", \"maps\", \"are\", \"fun\"],\n\t *        mappings: \"AAAA,E;;ABCDE;\"\n\t *      }\n\t *    }],\n\t *  }\n\t *\n\t * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt\n\t */\n\tfunction IndexedSourceMapConsumer(aSourceMap) {\n\t  var sourceMap = aSourceMap;\n\t  if (typeof aSourceMap === 'string') {\n\t    sourceMap = JSON.parse(aSourceMap.replace(/^\\)\\]\\}'/, ''));\n\t  }\n\t\n\t  var version = util.getArg(sourceMap, 'version');\n\t  var sections = util.getArg(sourceMap, 'sections');\n\t\n\t  if (version != this._version) {\n\t    throw new Error('Unsupported version: ' + version);\n\t  }\n\t\n\t  this._sources = new ArraySet();\n\t  this._names = new ArraySet();\n\t\n\t  var lastOffset = {\n\t    line: -1,\n\t    column: 0\n\t  };\n\t  this._sections = sections.map(function (s) {\n\t    if (s.url) {\n\t      // The url field will require support for asynchronicity.\n\t      // See https://github.com/mozilla/source-map/issues/16\n\t      throw new Error('Support for url field in sections not implemented.');\n\t    }\n\t    var offset = util.getArg(s, 'offset');\n\t    var offsetLine = util.getArg(offset, 'line');\n\t    var offsetColumn = util.getArg(offset, 'column');\n\t\n\t    if (offsetLine < lastOffset.line ||\n\t        (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {\n\t      throw new Error('Section offsets must be ordered and non-overlapping.');\n\t    }\n\t    lastOffset = offset;\n\t\n\t    return {\n\t      generatedOffset: {\n\t        // The offset fields are 0-based, but we use 1-based indices when\n\t        // encoding/decoding from VLQ.\n\t        generatedLine: offsetLine + 1,\n\t        generatedColumn: offsetColumn + 1\n\t      },\n\t      consumer: new SourceMapConsumer(util.getArg(s, 'map'))\n\t    }\n\t  });\n\t}\n\t\n\tIndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);\n\tIndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;\n\t\n\t/**\n\t * The version of the source mapping spec that we are consuming.\n\t */\n\tIndexedSourceMapConsumer.prototype._version = 3;\n\t\n\t/**\n\t * The list of original sources.\n\t */\n\tObject.defineProperty(IndexedSourceMapConsumer.prototype, 'sources', {\n\t  get: function () {\n\t    var sources = [];\n\t    for (var i = 0; i < this._sections.length; i++) {\n\t      for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {\n\t        sources.push(this._sections[i].consumer.sources[j]);\n\t      }\n\t    }\n\t    return sources;\n\t  }\n\t});\n\t\n\t/**\n\t * Returns the original source, line, and column information for the generated\n\t * source's line and column positions provided. The only argument is an object\n\t * with the following properties:\n\t *\n\t *   - line: The line number in the generated source.\n\t *   - column: The column number in the generated source.\n\t *\n\t * and an object is returned with the following properties:\n\t *\n\t *   - source: The original source file, or null.\n\t *   - line: The line number in the original source, or null.\n\t *   - column: The column number in the original source, or null.\n\t *   - name: The original identifier, or null.\n\t */\n\tIndexedSourceMapConsumer.prototype.originalPositionFor =\n\t  function IndexedSourceMapConsumer_originalPositionFor(aArgs) {\n\t    var needle = {\n\t      generatedLine: util.getArg(aArgs, 'line'),\n\t      generatedColumn: util.getArg(aArgs, 'column')\n\t    };\n\t\n\t    // Find the section containing the generated position we're trying to map\n\t    // to an original position.\n\t    var sectionIndex = binarySearch.search(needle, this._sections,\n\t      function(needle, section) {\n\t        var cmp = needle.generatedLine - section.generatedOffset.generatedLine;\n\t        if (cmp) {\n\t          return cmp;\n\t        }\n\t\n\t        return (needle.generatedColumn -\n\t                section.generatedOffset.generatedColumn);\n\t      });\n\t    var section = this._sections[sectionIndex];\n\t\n\t    if (!section) {\n\t      return {\n\t        source: null,\n\t        line: null,\n\t        column: null,\n\t        name: null\n\t      };\n\t    }\n\t\n\t    return section.consumer.originalPositionFor({\n\t      line: needle.generatedLine -\n\t        (section.generatedOffset.generatedLine - 1),\n\t      column: needle.generatedColumn -\n\t        (section.generatedOffset.generatedLine === needle.generatedLine\n\t         ? section.generatedOffset.generatedColumn - 1\n\t         : 0),\n\t      bias: aArgs.bias\n\t    });\n\t  };\n\t\n\t/**\n\t * Return true if we have the source content for every source in the source\n\t * map, false otherwise.\n\t */\n\tIndexedSourceMapConsumer.prototype.hasContentsOfAllSources =\n\t  function IndexedSourceMapConsumer_hasContentsOfAllSources() {\n\t    return this._sections.every(function (s) {\n\t      return s.consumer.hasContentsOfAllSources();\n\t    });\n\t  };\n\t\n\t/**\n\t * Returns the original source content. The only argument is the url of the\n\t * original source file. Returns null if no original source content is\n\t * available.\n\t */\n\tIndexedSourceMapConsumer.prototype.sourceContentFor =\n\t  function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {\n\t    for (var i = 0; i < this._sections.length; i++) {\n\t      var section = this._sections[i];\n\t\n\t      var content = section.consumer.sourceContentFor(aSource, true);\n\t      if (content) {\n\t        return content;\n\t      }\n\t    }\n\t    if (nullOnMissing) {\n\t      return null;\n\t    }\n\t    else {\n\t      throw new Error('\"' + aSource + '\" is not in the SourceMap.');\n\t    }\n\t  };\n\t\n\t/**\n\t * Returns the generated line and column information for the original source,\n\t * line, and column positions provided. The only argument is an object with\n\t * the following properties:\n\t *\n\t *   - source: The filename of the original source.\n\t *   - line: The line number in the original source.\n\t *   - column: The column number in the original source.\n\t *\n\t * and an object is returned with the following properties:\n\t *\n\t *   - line: The line number in the generated source, or null.\n\t *   - column: The column number in the generated source, or null.\n\t */\n\tIndexedSourceMapConsumer.prototype.generatedPositionFor =\n\t  function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {\n\t    for (var i = 0; i < this._sections.length; i++) {\n\t      var section = this._sections[i];\n\t\n\t      // Only consider this section if the requested source is in the list of\n\t      // sources of the consumer.\n\t      if (section.consumer.sources.indexOf(util.getArg(aArgs, 'source')) === -1) {\n\t        continue;\n\t      }\n\t      var generatedPosition = section.consumer.generatedPositionFor(aArgs);\n\t      if (generatedPosition) {\n\t        var ret = {\n\t          line: generatedPosition.line +\n\t            (section.generatedOffset.generatedLine - 1),\n\t          column: generatedPosition.column +\n\t            (section.generatedOffset.generatedLine === generatedPosition.line\n\t             ? section.generatedOffset.generatedColumn - 1\n\t             : 0)\n\t        };\n\t        return ret;\n\t      }\n\t    }\n\t\n\t    return {\n\t      line: null,\n\t      column: null\n\t    };\n\t  };\n\t\n\t/**\n\t * Parse the mappings in a string in to a data structure which we can easily\n\t * query (the ordered arrays in the `this.__generatedMappings` and\n\t * `this.__originalMappings` properties).\n\t */\n\tIndexedSourceMapConsumer.prototype._parseMappings =\n\t  function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n\t    this.__generatedMappings = [];\n\t    this.__originalMappings = [];\n\t    for (var i = 0; i < this._sections.length; i++) {\n\t      var section = this._sections[i];\n\t      var sectionMappings = section.consumer._generatedMappings;\n\t      for (var j = 0; j < sectionMappings.length; j++) {\n\t        var mapping = sectionMappings[j];\n\t\n\t        var source = section.consumer._sources.at(mapping.source);\n\t        if (section.consumer.sourceRoot !== null) {\n\t          source = util.join(section.consumer.sourceRoot, source);\n\t        }\n\t        this._sources.add(source);\n\t        source = this._sources.indexOf(source);\n\t\n\t        var name = section.consumer._names.at(mapping.name);\n\t        this._names.add(name);\n\t        name = this._names.indexOf(name);\n\t\n\t        // The mappings coming from the consumer for the section have\n\t        // generated positions relative to the start of the section, so we\n\t        // need to offset them to be relative to the start of the concatenated\n\t        // generated file.\n\t        var adjustedMapping = {\n\t          source: source,\n\t          generatedLine: mapping.generatedLine +\n\t            (section.generatedOffset.generatedLine - 1),\n\t          generatedColumn: mapping.generatedColumn +\n\t            (section.generatedOffset.generatedLine === mapping.generatedLine\n\t            ? section.generatedOffset.generatedColumn - 1\n\t            : 0),\n\t          originalLine: mapping.originalLine,\n\t          originalColumn: mapping.originalColumn,\n\t          name: name\n\t        };\n\t\n\t        this.__generatedMappings.push(adjustedMapping);\n\t        if (typeof adjustedMapping.originalLine === 'number') {\n\t          this.__originalMappings.push(adjustedMapping);\n\t        }\n\t      }\n\t    }\n\t\n\t    quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);\n\t    quickSort(this.__originalMappings, util.compareByOriginalPositions);\n\t  };\n\t\n\texports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;\n\n\n/***/ }),\n/* 8 */\n/***/ (function(module, exports) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\t\n\texports.GREATEST_LOWER_BOUND = 1;\n\texports.LEAST_UPPER_BOUND = 2;\n\t\n\t/**\n\t * Recursive implementation of binary search.\n\t *\n\t * @param aLow Indices here and lower do not contain the needle.\n\t * @param aHigh Indices here and higher do not contain the needle.\n\t * @param aNeedle The element being searched for.\n\t * @param aHaystack The non-empty array being searched.\n\t * @param aCompare Function which takes two elements and returns -1, 0, or 1.\n\t * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or\n\t *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the\n\t *     closest element that is smaller than or greater than the one we are\n\t *     searching for, respectively, if the exact element cannot be found.\n\t */\n\tfunction recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {\n\t  // This function terminates when one of the following is true:\n\t  //\n\t  //   1. We find the exact element we are looking for.\n\t  //\n\t  //   2. We did not find the exact element, but we can return the index of\n\t  //      the next-closest element.\n\t  //\n\t  //   3. We did not find the exact element, and there is no next-closest\n\t  //      element than the one we are searching for, so we return -1.\n\t  var mid = Math.floor((aHigh - aLow) / 2) + aLow;\n\t  var cmp = aCompare(aNeedle, aHaystack[mid], true);\n\t  if (cmp === 0) {\n\t    // Found the element we are looking for.\n\t    return mid;\n\t  }\n\t  else if (cmp > 0) {\n\t    // Our needle is greater than aHaystack[mid].\n\t    if (aHigh - mid > 1) {\n\t      // The element is in the upper half.\n\t      return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);\n\t    }\n\t\n\t    // The exact needle element was not found in this haystack. Determine if\n\t    // we are in termination case (3) or (2) and return the appropriate thing.\n\t    if (aBias == exports.LEAST_UPPER_BOUND) {\n\t      return aHigh < aHaystack.length ? aHigh : -1;\n\t    } else {\n\t      return mid;\n\t    }\n\t  }\n\t  else {\n\t    // Our needle is less than aHaystack[mid].\n\t    if (mid - aLow > 1) {\n\t      // The element is in the lower half.\n\t      return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);\n\t    }\n\t\n\t    // we are in termination case (3) or (2) and return the appropriate thing.\n\t    if (aBias == exports.LEAST_UPPER_BOUND) {\n\t      return mid;\n\t    } else {\n\t      return aLow < 0 ? -1 : aLow;\n\t    }\n\t  }\n\t}\n\t\n\t/**\n\t * This is an implementation of binary search which will always try and return\n\t * the index of the closest element if there is no exact hit. This is because\n\t * mappings between original and generated line/col pairs are single points,\n\t * and there is an implicit region between each of them, so a miss just means\n\t * that you aren't on the very start of a region.\n\t *\n\t * @param aNeedle The element you are looking for.\n\t * @param aHaystack The array that is being searched.\n\t * @param aCompare A function which takes the needle and an element in the\n\t *     array and returns -1, 0, or 1 depending on whether the needle is less\n\t *     than, equal to, or greater than the element, respectively.\n\t * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or\n\t *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the\n\t *     closest element that is smaller than or greater than the one we are\n\t *     searching for, respectively, if the exact element cannot be found.\n\t *     Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.\n\t */\n\texports.search = function search(aNeedle, aHaystack, aCompare, aBias) {\n\t  if (aHaystack.length === 0) {\n\t    return -1;\n\t  }\n\t\n\t  var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack,\n\t                              aCompare, aBias || exports.GREATEST_LOWER_BOUND);\n\t  if (index < 0) {\n\t    return -1;\n\t  }\n\t\n\t  // We have found either the exact element, or the next-closest element than\n\t  // the one we are searching for. However, there may be more than one such\n\t  // element. Make sure we always return the smallest of these.\n\t  while (index - 1 >= 0) {\n\t    if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {\n\t      break;\n\t    }\n\t    --index;\n\t  }\n\t\n\t  return index;\n\t};\n\n\n/***/ }),\n/* 9 */\n/***/ (function(module, exports) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\t\n\t// It turns out that some (most?) JavaScript engines don't self-host\n\t// `Array.prototype.sort`. This makes sense because C++ will likely remain\n\t// faster than JS when doing raw CPU-intensive sorting. However, when using a\n\t// custom comparator function, calling back and forth between the VM's C++ and\n\t// JIT'd JS is rather slow *and* loses JIT type information, resulting in\n\t// worse generated code for the comparator function than would be optimal. In\n\t// fact, when sorting with a comparator, these costs outweigh the benefits of\n\t// sorting in C++. By using our own JS-implemented Quick Sort (below), we get\n\t// a ~3500ms mean speed-up in `bench/bench.html`.\n\t\n\t/**\n\t * Swap the elements indexed by `x` and `y` in the array `ary`.\n\t *\n\t * @param {Array} ary\n\t *        The array.\n\t * @param {Number} x\n\t *        The index of the first item.\n\t * @param {Number} y\n\t *        The index of the second item.\n\t */\n\tfunction swap(ary, x, y) {\n\t  var temp = ary[x];\n\t  ary[x] = ary[y];\n\t  ary[y] = temp;\n\t}\n\t\n\t/**\n\t * Returns a random integer within the range `low .. high` inclusive.\n\t *\n\t * @param {Number} low\n\t *        The lower bound on the range.\n\t * @param {Number} high\n\t *        The upper bound on the range.\n\t */\n\tfunction randomIntInRange(low, high) {\n\t  return Math.round(low + (Math.random() * (high - low)));\n\t}\n\t\n\t/**\n\t * The Quick Sort algorithm.\n\t *\n\t * @param {Array} ary\n\t *        An array to sort.\n\t * @param {function} comparator\n\t *        Function to use to compare two items.\n\t * @param {Number} p\n\t *        Start index of the array\n\t * @param {Number} r\n\t *        End index of the array\n\t */\n\tfunction doQuickSort(ary, comparator, p, r) {\n\t  // If our lower bound is less than our upper bound, we (1) partition the\n\t  // array into two pieces and (2) recurse on each half. If it is not, this is\n\t  // the empty array and our base case.\n\t\n\t  if (p < r) {\n\t    // (1) Partitioning.\n\t    //\n\t    // The partitioning chooses a pivot between `p` and `r` and moves all\n\t    // elements that are less than or equal to the pivot to the before it, and\n\t    // all the elements that are greater than it after it. The effect is that\n\t    // once partition is done, the pivot is in the exact place it will be when\n\t    // the array is put in sorted order, and it will not need to be moved\n\t    // again. This runs in O(n) time.\n\t\n\t    // Always choose a random pivot so that an input array which is reverse\n\t    // sorted does not cause O(n^2) running time.\n\t    var pivotIndex = randomIntInRange(p, r);\n\t    var i = p - 1;\n\t\n\t    swap(ary, pivotIndex, r);\n\t    var pivot = ary[r];\n\t\n\t    // Immediately after `j` is incremented in this loop, the following hold\n\t    // true:\n\t    //\n\t    //   * Every element in `ary[p .. i]` is less than or equal to the pivot.\n\t    //\n\t    //   * Every element in `ary[i+1 .. j-1]` is greater than the pivot.\n\t    for (var j = p; j < r; j++) {\n\t      if (comparator(ary[j], pivot) <= 0) {\n\t        i += 1;\n\t        swap(ary, i, j);\n\t      }\n\t    }\n\t\n\t    swap(ary, i + 1, j);\n\t    var q = i + 1;\n\t\n\t    // (2) Recurse on each half.\n\t\n\t    doQuickSort(ary, comparator, p, q - 1);\n\t    doQuickSort(ary, comparator, q + 1, r);\n\t  }\n\t}\n\t\n\t/**\n\t * Sort the given array in-place with the given comparator function.\n\t *\n\t * @param {Array} ary\n\t *        An array to sort.\n\t * @param {function} comparator\n\t *        Function to use to compare two items.\n\t */\n\texports.quickSort = function (ary, comparator) {\n\t  doQuickSort(ary, comparator, 0, ary.length - 1);\n\t};\n\n\n/***/ }),\n/* 10 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t/* -*- Mode: js; js-indent-level: 2; -*- */\n\t/*\n\t * Copyright 2011 Mozilla Foundation and contributors\n\t * Licensed under the New BSD license. See LICENSE or:\n\t * http://opensource.org/licenses/BSD-3-Clause\n\t */\n\t\n\tvar SourceMapGenerator = __webpack_require__(1).SourceMapGenerator;\n\tvar util = __webpack_require__(4);\n\t\n\t// Matches a Windows-style `\\r\\n` newline or a `\\n` newline used by all other\n\t// operating systems these days (capturing the result).\n\tvar REGEX_NEWLINE = /(\\r?\\n)/;\n\t\n\t// Newline character code for charCodeAt() comparisons\n\tvar NEWLINE_CODE = 10;\n\t\n\t// Private symbol for identifying `SourceNode`s when multiple versions of\n\t// the source-map library are loaded. This MUST NOT CHANGE across\n\t// versions!\n\tvar isSourceNode = \"$$$isSourceNode$$$\";\n\t\n\t/**\n\t * SourceNodes provide a way to abstract over interpolating/concatenating\n\t * snippets of generated JavaScript source code while maintaining the line and\n\t * column information associated with the original source code.\n\t *\n\t * @param aLine The original line number.\n\t * @param aColumn The original column number.\n\t * @param aSource The original source's filename.\n\t * @param aChunks Optional. An array of strings which are snippets of\n\t *        generated JS, or other SourceNodes.\n\t * @param aName The original identifier.\n\t */\n\tfunction SourceNode(aLine, aColumn, aSource, aChunks, aName) {\n\t  this.children = [];\n\t  this.sourceContents = {};\n\t  this.line = aLine == null ? null : aLine;\n\t  this.column = aColumn == null ? null : aColumn;\n\t  this.source = aSource == null ? null : aSource;\n\t  this.name = aName == null ? null : aName;\n\t  this[isSourceNode] = true;\n\t  if (aChunks != null) this.add(aChunks);\n\t}\n\t\n\t/**\n\t * Creates a SourceNode from generated code and a SourceMapConsumer.\n\t *\n\t * @param aGeneratedCode The generated code\n\t * @param aSourceMapConsumer The SourceMap for the generated code\n\t * @param aRelativePath Optional. The path that relative sources in the\n\t *        SourceMapConsumer should be relative to.\n\t */\n\tSourceNode.fromStringWithSourceMap =\n\t  function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {\n\t    // The SourceNode we want to fill with the generated code\n\t    // and the SourceMap\n\t    var node = new SourceNode();\n\t\n\t    // All even indices of this array are one line of the generated code,\n\t    // while all odd indices are the newlines between two adjacent lines\n\t    // (since `REGEX_NEWLINE` captures its match).\n\t    // Processed fragments are accessed by calling `shiftNextLine`.\n\t    var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);\n\t    var remainingLinesIndex = 0;\n\t    var shiftNextLine = function() {\n\t      var lineContents = getNextLine();\n\t      // The last line of a file might not have a newline.\n\t      var newLine = getNextLine() || \"\";\n\t      return lineContents + newLine;\n\t\n\t      function getNextLine() {\n\t        return remainingLinesIndex < remainingLines.length ?\n\t            remainingLines[remainingLinesIndex++] : undefined;\n\t      }\n\t    };\n\t\n\t    // We need to remember the position of \"remainingLines\"\n\t    var lastGeneratedLine = 1, lastGeneratedColumn = 0;\n\t\n\t    // The generate SourceNodes we need a code range.\n\t    // To extract it current and last mapping is used.\n\t    // Here we store the last mapping.\n\t    var lastMapping = null;\n\t\n\t    aSourceMapConsumer.eachMapping(function (mapping) {\n\t      if (lastMapping !== null) {\n\t        // We add the code from \"lastMapping\" to \"mapping\":\n\t        // First check if there is a new line in between.\n\t        if (lastGeneratedLine < mapping.generatedLine) {\n\t          // Associate first line with \"lastMapping\"\n\t          addMappingWithCode(lastMapping, shiftNextLine());\n\t          lastGeneratedLine++;\n\t          lastGeneratedColumn = 0;\n\t          // The remaining code is added without mapping\n\t        } else {\n\t          // There is no new line in between.\n\t          // Associate the code between \"lastGeneratedColumn\" and\n\t          // \"mapping.generatedColumn\" with \"lastMapping\"\n\t          var nextLine = remainingLines[remainingLinesIndex];\n\t          var code = nextLine.substr(0, mapping.generatedColumn -\n\t                                        lastGeneratedColumn);\n\t          remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn -\n\t                                              lastGeneratedColumn);\n\t          lastGeneratedColumn = mapping.generatedColumn;\n\t          addMappingWithCode(lastMapping, code);\n\t          // No more remaining code, continue\n\t          lastMapping = mapping;\n\t          return;\n\t        }\n\t      }\n\t      // We add the generated code until the first mapping\n\t      // to the SourceNode without any mapping.\n\t      // Each line is added as separate string.\n\t      while (lastGeneratedLine < mapping.generatedLine) {\n\t        node.add(shiftNextLine());\n\t        lastGeneratedLine++;\n\t      }\n\t      if (lastGeneratedColumn < mapping.generatedColumn) {\n\t        var nextLine = remainingLines[remainingLinesIndex];\n\t        node.add(nextLine.substr(0, mapping.generatedColumn));\n\t        remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);\n\t        lastGeneratedColumn = mapping.generatedColumn;\n\t      }\n\t      lastMapping = mapping;\n\t    }, this);\n\t    // We have processed all mappings.\n\t    if (remainingLinesIndex < remainingLines.length) {\n\t      if (lastMapping) {\n\t        // Associate the remaining code in the current line with \"lastMapping\"\n\t        addMappingWithCode(lastMapping, shiftNextLine());\n\t      }\n\t      // and add the remaining lines without any mapping\n\t      node.add(remainingLines.splice(remainingLinesIndex).join(\"\"));\n\t    }\n\t\n\t    // Copy sourcesContent into SourceNode\n\t    aSourceMapConsumer.sources.forEach(function (sourceFile) {\n\t      var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n\t      if (content != null) {\n\t        if (aRelativePath != null) {\n\t          sourceFile = util.join(aRelativePath, sourceFile);\n\t        }\n\t        node.setSourceContent(sourceFile, content);\n\t      }\n\t    });\n\t\n\t    return node;\n\t\n\t    function addMappingWithCode(mapping, code) {\n\t      if (mapping === null || mapping.source === undefined) {\n\t        node.add(code);\n\t      } else {\n\t        var source = aRelativePath\n\t          ? util.join(aRelativePath, mapping.source)\n\t          : mapping.source;\n\t        node.add(new SourceNode(mapping.originalLine,\n\t                                mapping.originalColumn,\n\t                                source,\n\t                                code,\n\t                                mapping.name));\n\t      }\n\t    }\n\t  };\n\t\n\t/**\n\t * Add a chunk of generated JS to this source node.\n\t *\n\t * @param aChunk A string snippet of generated JS code, another instance of\n\t *        SourceNode, or an array where each member is one of those things.\n\t */\n\tSourceNode.prototype.add = function SourceNode_add(aChunk) {\n\t  if (Array.isArray(aChunk)) {\n\t    aChunk.forEach(function (chunk) {\n\t      this.add(chunk);\n\t    }, this);\n\t  }\n\t  else if (aChunk[isSourceNode] || typeof aChunk === \"string\") {\n\t    if (aChunk) {\n\t      this.children.push(aChunk);\n\t    }\n\t  }\n\t  else {\n\t    throw new TypeError(\n\t      \"Expected a SourceNode, string, or an array of SourceNodes and strings. Got \" + aChunk\n\t    );\n\t  }\n\t  return this;\n\t};\n\t\n\t/**\n\t * Add a chunk of generated JS to the beginning of this source node.\n\t *\n\t * @param aChunk A string snippet of generated JS code, another instance of\n\t *        SourceNode, or an array where each member is one of those things.\n\t */\n\tSourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {\n\t  if (Array.isArray(aChunk)) {\n\t    for (var i = aChunk.length-1; i >= 0; i--) {\n\t      this.prepend(aChunk[i]);\n\t    }\n\t  }\n\t  else if (aChunk[isSourceNode] || typeof aChunk === \"string\") {\n\t    this.children.unshift(aChunk);\n\t  }\n\t  else {\n\t    throw new TypeError(\n\t      \"Expected a SourceNode, string, or an array of SourceNodes and strings. Got \" + aChunk\n\t    );\n\t  }\n\t  return this;\n\t};\n\t\n\t/**\n\t * Walk over the tree of JS snippets in this node and its children. The\n\t * walking function is called once for each snippet of JS and is passed that\n\t * snippet and the its original associated source's line/column location.\n\t *\n\t * @param aFn The traversal function.\n\t */\n\tSourceNode.prototype.walk = function SourceNode_walk(aFn) {\n\t  var chunk;\n\t  for (var i = 0, len = this.children.length; i < len; i++) {\n\t    chunk = this.children[i];\n\t    if (chunk[isSourceNode]) {\n\t      chunk.walk(aFn);\n\t    }\n\t    else {\n\t      if (chunk !== '') {\n\t        aFn(chunk, { source: this.source,\n\t                     line: this.line,\n\t                     column: this.column,\n\t                     name: this.name });\n\t      }\n\t    }\n\t  }\n\t};\n\t\n\t/**\n\t * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between\n\t * each of `this.children`.\n\t *\n\t * @param aSep The separator.\n\t */\n\tSourceNode.prototype.join = function SourceNode_join(aSep) {\n\t  var newChildren;\n\t  var i;\n\t  var len = this.children.length;\n\t  if (len > 0) {\n\t    newChildren = [];\n\t    for (i = 0; i < len-1; i++) {\n\t      newChildren.push(this.children[i]);\n\t      newChildren.push(aSep);\n\t    }\n\t    newChildren.push(this.children[i]);\n\t    this.children = newChildren;\n\t  }\n\t  return this;\n\t};\n\t\n\t/**\n\t * Call String.prototype.replace on the very right-most source snippet. Useful\n\t * for trimming whitespace from the end of a source node, etc.\n\t *\n\t * @param aPattern The pattern to replace.\n\t * @param aReplacement The thing to replace the pattern with.\n\t */\n\tSourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {\n\t  var lastChild = this.children[this.children.length - 1];\n\t  if (lastChild[isSourceNode]) {\n\t    lastChild.replaceRight(aPattern, aReplacement);\n\t  }\n\t  else if (typeof lastChild === 'string') {\n\t    this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);\n\t  }\n\t  else {\n\t    this.children.push(''.replace(aPattern, aReplacement));\n\t  }\n\t  return this;\n\t};\n\t\n\t/**\n\t * Set the source content for a source file. This will be added to the SourceMapGenerator\n\t * in the sourcesContent field.\n\t *\n\t * @param aSourceFile The filename of the source file\n\t * @param aSourceContent The content of the source file\n\t */\n\tSourceNode.prototype.setSourceContent =\n\t  function SourceNode_setSourceContent(aSourceFile, aSourceContent) {\n\t    this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;\n\t  };\n\t\n\t/**\n\t * Walk over the tree of SourceNodes. The walking function is called for each\n\t * source file content and is passed the filename and source content.\n\t *\n\t * @param aFn The traversal function.\n\t */\n\tSourceNode.prototype.walkSourceContents =\n\t  function SourceNode_walkSourceContents(aFn) {\n\t    for (var i = 0, len = this.children.length; i < len; i++) {\n\t      if (this.children[i][isSourceNode]) {\n\t        this.children[i].walkSourceContents(aFn);\n\t      }\n\t    }\n\t\n\t    var sources = Object.keys(this.sourceContents);\n\t    for (var i = 0, len = sources.length; i < len; i++) {\n\t      aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);\n\t    }\n\t  };\n\t\n\t/**\n\t * Return the string representation of this source node. Walks over the tree\n\t * and concatenates all the various snippets together to one string.\n\t */\n\tSourceNode.prototype.toString = function SourceNode_toString() {\n\t  var str = \"\";\n\t  this.walk(function (chunk) {\n\t    str += chunk;\n\t  });\n\t  return str;\n\t};\n\t\n\t/**\n\t * Returns the string representation of this source node along with a source\n\t * map.\n\t */\n\tSourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {\n\t  var generated = {\n\t    code: \"\",\n\t    line: 1,\n\t    column: 0\n\t  };\n\t  var map = new SourceMapGenerator(aArgs);\n\t  var sourceMappingActive = false;\n\t  var lastOriginalSource = null;\n\t  var lastOriginalLine = null;\n\t  var lastOriginalColumn = null;\n\t  var lastOriginalName = null;\n\t  this.walk(function (chunk, original) {\n\t    generated.code += chunk;\n\t    if (original.source !== null\n\t        && original.line !== null\n\t        && original.column !== null) {\n\t      if(lastOriginalSource !== original.source\n\t         || lastOriginalLine !== original.line\n\t         || lastOriginalColumn !== original.column\n\t         || lastOriginalName !== original.name) {\n\t        map.addMapping({\n\t          source: original.source,\n\t          original: {\n\t            line: original.line,\n\t            column: original.column\n\t          },\n\t          generated: {\n\t            line: generated.line,\n\t            column: generated.column\n\t          },\n\t          name: original.name\n\t        });\n\t      }\n\t      lastOriginalSource = original.source;\n\t      lastOriginalLine = original.line;\n\t      lastOriginalColumn = original.column;\n\t      lastOriginalName = original.name;\n\t      sourceMappingActive = true;\n\t    } else if (sourceMappingActive) {\n\t      map.addMapping({\n\t        generated: {\n\t          line: generated.line,\n\t          column: generated.column\n\t        }\n\t      });\n\t      lastOriginalSource = null;\n\t      sourceMappingActive = false;\n\t    }\n\t    for (var idx = 0, length = chunk.length; idx < length; idx++) {\n\t      if (chunk.charCodeAt(idx) === NEWLINE_CODE) {\n\t        generated.line++;\n\t        generated.column = 0;\n\t        // Mappings end at eol\n\t        if (idx + 1 === length) {\n\t          lastOriginalSource = null;\n\t          sourceMappingActive = false;\n\t        } else if (sourceMappingActive) {\n\t          map.addMapping({\n\t            source: original.source,\n\t            original: {\n\t              line: original.line,\n\t              column: original.column\n\t            },\n\t            generated: {\n\t              line: generated.line,\n\t              column: generated.column\n\t            },\n\t            name: original.name\n\t          });\n\t        }\n\t      } else {\n\t        generated.column++;\n\t      }\n\t    }\n\t  });\n\t  this.walkSourceContents(function (sourceFile, sourceContent) {\n\t    map.setSourceContent(sourceFile, sourceContent);\n\t  });\n\t\n\t  return { code: generated.code, map: map };\n\t};\n\t\n\texports.SourceNode = SourceNode;\n\n\n/***/ })\n/******/ ])\n});\n;\n\n\n// WEBPACK FOOTER //\n// source-map.min.js"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.loaded = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 42c329f865e32e011afb","/*\n * Copyright 2009-2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE.txt or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\nexports.SourceMapGenerator = require('./lib/source-map-generator').SourceMapGenerator;\nexports.SourceMapConsumer = require('./lib/source-map-consumer').SourceMapConsumer;\nexports.SourceNode = require('./lib/source-node').SourceNode;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./source-map.js\n// module id = 0\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar base64VLQ = require('./base64-vlq');\nvar util = require('./util');\nvar ArraySet = require('./array-set').ArraySet;\nvar MappingList = require('./mapping-list').MappingList;\n\n/**\n * An instance of the SourceMapGenerator represents a source map which is\n * being built incrementally. You may pass an object with the following\n * properties:\n *\n *   - file: The filename of the generated source.\n *   - sourceRoot: A root for all relative URLs in this source map.\n */\nfunction SourceMapGenerator(aArgs) {\n  if (!aArgs) {\n    aArgs = {};\n  }\n  this._file = util.getArg(aArgs, 'file', null);\n  this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);\n  this._skipValidation = util.getArg(aArgs, 'skipValidation', false);\n  this._sources = new ArraySet();\n  this._names = new ArraySet();\n  this._mappings = new MappingList();\n  this._sourcesContents = null;\n}\n\nSourceMapGenerator.prototype._version = 3;\n\n/**\n * Creates a new SourceMapGenerator based on a SourceMapConsumer\n *\n * @param aSourceMapConsumer The SourceMap.\n */\nSourceMapGenerator.fromSourceMap =\n  function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {\n    var sourceRoot = aSourceMapConsumer.sourceRoot;\n    var generator = new SourceMapGenerator({\n      file: aSourceMapConsumer.file,\n      sourceRoot: sourceRoot\n    });\n    aSourceMapConsumer.eachMapping(function (mapping) {\n      var newMapping = {\n        generated: {\n          line: mapping.generatedLine,\n          column: mapping.generatedColumn\n        }\n      };\n\n      if (mapping.source != null) {\n        newMapping.source = mapping.source;\n        if (sourceRoot != null) {\n          newMapping.source = util.relative(sourceRoot, newMapping.source);\n        }\n\n        newMapping.original = {\n          line: mapping.originalLine,\n          column: mapping.originalColumn\n        };\n\n        if (mapping.name != null) {\n          newMapping.name = mapping.name;\n        }\n      }\n\n      generator.addMapping(newMapping);\n    });\n    aSourceMapConsumer.sources.forEach(function (sourceFile) {\n      var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n      if (content != null) {\n        generator.setSourceContent(sourceFile, content);\n      }\n    });\n    return generator;\n  };\n\n/**\n * Add a single mapping from original source line and column to the generated\n * source's line and column for this source map being created. The mapping\n * object should have the following properties:\n *\n *   - generated: An object with the generated line and column positions.\n *   - original: An object with the original line and column positions.\n *   - source: The original source file (relative to the sourceRoot).\n *   - name: An optional original token name for this mapping.\n */\nSourceMapGenerator.prototype.addMapping =\n  function SourceMapGenerator_addMapping(aArgs) {\n    var generated = util.getArg(aArgs, 'generated');\n    var original = util.getArg(aArgs, 'original', null);\n    var source = util.getArg(aArgs, 'source', null);\n    var name = util.getArg(aArgs, 'name', null);\n\n    if (!this._skipValidation) {\n      this._validateMapping(generated, original, source, name);\n    }\n\n    if (source != null) {\n      source = String(source);\n      if (!this._sources.has(source)) {\n        this._sources.add(source);\n      }\n    }\n\n    if (name != null) {\n      name = String(name);\n      if (!this._names.has(name)) {\n        this._names.add(name);\n      }\n    }\n\n    this._mappings.add({\n      generatedLine: generated.line,\n      generatedColumn: generated.column,\n      originalLine: original != null && original.line,\n      originalColumn: original != null && original.column,\n      source: source,\n      name: name\n    });\n  };\n\n/**\n * Set the source content for a source file.\n */\nSourceMapGenerator.prototype.setSourceContent =\n  function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {\n    var source = aSourceFile;\n    if (this._sourceRoot != null) {\n      source = util.relative(this._sourceRoot, source);\n    }\n\n    if (aSourceContent != null) {\n      // Add the source content to the _sourcesContents map.\n      // Create a new _sourcesContents map if the property is null.\n      if (!this._sourcesContents) {\n        this._sourcesContents = Object.create(null);\n      }\n      this._sourcesContents[util.toSetString(source)] = aSourceContent;\n    } else if (this._sourcesContents) {\n      // Remove the source file from the _sourcesContents map.\n      // If the _sourcesContents map is empty, set the property to null.\n      delete this._sourcesContents[util.toSetString(source)];\n      if (Object.keys(this._sourcesContents).length === 0) {\n        this._sourcesContents = null;\n      }\n    }\n  };\n\n/**\n * Applies the mappings of a sub-source-map for a specific source file to the\n * source map being generated. Each mapping to the supplied source file is\n * rewritten using the supplied source map. Note: The resolution for the\n * resulting mappings is the minimium of this map and the supplied map.\n *\n * @param aSourceMapConsumer The source map to be applied.\n * @param aSourceFile Optional. The filename of the source file.\n *        If omitted, SourceMapConsumer's file property will be used.\n * @param aSourceMapPath Optional. The dirname of the path to the source map\n *        to be applied. If relative, it is relative to the SourceMapConsumer.\n *        This parameter is needed when the two source maps aren't in the same\n *        directory, and the source map to be applied contains relative source\n *        paths. If so, those relative source paths need to be rewritten\n *        relative to the SourceMapGenerator.\n */\nSourceMapGenerator.prototype.applySourceMap =\n  function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {\n    var sourceFile = aSourceFile;\n    // If aSourceFile is omitted, we will use the file property of the SourceMap\n    if (aSourceFile == null) {\n      if (aSourceMapConsumer.file == null) {\n        throw new Error(\n          'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +\n          'or the source map\\'s \"file\" property. Both were omitted.'\n        );\n      }\n      sourceFile = aSourceMapConsumer.file;\n    }\n    var sourceRoot = this._sourceRoot;\n    // Make \"sourceFile\" relative if an absolute Url is passed.\n    if (sourceRoot != null) {\n      sourceFile = util.relative(sourceRoot, sourceFile);\n    }\n    // Applying the SourceMap can add and remove items from the sources and\n    // the names array.\n    var newSources = new ArraySet();\n    var newNames = new ArraySet();\n\n    // Find mappings for the \"sourceFile\"\n    this._mappings.unsortedForEach(function (mapping) {\n      if (mapping.source === sourceFile && mapping.originalLine != null) {\n        // Check if it can be mapped by the source map, then update the mapping.\n        var original = aSourceMapConsumer.originalPositionFor({\n          line: mapping.originalLine,\n          column: mapping.originalColumn\n        });\n        if (original.source != null) {\n          // Copy mapping\n          mapping.source = original.source;\n          if (aSourceMapPath != null) {\n            mapping.source = util.join(aSourceMapPath, mapping.source)\n          }\n          if (sourceRoot != null) {\n            mapping.source = util.relative(sourceRoot, mapping.source);\n          }\n          mapping.originalLine = original.line;\n          mapping.originalColumn = original.column;\n          if (original.name != null) {\n            mapping.name = original.name;\n          }\n        }\n      }\n\n      var source = mapping.source;\n      if (source != null && !newSources.has(source)) {\n        newSources.add(source);\n      }\n\n      var name = mapping.name;\n      if (name != null && !newNames.has(name)) {\n        newNames.add(name);\n      }\n\n    }, this);\n    this._sources = newSources;\n    this._names = newNames;\n\n    // Copy sourcesContents of applied map.\n    aSourceMapConsumer.sources.forEach(function (sourceFile) {\n      var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n      if (content != null) {\n        if (aSourceMapPath != null) {\n          sourceFile = util.join(aSourceMapPath, sourceFile);\n        }\n        if (sourceRoot != null) {\n          sourceFile = util.relative(sourceRoot, sourceFile);\n        }\n        this.setSourceContent(sourceFile, content);\n      }\n    }, this);\n  };\n\n/**\n * A mapping can have one of the three levels of data:\n *\n *   1. Just the generated position.\n *   2. The Generated position, original position, and original source.\n *   3. Generated and original position, original source, as well as a name\n *      token.\n *\n * To maintain consistency, we validate that any new mapping being added falls\n * in to one of these categories.\n */\nSourceMapGenerator.prototype._validateMapping =\n  function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,\n                                              aName) {\n    // When aOriginal is truthy but has empty values for .line and .column,\n    // it is most likely a programmer error. In this case we throw a very\n    // specific error message to try to guide them the right way.\n    // For example: https://github.com/Polymer/polymer-bundler/pull/519\n    if (aOriginal && typeof aOriginal.line !== 'number' && typeof aOriginal.column !== 'number') {\n        throw new Error(\n            'original.line and original.column are not numbers -- you probably meant to omit ' +\n            'the original mapping entirely and only map the generated position. If so, pass ' +\n            'null for the original mapping instead of an object with empty or null values.'\n        );\n    }\n\n    if (aGenerated && 'line' in aGenerated && 'column' in aGenerated\n        && aGenerated.line > 0 && aGenerated.column >= 0\n        && !aOriginal && !aSource && !aName) {\n      // Case 1.\n      return;\n    }\n    else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated\n             && aOriginal && 'line' in aOriginal && 'column' in aOriginal\n             && aGenerated.line > 0 && aGenerated.column >= 0\n             && aOriginal.line > 0 && aOriginal.column >= 0\n             && aSource) {\n      // Cases 2 and 3.\n      return;\n    }\n    else {\n      throw new Error('Invalid mapping: ' + JSON.stringify({\n        generated: aGenerated,\n        source: aSource,\n        original: aOriginal,\n        name: aName\n      }));\n    }\n  };\n\n/**\n * Serialize the accumulated mappings in to the stream of base 64 VLQs\n * specified by the source map format.\n */\nSourceMapGenerator.prototype._serializeMappings =\n  function SourceMapGenerator_serializeMappings() {\n    var previousGeneratedColumn = 0;\n    var previousGeneratedLine = 1;\n    var previousOriginalColumn = 0;\n    var previousOriginalLine = 0;\n    var previousName = 0;\n    var previousSource = 0;\n    var result = '';\n    var next;\n    var mapping;\n    var nameIdx;\n    var sourceIdx;\n\n    var mappings = this._mappings.toArray();\n    for (var i = 0, len = mappings.length; i < len; i++) {\n      mapping = mappings[i];\n      next = ''\n\n      if (mapping.generatedLine !== previousGeneratedLine) {\n        previousGeneratedColumn = 0;\n        while (mapping.generatedLine !== previousGeneratedLine) {\n          next += ';';\n          previousGeneratedLine++;\n        }\n      }\n      else {\n        if (i > 0) {\n          if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {\n            continue;\n          }\n          next += ',';\n        }\n      }\n\n      next += base64VLQ.encode(mapping.generatedColumn\n                                 - previousGeneratedColumn);\n      previousGeneratedColumn = mapping.generatedColumn;\n\n      if (mapping.source != null) {\n        sourceIdx = this._sources.indexOf(mapping.source);\n        next += base64VLQ.encode(sourceIdx - previousSource);\n        previousSource = sourceIdx;\n\n        // lines are stored 0-based in SourceMap spec version 3\n        next += base64VLQ.encode(mapping.originalLine - 1\n                                   - previousOriginalLine);\n        previousOriginalLine = mapping.originalLine - 1;\n\n        next += base64VLQ.encode(mapping.originalColumn\n                                   - previousOriginalColumn);\n        previousOriginalColumn = mapping.originalColumn;\n\n        if (mapping.name != null) {\n          nameIdx = this._names.indexOf(mapping.name);\n          next += base64VLQ.encode(nameIdx - previousName);\n          previousName = nameIdx;\n        }\n      }\n\n      result += next;\n    }\n\n    return result;\n  };\n\nSourceMapGenerator.prototype._generateSourcesContent =\n  function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {\n    return aSources.map(function (source) {\n      if (!this._sourcesContents) {\n        return null;\n      }\n      if (aSourceRoot != null) {\n        source = util.relative(aSourceRoot, source);\n      }\n      var key = util.toSetString(source);\n      return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)\n        ? this._sourcesContents[key]\n        : null;\n    }, this);\n  };\n\n/**\n * Externalize the source map.\n */\nSourceMapGenerator.prototype.toJSON =\n  function SourceMapGenerator_toJSON() {\n    var map = {\n      version: this._version,\n      sources: this._sources.toArray(),\n      names: this._names.toArray(),\n      mappings: this._serializeMappings()\n    };\n    if (this._file != null) {\n      map.file = this._file;\n    }\n    if (this._sourceRoot != null) {\n      map.sourceRoot = this._sourceRoot;\n    }\n    if (this._sourcesContents) {\n      map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);\n    }\n\n    return map;\n  };\n\n/**\n * Render the source map being generated to a string.\n */\nSourceMapGenerator.prototype.toString =\n  function SourceMapGenerator_toString() {\n    return JSON.stringify(this.toJSON());\n  };\n\nexports.SourceMapGenerator = SourceMapGenerator;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/source-map-generator.js\n// module id = 1\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n *\n * Based on the Base 64 VLQ implementation in Closure Compiler:\n * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java\n *\n * Copyright 2011 The Closure Compiler Authors. All rights reserved.\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n *  * Redistributions of source code must retain the above copyright\n *    notice, this list of conditions and the following disclaimer.\n *  * Redistributions in binary form must reproduce the above\n *    copyright notice, this list of conditions and the following\n *    disclaimer in the documentation and/or other materials provided\n *    with the distribution.\n *  * Neither the name of Google Inc. nor the names of its\n *    contributors may be used to endorse or promote products derived\n *    from this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\nvar base64 = require('./base64');\n\n// A single base 64 digit can contain 6 bits of data. For the base 64 variable\n// length quantities we use in the source map spec, the first bit is the sign,\n// the next four bits are the actual value, and the 6th bit is the\n// continuation bit. The continuation bit tells us whether there are more\n// digits in this value following this digit.\n//\n//   Continuation\n//   |    Sign\n//   |    |\n//   V    V\n//   101011\n\nvar VLQ_BASE_SHIFT = 5;\n\n// binary: 100000\nvar VLQ_BASE = 1 << VLQ_BASE_SHIFT;\n\n// binary: 011111\nvar VLQ_BASE_MASK = VLQ_BASE - 1;\n\n// binary: 100000\nvar VLQ_CONTINUATION_BIT = VLQ_BASE;\n\n/**\n * Converts from a two-complement value to a value where the sign bit is\n * placed in the least significant bit.  For example, as decimals:\n *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)\n *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)\n */\nfunction toVLQSigned(aValue) {\n  return aValue < 0\n    ? ((-aValue) << 1) + 1\n    : (aValue << 1) + 0;\n}\n\n/**\n * Converts to a two-complement value from a value where the sign bit is\n * placed in the least significant bit.  For example, as decimals:\n *   2 (10 binary) becomes 1, 3 (11 binary) becomes -1\n *   4 (100 binary) becomes 2, 5 (101 binary) becomes -2\n */\nfunction fromVLQSigned(aValue) {\n  var isNegative = (aValue & 1) === 1;\n  var shifted = aValue >> 1;\n  return isNegative\n    ? -shifted\n    : shifted;\n}\n\n/**\n * Returns the base 64 VLQ encoded value.\n */\nexports.encode = function base64VLQ_encode(aValue) {\n  var encoded = \"\";\n  var digit;\n\n  var vlq = toVLQSigned(aValue);\n\n  do {\n    digit = vlq & VLQ_BASE_MASK;\n    vlq >>>= VLQ_BASE_SHIFT;\n    if (vlq > 0) {\n      // There are still more digits in this value, so we must make sure the\n      // continuation bit is marked.\n      digit |= VLQ_CONTINUATION_BIT;\n    }\n    encoded += base64.encode(digit);\n  } while (vlq > 0);\n\n  return encoded;\n};\n\n/**\n * Decodes the next base 64 VLQ value from the given string and returns the\n * value and the rest of the string via the out parameter.\n */\nexports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {\n  var strLen = aStr.length;\n  var result = 0;\n  var shift = 0;\n  var continuation, digit;\n\n  do {\n    if (aIndex >= strLen) {\n      throw new Error(\"Expected more digits in base 64 VLQ value.\");\n    }\n\n    digit = base64.decode(aStr.charCodeAt(aIndex++));\n    if (digit === -1) {\n      throw new Error(\"Invalid base64 digit: \" + aStr.charAt(aIndex - 1));\n    }\n\n    continuation = !!(digit & VLQ_CONTINUATION_BIT);\n    digit &= VLQ_BASE_MASK;\n    result = result + (digit << shift);\n    shift += VLQ_BASE_SHIFT;\n  } while (continuation);\n\n  aOutParam.value = fromVLQSigned(result);\n  aOutParam.rest = aIndex;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/base64-vlq.js\n// module id = 2\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar intToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');\n\n/**\n * Encode an integer in the range of 0 to 63 to a single base 64 digit.\n */\nexports.encode = function (number) {\n  if (0 <= number && number < intToCharMap.length) {\n    return intToCharMap[number];\n  }\n  throw new TypeError(\"Must be between 0 and 63: \" + number);\n};\n\n/**\n * Decode a single base 64 character code digit to an integer. Returns -1 on\n * failure.\n */\nexports.decode = function (charCode) {\n  var bigA = 65;     // 'A'\n  var bigZ = 90;     // 'Z'\n\n  var littleA = 97;  // 'a'\n  var littleZ = 122; // 'z'\n\n  var zero = 48;     // '0'\n  var nine = 57;     // '9'\n\n  var plus = 43;     // '+'\n  var slash = 47;    // '/'\n\n  var littleOffset = 26;\n  var numberOffset = 52;\n\n  // 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ\n  if (bigA <= charCode && charCode <= bigZ) {\n    return (charCode - bigA);\n  }\n\n  // 26 - 51: abcdefghijklmnopqrstuvwxyz\n  if (littleA <= charCode && charCode <= littleZ) {\n    return (charCode - littleA + littleOffset);\n  }\n\n  // 52 - 61: 0123456789\n  if (zero <= charCode && charCode <= nine) {\n    return (charCode - zero + numberOffset);\n  }\n\n  // 62: +\n  if (charCode == plus) {\n    return 62;\n  }\n\n  // 63: /\n  if (charCode == slash) {\n    return 63;\n  }\n\n  // Invalid base64 digit.\n  return -1;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/base64.js\n// module id = 3\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\n/**\n * This is a helper function for getting values from parameter/options\n * objects.\n *\n * @param args The object we are extracting values from\n * @param name The name of the property we are getting.\n * @param defaultValue An optional value to return if the property is missing\n * from the object. If this is not specified and the property is missing, an\n * error will be thrown.\n */\nfunction getArg(aArgs, aName, aDefaultValue) {\n  if (aName in aArgs) {\n    return aArgs[aName];\n  } else if (arguments.length === 3) {\n    return aDefaultValue;\n  } else {\n    throw new Error('\"' + aName + '\" is a required argument.');\n  }\n}\nexports.getArg = getArg;\n\nvar urlRegexp = /^(?:([\\w+\\-.]+):)?\\/\\/(?:(\\w+:\\w+)@)?([\\w.]*)(?::(\\d+))?(\\S*)$/;\nvar dataUrlRegexp = /^data:.+\\,.+$/;\n\nfunction urlParse(aUrl) {\n  var match = aUrl.match(urlRegexp);\n  if (!match) {\n    return null;\n  }\n  return {\n    scheme: match[1],\n    auth: match[2],\n    host: match[3],\n    port: match[4],\n    path: match[5]\n  };\n}\nexports.urlParse = urlParse;\n\nfunction urlGenerate(aParsedUrl) {\n  var url = '';\n  if (aParsedUrl.scheme) {\n    url += aParsedUrl.scheme + ':';\n  }\n  url += '//';\n  if (aParsedUrl.auth) {\n    url += aParsedUrl.auth + '@';\n  }\n  if (aParsedUrl.host) {\n    url += aParsedUrl.host;\n  }\n  if (aParsedUrl.port) {\n    url += \":\" + aParsedUrl.port\n  }\n  if (aParsedUrl.path) {\n    url += aParsedUrl.path;\n  }\n  return url;\n}\nexports.urlGenerate = urlGenerate;\n\n/**\n * Normalizes a path, or the path portion of a URL:\n *\n * - Replaces consecutive slashes with one slash.\n * - Removes unnecessary '.' parts.\n * - Removes unnecessary '<dir>/..' parts.\n *\n * Based on code in the Node.js 'path' core module.\n *\n * @param aPath The path or url to normalize.\n */\nfunction normalize(aPath) {\n  var path = aPath;\n  var url = urlParse(aPath);\n  if (url) {\n    if (!url.path) {\n      return aPath;\n    }\n    path = url.path;\n  }\n  var isAbsolute = exports.isAbsolute(path);\n\n  var parts = path.split(/\\/+/);\n  for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {\n    part = parts[i];\n    if (part === '.') {\n      parts.splice(i, 1);\n    } else if (part === '..') {\n      up++;\n    } else if (up > 0) {\n      if (part === '') {\n        // The first part is blank if the path is absolute. Trying to go\n        // above the root is a no-op. Therefore we can remove all '..' parts\n        // directly after the root.\n        parts.splice(i + 1, up);\n        up = 0;\n      } else {\n        parts.splice(i, 2);\n        up--;\n      }\n    }\n  }\n  path = parts.join('/');\n\n  if (path === '') {\n    path = isAbsolute ? '/' : '.';\n  }\n\n  if (url) {\n    url.path = path;\n    return urlGenerate(url);\n  }\n  return path;\n}\nexports.normalize = normalize;\n\n/**\n * Joins two paths/URLs.\n *\n * @param aRoot The root path or URL.\n * @param aPath The path or URL to be joined with the root.\n *\n * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a\n *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended\n *   first.\n * - Otherwise aPath is a path. If aRoot is a URL, then its path portion\n *   is updated with the result and aRoot is returned. Otherwise the result\n *   is returned.\n *   - If aPath is absolute, the result is aPath.\n *   - Otherwise the two paths are joined with a slash.\n * - Joining for example 'http://' and 'www.example.com' is also supported.\n */\nfunction join(aRoot, aPath) {\n  if (aRoot === \"\") {\n    aRoot = \".\";\n  }\n  if (aPath === \"\") {\n    aPath = \".\";\n  }\n  var aPathUrl = urlParse(aPath);\n  var aRootUrl = urlParse(aRoot);\n  if (aRootUrl) {\n    aRoot = aRootUrl.path || '/';\n  }\n\n  // `join(foo, '//www.example.org')`\n  if (aPathUrl && !aPathUrl.scheme) {\n    if (aRootUrl) {\n      aPathUrl.scheme = aRootUrl.scheme;\n    }\n    return urlGenerate(aPathUrl);\n  }\n\n  if (aPathUrl || aPath.match(dataUrlRegexp)) {\n    return aPath;\n  }\n\n  // `join('http://', 'www.example.com')`\n  if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {\n    aRootUrl.host = aPath;\n    return urlGenerate(aRootUrl);\n  }\n\n  var joined = aPath.charAt(0) === '/'\n    ? aPath\n    : normalize(aRoot.replace(/\\/+$/, '') + '/' + aPath);\n\n  if (aRootUrl) {\n    aRootUrl.path = joined;\n    return urlGenerate(aRootUrl);\n  }\n  return joined;\n}\nexports.join = join;\n\nexports.isAbsolute = function (aPath) {\n  return aPath.charAt(0) === '/' || !!aPath.match(urlRegexp);\n};\n\n/**\n * Make a path relative to a URL or another path.\n *\n * @param aRoot The root path or URL.\n * @param aPath The path or URL to be made relative to aRoot.\n */\nfunction relative(aRoot, aPath) {\n  if (aRoot === \"\") {\n    aRoot = \".\";\n  }\n\n  aRoot = aRoot.replace(/\\/$/, '');\n\n  // It is possible for the path to be above the root. In this case, simply\n  // checking whether the root is a prefix of the path won't work. Instead, we\n  // need to remove components from the root one by one, until either we find\n  // a prefix that fits, or we run out of components to remove.\n  var level = 0;\n  while (aPath.indexOf(aRoot + '/') !== 0) {\n    var index = aRoot.lastIndexOf(\"/\");\n    if (index < 0) {\n      return aPath;\n    }\n\n    // If the only part of the root that is left is the scheme (i.e. http://,\n    // file:///, etc.), one or more slashes (/), or simply nothing at all, we\n    // have exhausted all components, so the path is not relative to the root.\n    aRoot = aRoot.slice(0, index);\n    if (aRoot.match(/^([^\\/]+:\\/)?\\/*$/)) {\n      return aPath;\n    }\n\n    ++level;\n  }\n\n  // Make sure we add a \"../\" for each component we removed from the root.\n  return Array(level + 1).join(\"../\") + aPath.substr(aRoot.length + 1);\n}\nexports.relative = relative;\n\nvar supportsNullProto = (function () {\n  var obj = Object.create(null);\n  return !('__proto__' in obj);\n}());\n\nfunction identity (s) {\n  return s;\n}\n\n/**\n * Because behavior goes wacky when you set `__proto__` on objects, we\n * have to prefix all the strings in our set with an arbitrary character.\n *\n * See https://github.com/mozilla/source-map/pull/31 and\n * https://github.com/mozilla/source-map/issues/30\n *\n * @param String aStr\n */\nfunction toSetString(aStr) {\n  if (isProtoString(aStr)) {\n    return '$' + aStr;\n  }\n\n  return aStr;\n}\nexports.toSetString = supportsNullProto ? identity : toSetString;\n\nfunction fromSetString(aStr) {\n  if (isProtoString(aStr)) {\n    return aStr.slice(1);\n  }\n\n  return aStr;\n}\nexports.fromSetString = supportsNullProto ? identity : fromSetString;\n\nfunction isProtoString(s) {\n  if (!s) {\n    return false;\n  }\n\n  var length = s.length;\n\n  if (length < 9 /* \"__proto__\".length */) {\n    return false;\n  }\n\n  if (s.charCodeAt(length - 1) !== 95  /* '_' */ ||\n      s.charCodeAt(length - 2) !== 95  /* '_' */ ||\n      s.charCodeAt(length - 3) !== 111 /* 'o' */ ||\n      s.charCodeAt(length - 4) !== 116 /* 't' */ ||\n      s.charCodeAt(length - 5) !== 111 /* 'o' */ ||\n      s.charCodeAt(length - 6) !== 114 /* 'r' */ ||\n      s.charCodeAt(length - 7) !== 112 /* 'p' */ ||\n      s.charCodeAt(length - 8) !== 95  /* '_' */ ||\n      s.charCodeAt(length - 9) !== 95  /* '_' */) {\n    return false;\n  }\n\n  for (var i = length - 10; i >= 0; i--) {\n    if (s.charCodeAt(i) !== 36 /* '$' */) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Comparator between two mappings where the original positions are compared.\n *\n * Optionally pass in `true` as `onlyCompareGenerated` to consider two\n * mappings with the same original source/line/column, but different generated\n * line and column the same. Useful when searching for a mapping with a\n * stubbed out mapping.\n */\nfunction compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {\n  var cmp = mappingA.source - mappingB.source;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalLine - mappingB.originalLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalColumn - mappingB.originalColumn;\n  if (cmp !== 0 || onlyCompareOriginal) {\n    return cmp;\n  }\n\n  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.generatedLine - mappingB.generatedLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  return mappingA.name - mappingB.name;\n}\nexports.compareByOriginalPositions = compareByOriginalPositions;\n\n/**\n * Comparator between two mappings with deflated source and name indices where\n * the generated positions are compared.\n *\n * Optionally pass in `true` as `onlyCompareGenerated` to consider two\n * mappings with the same generated line and column, but different\n * source/name/original line and column the same. Useful when searching for a\n * mapping with a stubbed out mapping.\n */\nfunction compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {\n  var cmp = mappingA.generatedLine - mappingB.generatedLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n  if (cmp !== 0 || onlyCompareGenerated) {\n    return cmp;\n  }\n\n  cmp = mappingA.source - mappingB.source;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalLine - mappingB.originalLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalColumn - mappingB.originalColumn;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  return mappingA.name - mappingB.name;\n}\nexports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;\n\nfunction strcmp(aStr1, aStr2) {\n  if (aStr1 === aStr2) {\n    return 0;\n  }\n\n  if (aStr1 > aStr2) {\n    return 1;\n  }\n\n  return -1;\n}\n\n/**\n * Comparator between two mappings with inflated source and name strings where\n * the generated positions are compared.\n */\nfunction compareByGeneratedPositionsInflated(mappingA, mappingB) {\n  var cmp = mappingA.generatedLine - mappingB.generatedLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = strcmp(mappingA.source, mappingB.source);\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalLine - mappingB.originalLine;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  cmp = mappingA.originalColumn - mappingB.originalColumn;\n  if (cmp !== 0) {\n    return cmp;\n  }\n\n  return strcmp(mappingA.name, mappingB.name);\n}\nexports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/util.js\n// module id = 4\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar util = require('./util');\nvar has = Object.prototype.hasOwnProperty;\nvar hasNativeMap = typeof Map !== \"undefined\";\n\n/**\n * A data structure which is a combination of an array and a set. Adding a new\n * member is O(1), testing for membership is O(1), and finding the index of an\n * element is O(1). Removing elements from the set is not supported. Only\n * strings are supported for membership.\n */\nfunction ArraySet() {\n  this._array = [];\n  this._set = hasNativeMap ? new Map() : Object.create(null);\n}\n\n/**\n * Static method for creating ArraySet instances from an existing array.\n */\nArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {\n  var set = new ArraySet();\n  for (var i = 0, len = aArray.length; i < len; i++) {\n    set.add(aArray[i], aAllowDuplicates);\n  }\n  return set;\n};\n\n/**\n * Return how many unique items are in this ArraySet. If duplicates have been\n * added, than those do not count towards the size.\n *\n * @returns Number\n */\nArraySet.prototype.size = function ArraySet_size() {\n  return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;\n};\n\n/**\n * Add the given string to this set.\n *\n * @param String aStr\n */\nArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {\n  var sStr = hasNativeMap ? aStr : util.toSetString(aStr);\n  var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);\n  var idx = this._array.length;\n  if (!isDuplicate || aAllowDuplicates) {\n    this._array.push(aStr);\n  }\n  if (!isDuplicate) {\n    if (hasNativeMap) {\n      this._set.set(aStr, idx);\n    } else {\n      this._set[sStr] = idx;\n    }\n  }\n};\n\n/**\n * Is the given string a member of this set?\n *\n * @param String aStr\n */\nArraySet.prototype.has = function ArraySet_has(aStr) {\n  if (hasNativeMap) {\n    return this._set.has(aStr);\n  } else {\n    var sStr = util.toSetString(aStr);\n    return has.call(this._set, sStr);\n  }\n};\n\n/**\n * What is the index of the given string in the array?\n *\n * @param String aStr\n */\nArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {\n  if (hasNativeMap) {\n    var idx = this._set.get(aStr);\n    if (idx >= 0) {\n        return idx;\n    }\n  } else {\n    var sStr = util.toSetString(aStr);\n    if (has.call(this._set, sStr)) {\n      return this._set[sStr];\n    }\n  }\n\n  throw new Error('\"' + aStr + '\" is not in the set.');\n};\n\n/**\n * What is the element at the given index?\n *\n * @param Number aIdx\n */\nArraySet.prototype.at = function ArraySet_at(aIdx) {\n  if (aIdx >= 0 && aIdx < this._array.length) {\n    return this._array[aIdx];\n  }\n  throw new Error('No element indexed by ' + aIdx);\n};\n\n/**\n * Returns the array representation of this set (which has the proper indices\n * indicated by indexOf). Note that this is a copy of the internal array used\n * for storing the members so that no one can mess with internal state.\n */\nArraySet.prototype.toArray = function ArraySet_toArray() {\n  return this._array.slice();\n};\n\nexports.ArraySet = ArraySet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/array-set.js\n// module id = 5\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2014 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar util = require('./util');\n\n/**\n * Determine whether mappingB is after mappingA with respect to generated\n * position.\n */\nfunction generatedPositionAfter(mappingA, mappingB) {\n  // Optimized for most common case\n  var lineA = mappingA.generatedLine;\n  var lineB = mappingB.generatedLine;\n  var columnA = mappingA.generatedColumn;\n  var columnB = mappingB.generatedColumn;\n  return lineB > lineA || lineB == lineA && columnB >= columnA ||\n         util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;\n}\n\n/**\n * A data structure to provide a sorted view of accumulated mappings in a\n * performance conscious manner. It trades a neglibable overhead in general\n * case for a large speedup in case of mappings being added in order.\n */\nfunction MappingList() {\n  this._array = [];\n  this._sorted = true;\n  // Serves as infimum\n  this._last = {generatedLine: -1, generatedColumn: 0};\n}\n\n/**\n * Iterate through internal items. This method takes the same arguments that\n * `Array.prototype.forEach` takes.\n *\n * NOTE: The order of the mappings is NOT guaranteed.\n */\nMappingList.prototype.unsortedForEach =\n  function MappingList_forEach(aCallback, aThisArg) {\n    this._array.forEach(aCallback, aThisArg);\n  };\n\n/**\n * Add the given source mapping.\n *\n * @param Object aMapping\n */\nMappingList.prototype.add = function MappingList_add(aMapping) {\n  if (generatedPositionAfter(this._last, aMapping)) {\n    this._last = aMapping;\n    this._array.push(aMapping);\n  } else {\n    this._sorted = false;\n    this._array.push(aMapping);\n  }\n};\n\n/**\n * Returns the flat, sorted array of mappings. The mappings are sorted by\n * generated position.\n *\n * WARNING: This method returns internal data without copying, for\n * performance. The return value must NOT be mutated, and should be treated as\n * an immutable borrow. If you want to take ownership, you must make your own\n * copy.\n */\nMappingList.prototype.toArray = function MappingList_toArray() {\n  if (!this._sorted) {\n    this._array.sort(util.compareByGeneratedPositionsInflated);\n    this._sorted = true;\n  }\n  return this._array;\n};\n\nexports.MappingList = MappingList;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/mapping-list.js\n// module id = 6\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar util = require('./util');\nvar binarySearch = require('./binary-search');\nvar ArraySet = require('./array-set').ArraySet;\nvar base64VLQ = require('./base64-vlq');\nvar quickSort = require('./quick-sort').quickSort;\n\nfunction SourceMapConsumer(aSourceMap) {\n  var sourceMap = aSourceMap;\n  if (typeof aSourceMap === 'string') {\n    sourceMap = JSON.parse(aSourceMap.replace(/^\\)\\]\\}'/, ''));\n  }\n\n  return sourceMap.sections != null\n    ? new IndexedSourceMapConsumer(sourceMap)\n    : new BasicSourceMapConsumer(sourceMap);\n}\n\nSourceMapConsumer.fromSourceMap = function(aSourceMap) {\n  return BasicSourceMapConsumer.fromSourceMap(aSourceMap);\n}\n\n/**\n * The version of the source mapping spec that we are consuming.\n */\nSourceMapConsumer.prototype._version = 3;\n\n// `__generatedMappings` and `__originalMappings` are arrays that hold the\n// parsed mapping coordinates from the source map's \"mappings\" attribute. They\n// are lazily instantiated, accessed via the `_generatedMappings` and\n// `_originalMappings` getters respectively, and we only parse the mappings\n// and create these arrays once queried for a source location. We jump through\n// these hoops because there can be many thousands of mappings, and parsing\n// them is expensive, so we only want to do it if we must.\n//\n// Each object in the arrays is of the form:\n//\n//     {\n//       generatedLine: The line number in the generated code,\n//       generatedColumn: The column number in the generated code,\n//       source: The path to the original source file that generated this\n//               chunk of code,\n//       originalLine: The line number in the original source that\n//                     corresponds to this chunk of generated code,\n//       originalColumn: The column number in the original source that\n//                       corresponds to this chunk of generated code,\n//       name: The name of the original symbol which generated this chunk of\n//             code.\n//     }\n//\n// All properties except for `generatedLine` and `generatedColumn` can be\n// `null`.\n//\n// `_generatedMappings` is ordered by the generated positions.\n//\n// `_originalMappings` is ordered by the original positions.\n\nSourceMapConsumer.prototype.__generatedMappings = null;\nObject.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {\n  get: function () {\n    if (!this.__generatedMappings) {\n      this._parseMappings(this._mappings, this.sourceRoot);\n    }\n\n    return this.__generatedMappings;\n  }\n});\n\nSourceMapConsumer.prototype.__originalMappings = null;\nObject.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {\n  get: function () {\n    if (!this.__originalMappings) {\n      this._parseMappings(this._mappings, this.sourceRoot);\n    }\n\n    return this.__originalMappings;\n  }\n});\n\nSourceMapConsumer.prototype._charIsMappingSeparator =\n  function SourceMapConsumer_charIsMappingSeparator(aStr, index) {\n    var c = aStr.charAt(index);\n    return c === \";\" || c === \",\";\n  };\n\n/**\n * Parse the mappings in a string in to a data structure which we can easily\n * query (the ordered arrays in the `this.__generatedMappings` and\n * `this.__originalMappings` properties).\n */\nSourceMapConsumer.prototype._parseMappings =\n  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n    throw new Error(\"Subclasses must implement _parseMappings\");\n  };\n\nSourceMapConsumer.GENERATED_ORDER = 1;\nSourceMapConsumer.ORIGINAL_ORDER = 2;\n\nSourceMapConsumer.GREATEST_LOWER_BOUND = 1;\nSourceMapConsumer.LEAST_UPPER_BOUND = 2;\n\n/**\n * Iterate over each mapping between an original source/line/column and a\n * generated line/column in this source map.\n *\n * @param Function aCallback\n *        The function that is called with each mapping.\n * @param Object aContext\n *        Optional. If specified, this object will be the value of `this` every\n *        time that `aCallback` is called.\n * @param aOrder\n *        Either `SourceMapConsumer.GENERATED_ORDER` or\n *        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to\n *        iterate over the mappings sorted by the generated file's line/column\n *        order or the original's source/line/column order, respectively. Defaults to\n *        `SourceMapConsumer.GENERATED_ORDER`.\n */\nSourceMapConsumer.prototype.eachMapping =\n  function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {\n    var context = aContext || null;\n    var order = aOrder || SourceMapConsumer.GENERATED_ORDER;\n\n    var mappings;\n    switch (order) {\n    case SourceMapConsumer.GENERATED_ORDER:\n      mappings = this._generatedMappings;\n      break;\n    case SourceMapConsumer.ORIGINAL_ORDER:\n      mappings = this._originalMappings;\n      break;\n    default:\n      throw new Error(\"Unknown order of iteration.\");\n    }\n\n    var sourceRoot = this.sourceRoot;\n    mappings.map(function (mapping) {\n      var source = mapping.source === null ? null : this._sources.at(mapping.source);\n      if (source != null && sourceRoot != null) {\n        source = util.join(sourceRoot, source);\n      }\n      return {\n        source: source,\n        generatedLine: mapping.generatedLine,\n        generatedColumn: mapping.generatedColumn,\n        originalLine: mapping.originalLine,\n        originalColumn: mapping.originalColumn,\n        name: mapping.name === null ? null : this._names.at(mapping.name)\n      };\n    }, this).forEach(aCallback, context);\n  };\n\n/**\n * Returns all generated line and column information for the original source,\n * line, and column provided. If no column is provided, returns all mappings\n * corresponding to a either the line we are searching for or the next\n * closest line that has any mappings. Otherwise, returns all mappings\n * corresponding to the given line and either the column we are searching for\n * or the next closest column that has any offsets.\n *\n * The only argument is an object with the following properties:\n *\n *   - source: The filename of the original source.\n *   - line: The line number in the original source.\n *   - column: Optional. the column number in the original source.\n *\n * and an array of objects is returned, each with the following properties:\n *\n *   - line: The line number in the generated source, or null.\n *   - column: The column number in the generated source, or null.\n */\nSourceMapConsumer.prototype.allGeneratedPositionsFor =\n  function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {\n    var line = util.getArg(aArgs, 'line');\n\n    // When there is no exact match, BasicSourceMapConsumer.prototype._findMapping\n    // returns the index of the closest mapping less than the needle. By\n    // setting needle.originalColumn to 0, we thus find the last mapping for\n    // the given line, provided such a mapping exists.\n    var needle = {\n      source: util.getArg(aArgs, 'source'),\n      originalLine: line,\n      originalColumn: util.getArg(aArgs, 'column', 0)\n    };\n\n    if (this.sourceRoot != null) {\n      needle.source = util.relative(this.sourceRoot, needle.source);\n    }\n    if (!this._sources.has(needle.source)) {\n      return [];\n    }\n    needle.source = this._sources.indexOf(needle.source);\n\n    var mappings = [];\n\n    var index = this._findMapping(needle,\n                                  this._originalMappings,\n                                  \"originalLine\",\n                                  \"originalColumn\",\n                                  util.compareByOriginalPositions,\n                                  binarySearch.LEAST_UPPER_BOUND);\n    if (index >= 0) {\n      var mapping = this._originalMappings[index];\n\n      if (aArgs.column === undefined) {\n        var originalLine = mapping.originalLine;\n\n        // Iterate until either we run out of mappings, or we run into\n        // a mapping for a different line than the one we found. Since\n        // mappings are sorted, this is guaranteed to find all mappings for\n        // the line we found.\n        while (mapping && mapping.originalLine === originalLine) {\n          mappings.push({\n            line: util.getArg(mapping, 'generatedLine', null),\n            column: util.getArg(mapping, 'generatedColumn', null),\n            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n          });\n\n          mapping = this._originalMappings[++index];\n        }\n      } else {\n        var originalColumn = mapping.originalColumn;\n\n        // Iterate until either we run out of mappings, or we run into\n        // a mapping for a different line than the one we were searching for.\n        // Since mappings are sorted, this is guaranteed to find all mappings for\n        // the line we are searching for.\n        while (mapping &&\n               mapping.originalLine === line &&\n               mapping.originalColumn == originalColumn) {\n          mappings.push({\n            line: util.getArg(mapping, 'generatedLine', null),\n            column: util.getArg(mapping, 'generatedColumn', null),\n            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n          });\n\n          mapping = this._originalMappings[++index];\n        }\n      }\n    }\n\n    return mappings;\n  };\n\nexports.SourceMapConsumer = SourceMapConsumer;\n\n/**\n * A BasicSourceMapConsumer instance represents a parsed source map which we can\n * query for information about the original file positions by giving it a file\n * position in the generated source.\n *\n * The only parameter is the raw source map (either as a JSON string, or\n * already parsed to an object). According to the spec, source maps have the\n * following attributes:\n *\n *   - version: Which version of the source map spec this map is following.\n *   - sources: An array of URLs to the original source files.\n *   - names: An array of identifiers which can be referrenced by individual mappings.\n *   - sourceRoot: Optional. The URL root from which all sources are relative.\n *   - sourcesContent: Optional. An array of contents of the original source files.\n *   - mappings: A string of base64 VLQs which contain the actual mappings.\n *   - file: Optional. The generated file this source map is associated with.\n *\n * Here is an example source map, taken from the source map spec[0]:\n *\n *     {\n *       version : 3,\n *       file: \"out.js\",\n *       sourceRoot : \"\",\n *       sources: [\"foo.js\", \"bar.js\"],\n *       names: [\"src\", \"maps\", \"are\", \"fun\"],\n *       mappings: \"AA,AB;;ABCDE;\"\n *     }\n *\n * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#\n */\nfunction BasicSourceMapConsumer(aSourceMap) {\n  var sourceMap = aSourceMap;\n  if (typeof aSourceMap === 'string') {\n    sourceMap = JSON.parse(aSourceMap.replace(/^\\)\\]\\}'/, ''));\n  }\n\n  var version = util.getArg(sourceMap, 'version');\n  var sources = util.getArg(sourceMap, 'sources');\n  // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which\n  // requires the array) to play nice here.\n  var names = util.getArg(sourceMap, 'names', []);\n  var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);\n  var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);\n  var mappings = util.getArg(sourceMap, 'mappings');\n  var file = util.getArg(sourceMap, 'file', null);\n\n  // Once again, Sass deviates from the spec and supplies the version as a\n  // string rather than a number, so we use loose equality checking here.\n  if (version != this._version) {\n    throw new Error('Unsupported version: ' + version);\n  }\n\n  sources = sources\n    .map(String)\n    // Some source maps produce relative source paths like \"./foo.js\" instead of\n    // \"foo.js\".  Normalize these first so that future comparisons will succeed.\n    // See bugzil.la/1090768.\n    .map(util.normalize)\n    // Always ensure that absolute sources are internally stored relative to\n    // the source root, if the source root is absolute. Not doing this would\n    // be particularly problematic when the source root is a prefix of the\n    // source (valid, but why??). See github issue #199 and bugzil.la/1188982.\n    .map(function (source) {\n      return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source)\n        ? util.relative(sourceRoot, source)\n        : source;\n    });\n\n  // Pass `true` below to allow duplicate names and sources. While source maps\n  // are intended to be compressed and deduplicated, the TypeScript compiler\n  // sometimes generates source maps with duplicates in them. See Github issue\n  // #72 and bugzil.la/889492.\n  this._names = ArraySet.fromArray(names.map(String), true);\n  this._sources = ArraySet.fromArray(sources, true);\n\n  this.sourceRoot = sourceRoot;\n  this.sourcesContent = sourcesContent;\n  this._mappings = mappings;\n  this.file = file;\n}\n\nBasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);\nBasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;\n\n/**\n * Create a BasicSourceMapConsumer from a SourceMapGenerator.\n *\n * @param SourceMapGenerator aSourceMap\n *        The source map that will be consumed.\n * @returns BasicSourceMapConsumer\n */\nBasicSourceMapConsumer.fromSourceMap =\n  function SourceMapConsumer_fromSourceMap(aSourceMap) {\n    var smc = Object.create(BasicSourceMapConsumer.prototype);\n\n    var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);\n    var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);\n    smc.sourceRoot = aSourceMap._sourceRoot;\n    smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),\n                                                            smc.sourceRoot);\n    smc.file = aSourceMap._file;\n\n    // Because we are modifying the entries (by converting string sources and\n    // names to indices into the sources and names ArraySets), we have to make\n    // a copy of the entry or else bad things happen. Shared mutable state\n    // strikes again! See github issue #191.\n\n    var generatedMappings = aSourceMap._mappings.toArray().slice();\n    var destGeneratedMappings = smc.__generatedMappings = [];\n    var destOriginalMappings = smc.__originalMappings = [];\n\n    for (var i = 0, length = generatedMappings.length; i < length; i++) {\n      var srcMapping = generatedMappings[i];\n      var destMapping = new Mapping;\n      destMapping.generatedLine = srcMapping.generatedLine;\n      destMapping.generatedColumn = srcMapping.generatedColumn;\n\n      if (srcMapping.source) {\n        destMapping.source = sources.indexOf(srcMapping.source);\n        destMapping.originalLine = srcMapping.originalLine;\n        destMapping.originalColumn = srcMapping.originalColumn;\n\n        if (srcMapping.name) {\n          destMapping.name = names.indexOf(srcMapping.name);\n        }\n\n        destOriginalMappings.push(destMapping);\n      }\n\n      destGeneratedMappings.push(destMapping);\n    }\n\n    quickSort(smc.__originalMappings, util.compareByOriginalPositions);\n\n    return smc;\n  };\n\n/**\n * The version of the source mapping spec that we are consuming.\n */\nBasicSourceMapConsumer.prototype._version = 3;\n\n/**\n * The list of original sources.\n */\nObject.defineProperty(BasicSourceMapConsumer.prototype, 'sources', {\n  get: function () {\n    return this._sources.toArray().map(function (s) {\n      return this.sourceRoot != null ? util.join(this.sourceRoot, s) : s;\n    }, this);\n  }\n});\n\n/**\n * Provide the JIT with a nice shape / hidden class.\n */\nfunction Mapping() {\n  this.generatedLine = 0;\n  this.generatedColumn = 0;\n  this.source = null;\n  this.originalLine = null;\n  this.originalColumn = null;\n  this.name = null;\n}\n\n/**\n * Parse the mappings in a string in to a data structure which we can easily\n * query (the ordered arrays in the `this.__generatedMappings` and\n * `this.__originalMappings` properties).\n */\nBasicSourceMapConsumer.prototype._parseMappings =\n  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n    var generatedLine = 1;\n    var previousGeneratedColumn = 0;\n    var previousOriginalLine = 0;\n    var previousOriginalColumn = 0;\n    var previousSource = 0;\n    var previousName = 0;\n    var length = aStr.length;\n    var index = 0;\n    var cachedSegments = {};\n    var temp = {};\n    var originalMappings = [];\n    var generatedMappings = [];\n    var mapping, str, segment, end, value;\n\n    while (index < length) {\n      if (aStr.charAt(index) === ';') {\n        generatedLine++;\n        index++;\n        previousGeneratedColumn = 0;\n      }\n      else if (aStr.charAt(index) === ',') {\n        index++;\n      }\n      else {\n        mapping = new Mapping();\n        mapping.generatedLine = generatedLine;\n\n        // Because each offset is encoded relative to the previous one,\n        // many segments often have the same encoding. We can exploit this\n        // fact by caching the parsed variable length fields of each segment,\n        // allowing us to avoid a second parse if we encounter the same\n        // segment again.\n        for (end = index; end < length; end++) {\n          if (this._charIsMappingSeparator(aStr, end)) {\n            break;\n          }\n        }\n        str = aStr.slice(index, end);\n\n        segment = cachedSegments[str];\n        if (segment) {\n          index += str.length;\n        } else {\n          segment = [];\n          while (index < end) {\n            base64VLQ.decode(aStr, index, temp);\n            value = temp.value;\n            index = temp.rest;\n            segment.push(value);\n          }\n\n          if (segment.length === 2) {\n            throw new Error('Found a source, but no line and column');\n          }\n\n          if (segment.length === 3) {\n            throw new Error('Found a source and line, but no column');\n          }\n\n          cachedSegments[str] = segment;\n        }\n\n        // Generated column.\n        mapping.generatedColumn = previousGeneratedColumn + segment[0];\n        previousGeneratedColumn = mapping.generatedColumn;\n\n        if (segment.length > 1) {\n          // Original source.\n          mapping.source = previousSource + segment[1];\n          previousSource += segment[1];\n\n          // Original line.\n          mapping.originalLine = previousOriginalLine + segment[2];\n          previousOriginalLine = mapping.originalLine;\n          // Lines are stored 0-based\n          mapping.originalLine += 1;\n\n          // Original column.\n          mapping.originalColumn = previousOriginalColumn + segment[3];\n          previousOriginalColumn = mapping.originalColumn;\n\n          if (segment.length > 4) {\n            // Original name.\n            mapping.name = previousName + segment[4];\n            previousName += segment[4];\n          }\n        }\n\n        generatedMappings.push(mapping);\n        if (typeof mapping.originalLine === 'number') {\n          originalMappings.push(mapping);\n        }\n      }\n    }\n\n    quickSort(generatedMappings, util.compareByGeneratedPositionsDeflated);\n    this.__generatedMappings = generatedMappings;\n\n    quickSort(originalMappings, util.compareByOriginalPositions);\n    this.__originalMappings = originalMappings;\n  };\n\n/**\n * Find the mapping that best matches the hypothetical \"needle\" mapping that\n * we are searching for in the given \"haystack\" of mappings.\n */\nBasicSourceMapConsumer.prototype._findMapping =\n  function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,\n                                         aColumnName, aComparator, aBias) {\n    // To return the position we are searching for, we must first find the\n    // mapping for the given position and then return the opposite position it\n    // points to. Because the mappings are sorted, we can use binary search to\n    // find the best mapping.\n\n    if (aNeedle[aLineName] <= 0) {\n      throw new TypeError('Line must be greater than or equal to 1, got '\n                          + aNeedle[aLineName]);\n    }\n    if (aNeedle[aColumnName] < 0) {\n      throw new TypeError('Column must be greater than or equal to 0, got '\n                          + aNeedle[aColumnName]);\n    }\n\n    return binarySearch.search(aNeedle, aMappings, aComparator, aBias);\n  };\n\n/**\n * Compute the last column for each generated mapping. The last column is\n * inclusive.\n */\nBasicSourceMapConsumer.prototype.computeColumnSpans =\n  function SourceMapConsumer_computeColumnSpans() {\n    for (var index = 0; index < this._generatedMappings.length; ++index) {\n      var mapping = this._generatedMappings[index];\n\n      // Mappings do not contain a field for the last generated columnt. We\n      // can come up with an optimistic estimate, however, by assuming that\n      // mappings are contiguous (i.e. given two consecutive mappings, the\n      // first mapping ends where the second one starts).\n      if (index + 1 < this._generatedMappings.length) {\n        var nextMapping = this._generatedMappings[index + 1];\n\n        if (mapping.generatedLine === nextMapping.generatedLine) {\n          mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;\n          continue;\n        }\n      }\n\n      // The last mapping for each line spans the entire line.\n      mapping.lastGeneratedColumn = Infinity;\n    }\n  };\n\n/**\n * Returns the original source, line, and column information for the generated\n * source's line and column positions provided. The only argument is an object\n * with the following properties:\n *\n *   - line: The line number in the generated source.\n *   - column: The column number in the generated source.\n *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or\n *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the\n *     closest element that is smaller than or greater than the one we are\n *     searching for, respectively, if the exact element cannot be found.\n *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.\n *\n * and an object is returned with the following properties:\n *\n *   - source: The original source file, or null.\n *   - line: The line number in the original source, or null.\n *   - column: The column number in the original source, or null.\n *   - name: The original identifier, or null.\n */\nBasicSourceMapConsumer.prototype.originalPositionFor =\n  function SourceMapConsumer_originalPositionFor(aArgs) {\n    var needle = {\n      generatedLine: util.getArg(aArgs, 'line'),\n      generatedColumn: util.getArg(aArgs, 'column')\n    };\n\n    var index = this._findMapping(\n      needle,\n      this._generatedMappings,\n      \"generatedLine\",\n      \"generatedColumn\",\n      util.compareByGeneratedPositionsDeflated,\n      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)\n    );\n\n    if (index >= 0) {\n      var mapping = this._generatedMappings[index];\n\n      if (mapping.generatedLine === needle.generatedLine) {\n        var source = util.getArg(mapping, 'source', null);\n        if (source !== null) {\n          source = this._sources.at(source);\n          if (this.sourceRoot != null) {\n            source = util.join(this.sourceRoot, source);\n          }\n        }\n        var name = util.getArg(mapping, 'name', null);\n        if (name !== null) {\n          name = this._names.at(name);\n        }\n        return {\n          source: source,\n          line: util.getArg(mapping, 'originalLine', null),\n          column: util.getArg(mapping, 'originalColumn', null),\n          name: name\n        };\n      }\n    }\n\n    return {\n      source: null,\n      line: null,\n      column: null,\n      name: null\n    };\n  };\n\n/**\n * Return true if we have the source content for every source in the source\n * map, false otherwise.\n */\nBasicSourceMapConsumer.prototype.hasContentsOfAllSources =\n  function BasicSourceMapConsumer_hasContentsOfAllSources() {\n    if (!this.sourcesContent) {\n      return false;\n    }\n    return this.sourcesContent.length >= this._sources.size() &&\n      !this.sourcesContent.some(function (sc) { return sc == null; });\n  };\n\n/**\n * Returns the original source content. The only argument is the url of the\n * original source file. Returns null if no original source content is\n * available.\n */\nBasicSourceMapConsumer.prototype.sourceContentFor =\n  function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {\n    if (!this.sourcesContent) {\n      return null;\n    }\n\n    if (this.sourceRoot != null) {\n      aSource = util.relative(this.sourceRoot, aSource);\n    }\n\n    if (this._sources.has(aSource)) {\n      return this.sourcesContent[this._sources.indexOf(aSource)];\n    }\n\n    var url;\n    if (this.sourceRoot != null\n        && (url = util.urlParse(this.sourceRoot))) {\n      // XXX: file:// URIs and absolute paths lead to unexpected behavior for\n      // many users. We can help them out when they expect file:// URIs to\n      // behave like it would if they were running a local HTTP server. See\n      // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.\n      var fileUriAbsPath = aSource.replace(/^file:\\/\\//, \"\");\n      if (url.scheme == \"file\"\n          && this._sources.has(fileUriAbsPath)) {\n        return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]\n      }\n\n      if ((!url.path || url.path == \"/\")\n          && this._sources.has(\"/\" + aSource)) {\n        return this.sourcesContent[this._sources.indexOf(\"/\" + aSource)];\n      }\n    }\n\n    // This function is used recursively from\n    // IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we\n    // don't want to throw if we can't find the source - we just want to\n    // return null, so we provide a flag to exit gracefully.\n    if (nullOnMissing) {\n      return null;\n    }\n    else {\n      throw new Error('\"' + aSource + '\" is not in the SourceMap.');\n    }\n  };\n\n/**\n * Returns the generated line and column information for the original source,\n * line, and column positions provided. The only argument is an object with\n * the following properties:\n *\n *   - source: The filename of the original source.\n *   - line: The line number in the original source.\n *   - column: The column number in the original source.\n *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or\n *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the\n *     closest element that is smaller than or greater than the one we are\n *     searching for, respectively, if the exact element cannot be found.\n *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.\n *\n * and an object is returned with the following properties:\n *\n *   - line: The line number in the generated source, or null.\n *   - column: The column number in the generated source, or null.\n */\nBasicSourceMapConsumer.prototype.generatedPositionFor =\n  function SourceMapConsumer_generatedPositionFor(aArgs) {\n    var source = util.getArg(aArgs, 'source');\n    if (this.sourceRoot != null) {\n      source = util.relative(this.sourceRoot, source);\n    }\n    if (!this._sources.has(source)) {\n      return {\n        line: null,\n        column: null,\n        lastColumn: null\n      };\n    }\n    source = this._sources.indexOf(source);\n\n    var needle = {\n      source: source,\n      originalLine: util.getArg(aArgs, 'line'),\n      originalColumn: util.getArg(aArgs, 'column')\n    };\n\n    var index = this._findMapping(\n      needle,\n      this._originalMappings,\n      \"originalLine\",\n      \"originalColumn\",\n      util.compareByOriginalPositions,\n      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)\n    );\n\n    if (index >= 0) {\n      var mapping = this._originalMappings[index];\n\n      if (mapping.source === needle.source) {\n        return {\n          line: util.getArg(mapping, 'generatedLine', null),\n          column: util.getArg(mapping, 'generatedColumn', null),\n          lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)\n        };\n      }\n    }\n\n    return {\n      line: null,\n      column: null,\n      lastColumn: null\n    };\n  };\n\nexports.BasicSourceMapConsumer = BasicSourceMapConsumer;\n\n/**\n * An IndexedSourceMapConsumer instance represents a parsed source map which\n * we can query for information. It differs from BasicSourceMapConsumer in\n * that it takes \"indexed\" source maps (i.e. ones with a \"sections\" field) as\n * input.\n *\n * The only parameter is a raw source map (either as a JSON string, or already\n * parsed to an object). According to the spec for indexed source maps, they\n * have the following attributes:\n *\n *   - version: Which version of the source map spec this map is following.\n *   - file: Optional. The generated file this source map is associated with.\n *   - sections: A list of section definitions.\n *\n * Each value under the \"sections\" field has two fields:\n *   - offset: The offset into the original specified at which this section\n *       begins to apply, defined as an object with a \"line\" and \"column\"\n *       field.\n *   - map: A source map definition. This source map could also be indexed,\n *       but doesn't have to be.\n *\n * Instead of the \"map\" field, it's also possible to have a \"url\" field\n * specifying a URL to retrieve a source map from, but that's currently\n * unsupported.\n *\n * Here's an example source map, taken from the source map spec[0], but\n * modified to omit a section which uses the \"url\" field.\n *\n *  {\n *    version : 3,\n *    file: \"app.js\",\n *    sections: [{\n *      offset: {line:100, column:10},\n *      map: {\n *        version : 3,\n *        file: \"section.js\",\n *        sources: [\"foo.js\", \"bar.js\"],\n *        names: [\"src\", \"maps\", \"are\", \"fun\"],\n *        mappings: \"AAAA,E;;ABCDE;\"\n *      }\n *    }],\n *  }\n *\n * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt\n */\nfunction IndexedSourceMapConsumer(aSourceMap) {\n  var sourceMap = aSourceMap;\n  if (typeof aSourceMap === 'string') {\n    sourceMap = JSON.parse(aSourceMap.replace(/^\\)\\]\\}'/, ''));\n  }\n\n  var version = util.getArg(sourceMap, 'version');\n  var sections = util.getArg(sourceMap, 'sections');\n\n  if (version != this._version) {\n    throw new Error('Unsupported version: ' + version);\n  }\n\n  this._sources = new ArraySet();\n  this._names = new ArraySet();\n\n  var lastOffset = {\n    line: -1,\n    column: 0\n  };\n  this._sections = sections.map(function (s) {\n    if (s.url) {\n      // The url field will require support for asynchronicity.\n      // See https://github.com/mozilla/source-map/issues/16\n      throw new Error('Support for url field in sections not implemented.');\n    }\n    var offset = util.getArg(s, 'offset');\n    var offsetLine = util.getArg(offset, 'line');\n    var offsetColumn = util.getArg(offset, 'column');\n\n    if (offsetLine < lastOffset.line ||\n        (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {\n      throw new Error('Section offsets must be ordered and non-overlapping.');\n    }\n    lastOffset = offset;\n\n    return {\n      generatedOffset: {\n        // The offset fields are 0-based, but we use 1-based indices when\n        // encoding/decoding from VLQ.\n        generatedLine: offsetLine + 1,\n        generatedColumn: offsetColumn + 1\n      },\n      consumer: new SourceMapConsumer(util.getArg(s, 'map'))\n    }\n  });\n}\n\nIndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);\nIndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;\n\n/**\n * The version of the source mapping spec that we are consuming.\n */\nIndexedSourceMapConsumer.prototype._version = 3;\n\n/**\n * The list of original sources.\n */\nObject.defineProperty(IndexedSourceMapConsumer.prototype, 'sources', {\n  get: function () {\n    var sources = [];\n    for (var i = 0; i < this._sections.length; i++) {\n      for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {\n        sources.push(this._sections[i].consumer.sources[j]);\n      }\n    }\n    return sources;\n  }\n});\n\n/**\n * Returns the original source, line, and column information for the generated\n * source's line and column positions provided. The only argument is an object\n * with the following properties:\n *\n *   - line: The line number in the generated source.\n *   - column: The column number in the generated source.\n *\n * and an object is returned with the following properties:\n *\n *   - source: The original source file, or null.\n *   - line: The line number in the original source, or null.\n *   - column: The column number in the original source, or null.\n *   - name: The original identifier, or null.\n */\nIndexedSourceMapConsumer.prototype.originalPositionFor =\n  function IndexedSourceMapConsumer_originalPositionFor(aArgs) {\n    var needle = {\n      generatedLine: util.getArg(aArgs, 'line'),\n      generatedColumn: util.getArg(aArgs, 'column')\n    };\n\n    // Find the section containing the generated position we're trying to map\n    // to an original position.\n    var sectionIndex = binarySearch.search(needle, this._sections,\n      function(needle, section) {\n        var cmp = needle.generatedLine - section.generatedOffset.generatedLine;\n        if (cmp) {\n          return cmp;\n        }\n\n        return (needle.generatedColumn -\n                section.generatedOffset.generatedColumn);\n      });\n    var section = this._sections[sectionIndex];\n\n    if (!section) {\n      return {\n        source: null,\n        line: null,\n        column: null,\n        name: null\n      };\n    }\n\n    return section.consumer.originalPositionFor({\n      line: needle.generatedLine -\n        (section.generatedOffset.generatedLine - 1),\n      column: needle.generatedColumn -\n        (section.generatedOffset.generatedLine === needle.generatedLine\n         ? section.generatedOffset.generatedColumn - 1\n         : 0),\n      bias: aArgs.bias\n    });\n  };\n\n/**\n * Return true if we have the source content for every source in the source\n * map, false otherwise.\n */\nIndexedSourceMapConsumer.prototype.hasContentsOfAllSources =\n  function IndexedSourceMapConsumer_hasContentsOfAllSources() {\n    return this._sections.every(function (s) {\n      return s.consumer.hasContentsOfAllSources();\n    });\n  };\n\n/**\n * Returns the original source content. The only argument is the url of the\n * original source file. Returns null if no original source content is\n * available.\n */\nIndexedSourceMapConsumer.prototype.sourceContentFor =\n  function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {\n    for (var i = 0; i < this._sections.length; i++) {\n      var section = this._sections[i];\n\n      var content = section.consumer.sourceContentFor(aSource, true);\n      if (content) {\n        return content;\n      }\n    }\n    if (nullOnMissing) {\n      return null;\n    }\n    else {\n      throw new Error('\"' + aSource + '\" is not in the SourceMap.');\n    }\n  };\n\n/**\n * Returns the generated line and column information for the original source,\n * line, and column positions provided. The only argument is an object with\n * the following properties:\n *\n *   - source: The filename of the original source.\n *   - line: The line number in the original source.\n *   - column: The column number in the original source.\n *\n * and an object is returned with the following properties:\n *\n *   - line: The line number in the generated source, or null.\n *   - column: The column number in the generated source, or null.\n */\nIndexedSourceMapConsumer.prototype.generatedPositionFor =\n  function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {\n    for (var i = 0; i < this._sections.length; i++) {\n      var section = this._sections[i];\n\n      // Only consider this section if the requested source is in the list of\n      // sources of the consumer.\n      if (section.consumer.sources.indexOf(util.getArg(aArgs, 'source')) === -1) {\n        continue;\n      }\n      var generatedPosition = section.consumer.generatedPositionFor(aArgs);\n      if (generatedPosition) {\n        var ret = {\n          line: generatedPosition.line +\n            (section.generatedOffset.generatedLine - 1),\n          column: generatedPosition.column +\n            (section.generatedOffset.generatedLine === generatedPosition.line\n             ? section.generatedOffset.generatedColumn - 1\n             : 0)\n        };\n        return ret;\n      }\n    }\n\n    return {\n      line: null,\n      column: null\n    };\n  };\n\n/**\n * Parse the mappings in a string in to a data structure which we can easily\n * query (the ordered arrays in the `this.__generatedMappings` and\n * `this.__originalMappings` properties).\n */\nIndexedSourceMapConsumer.prototype._parseMappings =\n  function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {\n    this.__generatedMappings = [];\n    this.__originalMappings = [];\n    for (var i = 0; i < this._sections.length; i++) {\n      var section = this._sections[i];\n      var sectionMappings = section.consumer._generatedMappings;\n      for (var j = 0; j < sectionMappings.length; j++) {\n        var mapping = sectionMappings[j];\n\n        var source = section.consumer._sources.at(mapping.source);\n        if (section.consumer.sourceRoot !== null) {\n          source = util.join(section.consumer.sourceRoot, source);\n        }\n        this._sources.add(source);\n        source = this._sources.indexOf(source);\n\n        var name = section.consumer._names.at(mapping.name);\n        this._names.add(name);\n        name = this._names.indexOf(name);\n\n        // The mappings coming from the consumer for the section have\n        // generated positions relative to the start of the section, so we\n        // need to offset them to be relative to the start of the concatenated\n        // generated file.\n        var adjustedMapping = {\n          source: source,\n          generatedLine: mapping.generatedLine +\n            (section.generatedOffset.generatedLine - 1),\n          generatedColumn: mapping.generatedColumn +\n            (section.generatedOffset.generatedLine === mapping.generatedLine\n            ? section.generatedOffset.generatedColumn - 1\n            : 0),\n          originalLine: mapping.originalLine,\n          originalColumn: mapping.originalColumn,\n          name: name\n        };\n\n        this.__generatedMappings.push(adjustedMapping);\n        if (typeof adjustedMapping.originalLine === 'number') {\n          this.__originalMappings.push(adjustedMapping);\n        }\n      }\n    }\n\n    quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);\n    quickSort(this.__originalMappings, util.compareByOriginalPositions);\n  };\n\nexports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/source-map-consumer.js\n// module id = 7\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nexports.GREATEST_LOWER_BOUND = 1;\nexports.LEAST_UPPER_BOUND = 2;\n\n/**\n * Recursive implementation of binary search.\n *\n * @param aLow Indices here and lower do not contain the needle.\n * @param aHigh Indices here and higher do not contain the needle.\n * @param aNeedle The element being searched for.\n * @param aHaystack The non-empty array being searched.\n * @param aCompare Function which takes two elements and returns -1, 0, or 1.\n * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or\n *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the\n *     closest element that is smaller than or greater than the one we are\n *     searching for, respectively, if the exact element cannot be found.\n */\nfunction recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {\n  // This function terminates when one of the following is true:\n  //\n  //   1. We find the exact element we are looking for.\n  //\n  //   2. We did not find the exact element, but we can return the index of\n  //      the next-closest element.\n  //\n  //   3. We did not find the exact element, and there is no next-closest\n  //      element than the one we are searching for, so we return -1.\n  var mid = Math.floor((aHigh - aLow) / 2) + aLow;\n  var cmp = aCompare(aNeedle, aHaystack[mid], true);\n  if (cmp === 0) {\n    // Found the element we are looking for.\n    return mid;\n  }\n  else if (cmp > 0) {\n    // Our needle is greater than aHaystack[mid].\n    if (aHigh - mid > 1) {\n      // The element is in the upper half.\n      return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);\n    }\n\n    // The exact needle element was not found in this haystack. Determine if\n    // we are in termination case (3) or (2) and return the appropriate thing.\n    if (aBias == exports.LEAST_UPPER_BOUND) {\n      return aHigh < aHaystack.length ? aHigh : -1;\n    } else {\n      return mid;\n    }\n  }\n  else {\n    // Our needle is less than aHaystack[mid].\n    if (mid - aLow > 1) {\n      // The element is in the lower half.\n      return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);\n    }\n\n    // we are in termination case (3) or (2) and return the appropriate thing.\n    if (aBias == exports.LEAST_UPPER_BOUND) {\n      return mid;\n    } else {\n      return aLow < 0 ? -1 : aLow;\n    }\n  }\n}\n\n/**\n * This is an implementation of binary search which will always try and return\n * the index of the closest element if there is no exact hit. This is because\n * mappings between original and generated line/col pairs are single points,\n * and there is an implicit region between each of them, so a miss just means\n * that you aren't on the very start of a region.\n *\n * @param aNeedle The element you are looking for.\n * @param aHaystack The array that is being searched.\n * @param aCompare A function which takes the needle and an element in the\n *     array and returns -1, 0, or 1 depending on whether the needle is less\n *     than, equal to, or greater than the element, respectively.\n * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or\n *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the\n *     closest element that is smaller than or greater than the one we are\n *     searching for, respectively, if the exact element cannot be found.\n *     Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.\n */\nexports.search = function search(aNeedle, aHaystack, aCompare, aBias) {\n  if (aHaystack.length === 0) {\n    return -1;\n  }\n\n  var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack,\n                              aCompare, aBias || exports.GREATEST_LOWER_BOUND);\n  if (index < 0) {\n    return -1;\n  }\n\n  // We have found either the exact element, or the next-closest element than\n  // the one we are searching for. However, there may be more than one such\n  // element. Make sure we always return the smallest of these.\n  while (index - 1 >= 0) {\n    if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {\n      break;\n    }\n    --index;\n  }\n\n  return index;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/binary-search.js\n// module id = 8\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\n// It turns out that some (most?) JavaScript engines don't self-host\n// `Array.prototype.sort`. This makes sense because C++ will likely remain\n// faster than JS when doing raw CPU-intensive sorting. However, when using a\n// custom comparator function, calling back and forth between the VM's C++ and\n// JIT'd JS is rather slow *and* loses JIT type information, resulting in\n// worse generated code for the comparator function than would be optimal. In\n// fact, when sorting with a comparator, these costs outweigh the benefits of\n// sorting in C++. By using our own JS-implemented Quick Sort (below), we get\n// a ~3500ms mean speed-up in `bench/bench.html`.\n\n/**\n * Swap the elements indexed by `x` and `y` in the array `ary`.\n *\n * @param {Array} ary\n *        The array.\n * @param {Number} x\n *        The index of the first item.\n * @param {Number} y\n *        The index of the second item.\n */\nfunction swap(ary, x, y) {\n  var temp = ary[x];\n  ary[x] = ary[y];\n  ary[y] = temp;\n}\n\n/**\n * Returns a random integer within the range `low .. high` inclusive.\n *\n * @param {Number} low\n *        The lower bound on the range.\n * @param {Number} high\n *        The upper bound on the range.\n */\nfunction randomIntInRange(low, high) {\n  return Math.round(low + (Math.random() * (high - low)));\n}\n\n/**\n * The Quick Sort algorithm.\n *\n * @param {Array} ary\n *        An array to sort.\n * @param {function} comparator\n *        Function to use to compare two items.\n * @param {Number} p\n *        Start index of the array\n * @param {Number} r\n *        End index of the array\n */\nfunction doQuickSort(ary, comparator, p, r) {\n  // If our lower bound is less than our upper bound, we (1) partition the\n  // array into two pieces and (2) recurse on each half. If it is not, this is\n  // the empty array and our base case.\n\n  if (p < r) {\n    // (1) Partitioning.\n    //\n    // The partitioning chooses a pivot between `p` and `r` and moves all\n    // elements that are less than or equal to the pivot to the before it, and\n    // all the elements that are greater than it after it. The effect is that\n    // once partition is done, the pivot is in the exact place it will be when\n    // the array is put in sorted order, and it will not need to be moved\n    // again. This runs in O(n) time.\n\n    // Always choose a random pivot so that an input array which is reverse\n    // sorted does not cause O(n^2) running time.\n    var pivotIndex = randomIntInRange(p, r);\n    var i = p - 1;\n\n    swap(ary, pivotIndex, r);\n    var pivot = ary[r];\n\n    // Immediately after `j` is incremented in this loop, the following hold\n    // true:\n    //\n    //   * Every element in `ary[p .. i]` is less than or equal to the pivot.\n    //\n    //   * Every element in `ary[i+1 .. j-1]` is greater than the pivot.\n    for (var j = p; j < r; j++) {\n      if (comparator(ary[j], pivot) <= 0) {\n        i += 1;\n        swap(ary, i, j);\n      }\n    }\n\n    swap(ary, i + 1, j);\n    var q = i + 1;\n\n    // (2) Recurse on each half.\n\n    doQuickSort(ary, comparator, p, q - 1);\n    doQuickSort(ary, comparator, q + 1, r);\n  }\n}\n\n/**\n * Sort the given array in-place with the given comparator function.\n *\n * @param {Array} ary\n *        An array to sort.\n * @param {function} comparator\n *        Function to use to compare two items.\n */\nexports.quickSort = function (ary, comparator) {\n  doQuickSort(ary, comparator, 0, ary.length - 1);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/quick-sort.js\n// module id = 9\n// module chunks = 0","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar SourceMapGenerator = require('./source-map-generator').SourceMapGenerator;\nvar util = require('./util');\n\n// Matches a Windows-style `\\r\\n` newline or a `\\n` newline used by all other\n// operating systems these days (capturing the result).\nvar REGEX_NEWLINE = /(\\r?\\n)/;\n\n// Newline character code for charCodeAt() comparisons\nvar NEWLINE_CODE = 10;\n\n// Private symbol for identifying `SourceNode`s when multiple versions of\n// the source-map library are loaded. This MUST NOT CHANGE across\n// versions!\nvar isSourceNode = \"$$$isSourceNode$$$\";\n\n/**\n * SourceNodes provide a way to abstract over interpolating/concatenating\n * snippets of generated JavaScript source code while maintaining the line and\n * column information associated with the original source code.\n *\n * @param aLine The original line number.\n * @param aColumn The original column number.\n * @param aSource The original source's filename.\n * @param aChunks Optional. An array of strings which are snippets of\n *        generated JS, or other SourceNodes.\n * @param aName The original identifier.\n */\nfunction SourceNode(aLine, aColumn, aSource, aChunks, aName) {\n  this.children = [];\n  this.sourceContents = {};\n  this.line = aLine == null ? null : aLine;\n  this.column = aColumn == null ? null : aColumn;\n  this.source = aSource == null ? null : aSource;\n  this.name = aName == null ? null : aName;\n  this[isSourceNode] = true;\n  if (aChunks != null) this.add(aChunks);\n}\n\n/**\n * Creates a SourceNode from generated code and a SourceMapConsumer.\n *\n * @param aGeneratedCode The generated code\n * @param aSourceMapConsumer The SourceMap for the generated code\n * @param aRelativePath Optional. The path that relative sources in the\n *        SourceMapConsumer should be relative to.\n */\nSourceNode.fromStringWithSourceMap =\n  function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {\n    // The SourceNode we want to fill with the generated code\n    // and the SourceMap\n    var node = new SourceNode();\n\n    // All even indices of this array are one line of the generated code,\n    // while all odd indices are the newlines between two adjacent lines\n    // (since `REGEX_NEWLINE` captures its match).\n    // Processed fragments are accessed by calling `shiftNextLine`.\n    var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);\n    var remainingLinesIndex = 0;\n    var shiftNextLine = function() {\n      var lineContents = getNextLine();\n      // The last line of a file might not have a newline.\n      var newLine = getNextLine() || \"\";\n      return lineContents + newLine;\n\n      function getNextLine() {\n        return remainingLinesIndex < remainingLines.length ?\n            remainingLines[remainingLinesIndex++] : undefined;\n      }\n    };\n\n    // We need to remember the position of \"remainingLines\"\n    var lastGeneratedLine = 1, lastGeneratedColumn = 0;\n\n    // The generate SourceNodes we need a code range.\n    // To extract it current and last mapping is used.\n    // Here we store the last mapping.\n    var lastMapping = null;\n\n    aSourceMapConsumer.eachMapping(function (mapping) {\n      if (lastMapping !== null) {\n        // We add the code from \"lastMapping\" to \"mapping\":\n        // First check if there is a new line in between.\n        if (lastGeneratedLine < mapping.generatedLine) {\n          // Associate first line with \"lastMapping\"\n          addMappingWithCode(lastMapping, shiftNextLine());\n          lastGeneratedLine++;\n          lastGeneratedColumn = 0;\n          // The remaining code is added without mapping\n        } else {\n          // There is no new line in between.\n          // Associate the code between \"lastGeneratedColumn\" and\n          // \"mapping.generatedColumn\" with \"lastMapping\"\n          var nextLine = remainingLines[remainingLinesIndex];\n          var code = nextLine.substr(0, mapping.generatedColumn -\n                                        lastGeneratedColumn);\n          remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn -\n                                              lastGeneratedColumn);\n          lastGeneratedColumn = mapping.generatedColumn;\n          addMappingWithCode(lastMapping, code);\n          // No more remaining code, continue\n          lastMapping = mapping;\n          return;\n        }\n      }\n      // We add the generated code until the first mapping\n      // to the SourceNode without any mapping.\n      // Each line is added as separate string.\n      while (lastGeneratedLine < mapping.generatedLine) {\n        node.add(shiftNextLine());\n        lastGeneratedLine++;\n      }\n      if (lastGeneratedColumn < mapping.generatedColumn) {\n        var nextLine = remainingLines[remainingLinesIndex];\n        node.add(nextLine.substr(0, mapping.generatedColumn));\n        remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);\n        lastGeneratedColumn = mapping.generatedColumn;\n      }\n      lastMapping = mapping;\n    }, this);\n    // We have processed all mappings.\n    if (remainingLinesIndex < remainingLines.length) {\n      if (lastMapping) {\n        // Associate the remaining code in the current line with \"lastMapping\"\n        addMappingWithCode(lastMapping, shiftNextLine());\n      }\n      // and add the remaining lines without any mapping\n      node.add(remainingLines.splice(remainingLinesIndex).join(\"\"));\n    }\n\n    // Copy sourcesContent into SourceNode\n    aSourceMapConsumer.sources.forEach(function (sourceFile) {\n      var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n      if (content != null) {\n        if (aRelativePath != null) {\n          sourceFile = util.join(aRelativePath, sourceFile);\n        }\n        node.setSourceContent(sourceFile, content);\n      }\n    });\n\n    return node;\n\n    function addMappingWithCode(mapping, code) {\n      if (mapping === null || mapping.source === undefined) {\n        node.add(code);\n      } else {\n        var source = aRelativePath\n          ? util.join(aRelativePath, mapping.source)\n          : mapping.source;\n        node.add(new SourceNode(mapping.originalLine,\n                                mapping.originalColumn,\n                                source,\n                                code,\n                                mapping.name));\n      }\n    }\n  };\n\n/**\n * Add a chunk of generated JS to this source node.\n *\n * @param aChunk A string snippet of generated JS code, another instance of\n *        SourceNode, or an array where each member is one of those things.\n */\nSourceNode.prototype.add = function SourceNode_add(aChunk) {\n  if (Array.isArray(aChunk)) {\n    aChunk.forEach(function (chunk) {\n      this.add(chunk);\n    }, this);\n  }\n  else if (aChunk[isSourceNode] || typeof aChunk === \"string\") {\n    if (aChunk) {\n      this.children.push(aChunk);\n    }\n  }\n  else {\n    throw new TypeError(\n      \"Expected a SourceNode, string, or an array of SourceNodes and strings. Got \" + aChunk\n    );\n  }\n  return this;\n};\n\n/**\n * Add a chunk of generated JS to the beginning of this source node.\n *\n * @param aChunk A string snippet of generated JS code, another instance of\n *        SourceNode, or an array where each member is one of those things.\n */\nSourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {\n  if (Array.isArray(aChunk)) {\n    for (var i = aChunk.length-1; i >= 0; i--) {\n      this.prepend(aChunk[i]);\n    }\n  }\n  else if (aChunk[isSourceNode] || typeof aChunk === \"string\") {\n    this.children.unshift(aChunk);\n  }\n  else {\n    throw new TypeError(\n      \"Expected a SourceNode, string, or an array of SourceNodes and strings. Got \" + aChunk\n    );\n  }\n  return this;\n};\n\n/**\n * Walk over the tree of JS snippets in this node and its children. The\n * walking function is called once for each snippet of JS and is passed that\n * snippet and the its original associated source's line/column location.\n *\n * @param aFn The traversal function.\n */\nSourceNode.prototype.walk = function SourceNode_walk(aFn) {\n  var chunk;\n  for (var i = 0, len = this.children.length; i < len; i++) {\n    chunk = this.children[i];\n    if (chunk[isSourceNode]) {\n      chunk.walk(aFn);\n    }\n    else {\n      if (chunk !== '') {\n        aFn(chunk, { source: this.source,\n                     line: this.line,\n                     column: this.column,\n                     name: this.name });\n      }\n    }\n  }\n};\n\n/**\n * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between\n * each of `this.children`.\n *\n * @param aSep The separator.\n */\nSourceNode.prototype.join = function SourceNode_join(aSep) {\n  var newChildren;\n  var i;\n  var len = this.children.length;\n  if (len > 0) {\n    newChildren = [];\n    for (i = 0; i < len-1; i++) {\n      newChildren.push(this.children[i]);\n      newChildren.push(aSep);\n    }\n    newChildren.push(this.children[i]);\n    this.children = newChildren;\n  }\n  return this;\n};\n\n/**\n * Call String.prototype.replace on the very right-most source snippet. Useful\n * for trimming whitespace from the end of a source node, etc.\n *\n * @param aPattern The pattern to replace.\n * @param aReplacement The thing to replace the pattern with.\n */\nSourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {\n  var lastChild = this.children[this.children.length - 1];\n  if (lastChild[isSourceNode]) {\n    lastChild.replaceRight(aPattern, aReplacement);\n  }\n  else if (typeof lastChild === 'string') {\n    this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);\n  }\n  else {\n    this.children.push(''.replace(aPattern, aReplacement));\n  }\n  return this;\n};\n\n/**\n * Set the source content for a source file. This will be added to the SourceMapGenerator\n * in the sourcesContent field.\n *\n * @param aSourceFile The filename of the source file\n * @param aSourceContent The content of the source file\n */\nSourceNode.prototype.setSourceContent =\n  function SourceNode_setSourceContent(aSourceFile, aSourceContent) {\n    this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;\n  };\n\n/**\n * Walk over the tree of SourceNodes. The walking function is called for each\n * source file content and is passed the filename and source content.\n *\n * @param aFn The traversal function.\n */\nSourceNode.prototype.walkSourceContents =\n  function SourceNode_walkSourceContents(aFn) {\n    for (var i = 0, len = this.children.length; i < len; i++) {\n      if (this.children[i][isSourceNode]) {\n        this.children[i].walkSourceContents(aFn);\n      }\n    }\n\n    var sources = Object.keys(this.sourceContents);\n    for (var i = 0, len = sources.length; i < len; i++) {\n      aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);\n    }\n  };\n\n/**\n * Return the string representation of this source node. Walks over the tree\n * and concatenates all the various snippets together to one string.\n */\nSourceNode.prototype.toString = function SourceNode_toString() {\n  var str = \"\";\n  this.walk(function (chunk) {\n    str += chunk;\n  });\n  return str;\n};\n\n/**\n * Returns the string representation of this source node along with a source\n * map.\n */\nSourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {\n  var generated = {\n    code: \"\",\n    line: 1,\n    column: 0\n  };\n  var map = new SourceMapGenerator(aArgs);\n  var sourceMappingActive = false;\n  var lastOriginalSource = null;\n  var lastOriginalLine = null;\n  var lastOriginalColumn = null;\n  var lastOriginalName = null;\n  this.walk(function (chunk, original) {\n    generated.code += chunk;\n    if (original.source !== null\n        && original.line !== null\n        && original.column !== null) {\n      if(lastOriginalSource !== original.source\n         || lastOriginalLine !== original.line\n         || lastOriginalColumn !== original.column\n         || lastOriginalName !== original.name) {\n        map.addMapping({\n          source: original.source,\n          original: {\n            line: original.line,\n            column: original.column\n          },\n          generated: {\n            line: generated.line,\n            column: generated.column\n          },\n          name: original.name\n        });\n      }\n      lastOriginalSource = original.source;\n      lastOriginalLine = original.line;\n      lastOriginalColumn = original.column;\n      lastOriginalName = original.name;\n      sourceMappingActive = true;\n    } else if (sourceMappingActive) {\n      map.addMapping({\n        generated: {\n          line: generated.line,\n          column: generated.column\n        }\n      });\n      lastOriginalSource = null;\n      sourceMappingActive = false;\n    }\n    for (var idx = 0, length = chunk.length; idx < length; idx++) {\n      if (chunk.charCodeAt(idx) === NEWLINE_CODE) {\n        generated.line++;\n        generated.column = 0;\n        // Mappings end at eol\n        if (idx + 1 === length) {\n          lastOriginalSource = null;\n          sourceMappingActive = false;\n        } else if (sourceMappingActive) {\n          map.addMapping({\n            source: original.source,\n            original: {\n              line: original.line,\n              column: original.column\n            },\n            generated: {\n              line: generated.line,\n              column: generated.column\n            },\n            name: original.name\n          });\n        }\n      } else {\n        generated.column++;\n      }\n    }\n  });\n  this.walkSourceContents(function (sourceFile, sourceContent) {\n    map.setSourceContent(sourceFile, sourceContent);\n  });\n\n  return { code: generated.code, map: map };\n};\n\nexports.SourceNode = SourceNode;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/source-node.js\n// module id = 10\n// module chunks = 0"],"sourceRoot":""}
\ No newline at end of file
diff --git a/node_modules/@babel/generator/node_modules/source-map/lib/array-set.js b/node_modules/@babel/generator/node_modules/source-map/lib/array-set.js
new file mode 100644
index 00000000..fbd5c81c
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/source-map/lib/array-set.js
@@ -0,0 +1,121 @@
+/* -*- 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 = require('./util');
+var has = Object.prototype.hasOwnProperty;
+var hasNativeMap = typeof Map !== "undefined";
+
+/**
+ * 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 = hasNativeMap ? new Map() : 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 hasNativeMap ? this._set.size : 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 = hasNativeMap ? aStr : util.toSetString(aStr);
+  var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
+  var idx = this._array.length;
+  if (!isDuplicate || aAllowDuplicates) {
+    this._array.push(aStr);
+  }
+  if (!isDuplicate) {
+    if (hasNativeMap) {
+      this._set.set(aStr, idx);
+    } else {
+      this._set[sStr] = idx;
+    }
+  }
+};
+
+/**
+ * Is the given string a member of this set?
+ *
+ * @param String aStr
+ */
+ArraySet.prototype.has = function ArraySet_has(aStr) {
+  if (hasNativeMap) {
+    return this._set.has(aStr);
+  } else {
+    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) {
+  if (hasNativeMap) {
+    var idx = this._set.get(aStr);
+    if (idx >= 0) {
+        return idx;
+    }
+  } else {
+    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;
diff --git a/node_modules/@babel/generator/node_modules/source-map/lib/base64-vlq.js b/node_modules/@babel/generator/node_modules/source-map/lib/base64-vlq.js
new file mode 100644
index 00000000..612b4040
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/source-map/lib/base64-vlq.js
@@ -0,0 +1,140 @@
+/* -*- 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 = require('./base64');
+
+// 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;
+};
diff --git a/node_modules/@babel/generator/node_modules/source-map/lib/base64.js b/node_modules/@babel/generator/node_modules/source-map/lib/base64.js
new file mode 100644
index 00000000..8aa86b30
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/source-map/lib/base64.js
@@ -0,0 +1,67 @@
+/* -*- 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;
+};
diff --git a/node_modules/@babel/generator/node_modules/source-map/lib/binary-search.js b/node_modules/@babel/generator/node_modules/source-map/lib/binary-search.js
new file mode 100644
index 00000000..010ac941
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/source-map/lib/binary-search.js
@@ -0,0 +1,111 @@
+/* -*- 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;
+};
diff --git a/node_modules/@babel/generator/node_modules/source-map/lib/mapping-list.js b/node_modules/@babel/generator/node_modules/source-map/lib/mapping-list.js
new file mode 100644
index 00000000..06d1274a
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/source-map/lib/mapping-list.js
@@ -0,0 +1,79 @@
+/* -*- 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 = require('./util');
+
+/**
+ * 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;
diff --git a/node_modules/@babel/generator/node_modules/source-map/lib/quick-sort.js b/node_modules/@babel/generator/node_modules/source-map/lib/quick-sort.js
new file mode 100644
index 00000000..6a7caadb
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/source-map/lib/quick-sort.js
@@ -0,0 +1,114 @@
+/* -*- 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);
+};
diff --git a/node_modules/@babel/generator/node_modules/source-map/lib/source-map-consumer.js b/node_modules/@babel/generator/node_modules/source-map/lib/source-map-consumer.js
new file mode 100644
index 00000000..6abcc280
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/source-map/lib/source-map-consumer.js
@@ -0,0 +1,1082 @@
+/* -*- 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 = require('./util');
+var binarySearch = require('./binary-search');
+var ArraySet = require('./array-set').ArraySet;
+var base64VLQ = require('./base64-vlq');
+var quickSort = require('./quick-sort').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;
diff --git a/node_modules/@babel/generator/node_modules/source-map/lib/source-map-generator.js b/node_modules/@babel/generator/node_modules/source-map/lib/source-map-generator.js
new file mode 100644
index 00000000..aff1e7fb
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/source-map/lib/source-map-generator.js
@@ -0,0 +1,416 @@
+/* -*- 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 = require('./base64-vlq');
+var util = require('./util');
+var ArraySet = require('./array-set').ArraySet;
+var MappingList = require('./mapping-list').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) {
+    // When aOriginal is truthy but has empty values for .line and .column,
+    // it is most likely a programmer error. In this case we throw a very
+    // specific error message to try to guide them the right way.
+    // For example: https://github.com/Polymer/polymer-bundler/pull/519
+    if (aOriginal && typeof aOriginal.line !== 'number' && typeof aOriginal.column !== 'number') {
+        throw new Error(
+            'original.line and original.column are not numbers -- you probably meant to omit ' +
+            'the original mapping entirely and only map the generated position. If so, pass ' +
+            'null for the original mapping instead of an object with empty or null values.'
+        );
+    }
+
+    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;
diff --git a/node_modules/@babel/generator/node_modules/source-map/lib/source-node.js b/node_modules/@babel/generator/node_modules/source-map/lib/source-node.js
new file mode 100644
index 00000000..d196a53f
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/source-map/lib/source-node.js
@@ -0,0 +1,413 @@
+/* -*- 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 = require('./source-map-generator').SourceMapGenerator;
+var util = require('./util');
+
+// 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 accessed by calling `shiftNextLine`.
+    var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
+    var remainingLinesIndex = 0;
+    var shiftNextLine = function() {
+      var lineContents = getNextLine();
+      // The last line of a file might not have a newline.
+      var newLine = getNextLine() || "";
+      return lineContents + newLine;
+
+      function getNextLine() {
+        return remainingLinesIndex < remainingLines.length ?
+            remainingLines[remainingLinesIndex++] : undefined;
+      }
+    };
+
+    // 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[remainingLinesIndex];
+          var code = nextLine.substr(0, mapping.generatedColumn -
+                                        lastGeneratedColumn);
+          remainingLines[remainingLinesIndex] = 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[remainingLinesIndex];
+        node.add(nextLine.substr(0, mapping.generatedColumn));
+        remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
+        lastGeneratedColumn = mapping.generatedColumn;
+      }
+      lastMapping = mapping;
+    }, this);
+    // We have processed all mappings.
+    if (remainingLinesIndex < remainingLines.length) {
+      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.splice(remainingLinesIndex).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) {
+        node.add(code);
+      } else {
+        var source = aRelativePath
+          ? util.join(aRelativePath, mapping.source)
+          : mapping.source;
+        node.add(new SourceNode(mapping.originalLine,
+                                mapping.originalColumn,
+                                source,
+                                code,
+                                mapping.name));
+      }
+    }
+  };
+
+/**
+ * Add a chunk of generated JS to this source node.
+ *
+ * @param aChunk A string snippet of generated JS code, another instance of
+ *        SourceNode, or an array where each member is one of those things.
+ */
+SourceNode.prototype.add = function SourceNode_add(aChunk) {
+  if (Array.isArray(aChunk)) {
+    aChunk.forEach(function (chunk) {
+      this.add(chunk);
+    }, this);
+  }
+  else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+    if (aChunk) {
+      this.children.push(aChunk);
+    }
+  }
+  else {
+    throw new TypeError(
+      "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+    );
+  }
+  return this;
+};
+
+/**
+ * Add a chunk of generated JS to the beginning of this source node.
+ *
+ * @param aChunk A string snippet of generated JS code, another instance of
+ *        SourceNode, or an array where each member is one of those things.
+ */
+SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
+  if (Array.isArray(aChunk)) {
+    for (var i = aChunk.length-1; i >= 0; i--) {
+      this.prepend(aChunk[i]);
+    }
+  }
+  else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+    this.children.unshift(aChunk);
+  }
+  else {
+    throw new TypeError(
+      "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+    );
+  }
+  return this;
+};
+
+/**
+ * Walk over the tree of JS snippets in this node and its children. The
+ * walking function is called once for each snippet of JS and is passed that
+ * snippet and the its original associated source's line/column location.
+ *
+ * @param aFn The traversal function.
+ */
+SourceNode.prototype.walk = function SourceNode_walk(aFn) {
+  var chunk;
+  for (var i = 0, len = this.children.length; i < len; i++) {
+    chunk = this.children[i];
+    if (chunk[isSourceNode]) {
+      chunk.walk(aFn);
+    }
+    else {
+      if (chunk !== '') {
+        aFn(chunk, { source: this.source,
+                     line: this.line,
+                     column: this.column,
+                     name: this.name });
+      }
+    }
+  }
+};
+
+/**
+ * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
+ * each of `this.children`.
+ *
+ * @param aSep The separator.
+ */
+SourceNode.prototype.join = function SourceNode_join(aSep) {
+  var newChildren;
+  var i;
+  var len = this.children.length;
+  if (len > 0) {
+    newChildren = [];
+    for (i = 0; i < len-1; i++) {
+      newChildren.push(this.children[i]);
+      newChildren.push(aSep);
+    }
+    newChildren.push(this.children[i]);
+    this.children = newChildren;
+  }
+  return this;
+};
+
+/**
+ * Call String.prototype.replace on the very right-most source snippet. Useful
+ * for trimming whitespace from the end of a source node, etc.
+ *
+ * @param aPattern The pattern to replace.
+ * @param aReplacement The thing to replace the pattern with.
+ */
+SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
+  var lastChild = this.children[this.children.length - 1];
+  if (lastChild[isSourceNode]) {
+    lastChild.replaceRight(aPattern, aReplacement);
+  }
+  else if (typeof lastChild === 'string') {
+    this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
+  }
+  else {
+    this.children.push(''.replace(aPattern, aReplacement));
+  }
+  return this;
+};
+
+/**
+ * Set the source content for a source file. This will be added to the SourceMapGenerator
+ * in the sourcesContent field.
+ *
+ * @param aSourceFile The filename of the source file
+ * @param aSourceContent The content of the source file
+ */
+SourceNode.prototype.setSourceContent =
+  function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
+    this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
+  };
+
+/**
+ * Walk over the tree of SourceNodes. The walking function is called for each
+ * source file content and is passed the filename and source content.
+ *
+ * @param aFn The traversal function.
+ */
+SourceNode.prototype.walkSourceContents =
+  function SourceNode_walkSourceContents(aFn) {
+    for (var i = 0, len = this.children.length; i < len; i++) {
+      if (this.children[i][isSourceNode]) {
+        this.children[i].walkSourceContents(aFn);
+      }
+    }
+
+    var sources = Object.keys(this.sourceContents);
+    for (var i = 0, len = sources.length; i < len; i++) {
+      aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
+    }
+  };
+
+/**
+ * Return the string representation of this source node. Walks over the tree
+ * and concatenates all the various snippets together to one string.
+ */
+SourceNode.prototype.toString = function SourceNode_toString() {
+  var str = "";
+  this.walk(function (chunk) {
+    str += chunk;
+  });
+  return str;
+};
+
+/**
+ * Returns the string representation of this source node along with a source
+ * map.
+ */
+SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
+  var generated = {
+    code: "",
+    line: 1,
+    column: 0
+  };
+  var map = new SourceMapGenerator(aArgs);
+  var sourceMappingActive = false;
+  var lastOriginalSource = null;
+  var lastOriginalLine = null;
+  var lastOriginalColumn = null;
+  var lastOriginalName = null;
+  this.walk(function (chunk, original) {
+    generated.code += chunk;
+    if (original.source !== null
+        && original.line !== null
+        && original.column !== null) {
+      if(lastOriginalSource !== original.source
+         || lastOriginalLine !== original.line
+         || lastOriginalColumn !== original.column
+         || lastOriginalName !== original.name) {
+        map.addMapping({
+          source: original.source,
+          original: {
+            line: original.line,
+            column: original.column
+          },
+          generated: {
+            line: generated.line,
+            column: generated.column
+          },
+          name: original.name
+        });
+      }
+      lastOriginalSource = original.source;
+      lastOriginalLine = original.line;
+      lastOriginalColumn = original.column;
+      lastOriginalName = original.name;
+      sourceMappingActive = true;
+    } else if (sourceMappingActive) {
+      map.addMapping({
+        generated: {
+          line: generated.line,
+          column: generated.column
+        }
+      });
+      lastOriginalSource = null;
+      sourceMappingActive = false;
+    }
+    for (var idx = 0, length = chunk.length; idx < length; idx++) {
+      if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
+        generated.line++;
+        generated.column = 0;
+        // Mappings end at eol
+        if (idx + 1 === length) {
+          lastOriginalSource = null;
+          sourceMappingActive = false;
+        } else if (sourceMappingActive) {
+          map.addMapping({
+            source: original.source,
+            original: {
+              line: original.line,
+              column: original.column
+            },
+            generated: {
+              line: generated.line,
+              column: generated.column
+            },
+            name: original.name
+          });
+        }
+      } else {
+        generated.column++;
+      }
+    }
+  });
+  this.walkSourceContents(function (sourceFile, sourceContent) {
+    map.setSourceContent(sourceFile, sourceContent);
+  });
+
+  return { code: generated.code, map: map };
+};
+
+exports.SourceNode = SourceNode;
diff --git a/node_modules/@babel/generator/node_modules/source-map/lib/util.js b/node_modules/@babel/generator/node_modules/source-map/lib/util.js
new file mode 100644
index 00000000..44e0e452
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/source-map/lib/util.js
@@ -0,0 +1,417 @@
+/* -*- 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 consecutive 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;
diff --git a/node_modules/@babel/generator/node_modules/source-map/package.json b/node_modules/@babel/generator/node_modules/source-map/package.json
new file mode 100644
index 00000000..048e3ae8
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/source-map/package.json
@@ -0,0 +1,72 @@
+{
+  "name": "source-map",
+  "description": "Generates and consumes source maps",
+  "version": "0.5.7",
+  "homepage": "https://github.com/mozilla/source-map",
+  "author": "Nick Fitzgerald <nfitzgerald@mozilla.com>",
+  "contributors": [
+    "Tobias Koppers <tobias.koppers@googlemail.com>",
+    "Duncan Beevers <duncan@dweebd.com>",
+    "Stephen Crane <scrane@mozilla.com>",
+    "Ryan Seddon <seddon.ryan@gmail.com>",
+    "Miles Elam <miles.elam@deem.com>",
+    "Mihai Bazon <mihai.bazon@gmail.com>",
+    "Michael Ficarra <github.public.email@michael.ficarra.me>",
+    "Todd Wolfson <todd@twolfson.com>",
+    "Alexander Solovyov <alexander@solovyov.net>",
+    "Felix Gnass <fgnass@gmail.com>",
+    "Conrad Irwin <conrad.irwin@gmail.com>",
+    "usrbincc <usrbincc@yahoo.com>",
+    "David Glasser <glasser@davidglasser.net>",
+    "Chase Douglas <chase@newrelic.com>",
+    "Evan Wallace <evan.exe@gmail.com>",
+    "Heather Arthur <fayearthur@gmail.com>",
+    "Hugh Kennedy <hughskennedy@gmail.com>",
+    "David Glasser <glasser@davidglasser.net>",
+    "Simon Lydell <simon.lydell@gmail.com>",
+    "Jmeas Smith <jellyes2@gmail.com>",
+    "Michael Z Goddard <mzgoddard@gmail.com>",
+    "azu <azu@users.noreply.github.com>",
+    "John Gozde <john@gozde.ca>",
+    "Adam Kirkton <akirkton@truefitinnovation.com>",
+    "Chris Montgomery <christopher.montgomery@dowjones.com>",
+    "J. Ryan Stinnett <jryans@gmail.com>",
+    "Jack Herrington <jherrington@walmartlabs.com>",
+    "Chris Truter <jeffpalentine@gmail.com>",
+    "Daniel Espeset <daniel@danielespeset.com>",
+    "Jamie Wong <jamie.lf.wong@gmail.com>",
+    "Eddy Bruël <ejpbruel@mozilla.com>",
+    "Hawken Rives <hawkrives@gmail.com>",
+    "Gilad Peleg <giladp007@gmail.com>",
+    "djchie <djchie.dev@gmail.com>",
+    "Gary Ye <garysye@gmail.com>",
+    "Nicolas Lalevée <nicolas.lalevee@hibnet.org>"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/mozilla/source-map.git"
+  },
+  "main": "./source-map.js",
+  "files": [
+    "source-map.js",
+    "lib/",
+    "dist/source-map.debug.js",
+    "dist/source-map.js",
+    "dist/source-map.min.js",
+    "dist/source-map.min.js.map"
+  ],
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "license": "BSD-3-Clause",
+  "scripts": {
+    "test": "npm run build && node test/run-tests.js",
+    "build": "webpack --color",
+    "toc": "doctoc --title '## Table of Contents' README.md && doctoc --title '## Table of Contents' CONTRIBUTING.md"
+  },
+  "devDependencies": {
+    "doctoc": "^0.15.0",
+    "webpack": "^1.12.0"
+  },
+  "typings": "source-map"
+}
diff --git a/node_modules/@babel/generator/node_modules/source-map/source-map.js b/node_modules/@babel/generator/node_modules/source-map/source-map.js
new file mode 100644
index 00000000..bc88fe82
--- /dev/null
+++ b/node_modules/@babel/generator/node_modules/source-map/source-map.js
@@ -0,0 +1,8 @@
+/*
+ * 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 = require('./lib/source-map-generator').SourceMapGenerator;
+exports.SourceMapConsumer = require('./lib/source-map-consumer').SourceMapConsumer;
+exports.SourceNode = require('./lib/source-node').SourceNode;
diff --git a/node_modules/@babel/generator/package.json b/node_modules/@babel/generator/package.json
new file mode 100644
index 00000000..22dbaabe
--- /dev/null
+++ b/node_modules/@babel/generator/package.json
@@ -0,0 +1,24 @@
+{
+  "name": "@babel/generator",
+  "version": "7.0.0-beta.47",
+  "description": "Turns an AST into code.",
+  "author": "Sebastian McKenzie <sebmck@gmail.com>",
+  "homepage": "https://babeljs.io/",
+  "license": "MIT",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-generator",
+  "main": "lib/index.js",
+  "files": [
+    "lib"
+  ],
+  "dependencies": {
+    "@babel/types": "7.0.0-beta.47",
+    "jsesc": "^2.5.1",
+    "lodash": "^4.17.5",
+    "source-map": "^0.5.0",
+    "trim-right": "^1.0.1"
+  },
+  "devDependencies": {
+    "@babel/helper-fixtures": "7.0.0-beta.47",
+    "babylon": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/helper-annotate-as-pure/README.md b/node_modules/@babel/helper-annotate-as-pure/README.md
new file mode 100644
index 00000000..2e8d9642
--- /dev/null
+++ b/node_modules/@babel/helper-annotate-as-pure/README.md
@@ -0,0 +1,40 @@
+# @babel/helper-annotate-as-pure
+
+## API
+
+```js
+declare export default annotateAsPure(nodeOrPath: Node | NodePath);
+```
+
+## Usage
+
+```js
+import traverse from "@babel/traverse";
+import annotateAsPure from "@babel/helper-annotate-as-pure";
+
+// ...
+
+traverse(file, {
+  CallExpression(path) {
+    annotateAsPure(path);
+  },
+});
+```
+
+## Caveat with UglifyJS pre v3.1.0
+
+`@babel/helper-annotate-as-pure` will append any existing leading comments to the `#__PURE__` annotation. Versions of UglifyJS prior to v3.1.0 will **ignore** these annotations, as they only check the _last_ leading comment for the annotation.
+
+For example, using the `Usage` snippet above:
+
+**In**
+
+```js
+const four = /* foo */ add(2, 2);
+```
+
+**Out**
+
+```js
+const four = /* #__PURE__ */ /* foo */ add(2, 2);
+```
diff --git a/node_modules/@babel/helper-annotate-as-pure/lib/index.js b/node_modules/@babel/helper-annotate-as-pure/lib/index.js
new file mode 100644
index 00000000..2251317b
--- /dev/null
+++ b/node_modules/@babel/helper-annotate-as-pure/lib/index.js
@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = annotateAsPure;
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+const PURE_ANNOTATION = "#__PURE__";
+
+const isPureAnnotated = ({
+  leadingComments
+}) => !!leadingComments && leadingComments.some(comment => /[@#]__PURE__/.test(comment.value));
+
+function annotateAsPure(pathOrNode) {
+  const node = pathOrNode.node || pathOrNode;
+
+  if (isPureAnnotated(node)) {
+    return;
+  }
+
+  t().addComment(node, "leading", PURE_ANNOTATION);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/helper-annotate-as-pure/package.json b/node_modules/@babel/helper-annotate-as-pure/package.json
new file mode 100644
index 00000000..47956e35
--- /dev/null
+++ b/node_modules/@babel/helper-annotate-as-pure/package.json
@@ -0,0 +1,11 @@
+{
+  "name": "@babel/helper-annotate-as-pure",
+  "version": "7.0.0-beta.47",
+  "description": "Helper function to annotate paths and nodes with #__PURE__ comment",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-helper-annotate-as-pure",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/types": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/helper-builder-binary-assignment-operator-visitor/README.md b/node_modules/@babel/helper-builder-binary-assignment-operator-visitor/README.md
new file mode 100644
index 00000000..a5cde7a8
--- /dev/null
+++ b/node_modules/@babel/helper-builder-binary-assignment-operator-visitor/README.md
@@ -0,0 +1,5 @@
+# @babel/helper-builder-binary-assignment-operator-visitor
+
+## Usage
+
+TODO
diff --git a/node_modules/@babel/helper-builder-binary-assignment-operator-visitor/lib/index.js b/node_modules/@babel/helper-builder-binary-assignment-operator-visitor/lib/index.js
new file mode 100644
index 00000000..06f78a39
--- /dev/null
+++ b/node_modules/@babel/helper-builder-binary-assignment-operator-visitor/lib/index.js
@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+function _helperExplodeAssignableExpression() {
+  const data = _interopRequireDefault(require("@babel/helper-explode-assignable-expression"));
+
+  _helperExplodeAssignableExpression = function _helperExplodeAssignableExpression() {
+    return data;
+  };
+
+  return data;
+}
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _default(opts) {
+  const build = opts.build,
+        operator = opts.operator;
+  return {
+    AssignmentExpression(path) {
+      const node = path.node,
+            scope = path.scope;
+      if (node.operator !== operator + "=") return;
+      const nodes = [];
+      const exploded = (0, _helperExplodeAssignableExpression().default)(node.left, nodes, this, scope);
+      nodes.push(t().assignmentExpression("=", exploded.ref, build(exploded.uid, node.right)));
+      path.replaceWith(t().sequenceExpression(nodes));
+    },
+
+    BinaryExpression(path) {
+      const node = path.node;
+
+      if (node.operator === operator) {
+        path.replaceWith(build(node.left, node.right));
+      }
+    }
+
+  };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/helper-builder-binary-assignment-operator-visitor/package.json b/node_modules/@babel/helper-builder-binary-assignment-operator-visitor/package.json
new file mode 100644
index 00000000..6e6b15ef
--- /dev/null
+++ b/node_modules/@babel/helper-builder-binary-assignment-operator-visitor/package.json
@@ -0,0 +1,12 @@
+{
+  "name": "@babel/helper-builder-binary-assignment-operator-visitor",
+  "version": "7.0.0-beta.47",
+  "description": "Helper function to build binary assignment operator visitors",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-helper-builder-binary-assignment-operator-visitor",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/helper-explode-assignable-expression": "7.0.0-beta.47",
+    "@babel/types": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/helper-call-delegate/README.md b/node_modules/@babel/helper-call-delegate/README.md
new file mode 100644
index 00000000..decce1e1
--- /dev/null
+++ b/node_modules/@babel/helper-call-delegate/README.md
@@ -0,0 +1,5 @@
+# @babel/helper-call-delegate
+
+## Usage
+
+TODO
diff --git a/node_modules/@babel/helper-call-delegate/lib/index.js b/node_modules/@babel/helper-call-delegate/lib/index.js
new file mode 100644
index 00000000..bf744a09
--- /dev/null
+++ b/node_modules/@babel/helper-call-delegate/lib/index.js
@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+function _helperHoistVariables() {
+  const data = _interopRequireDefault(require("@babel/helper-hoist-variables"));
+
+  _helperHoistVariables = function _helperHoistVariables() {
+    return data;
+  };
+
+  return data;
+}
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const visitor = {
+  enter(path, state) {
+    if (path.isThisExpression()) {
+      state.foundThis = true;
+    }
+
+    if (path.isReferencedIdentifier({
+      name: "arguments"
+    })) {
+      state.foundArguments = true;
+    }
+  },
+
+  Function(path) {
+    path.skip();
+  }
+
+};
+
+function _default(path, scope = path.scope) {
+  const node = path.node;
+  const container = t().functionExpression(null, [], node.body, node.generator, node.async);
+  let callee = container;
+  let args = [];
+  (0, _helperHoistVariables().default)(path, id => scope.push({
+    id
+  }));
+  const state = {
+    foundThis: false,
+    foundArguments: false
+  };
+  path.traverse(visitor, state);
+
+  if (state.foundArguments) {
+    callee = t().memberExpression(container, t().identifier("apply"));
+    args = [];
+
+    if (state.foundThis) {
+      args.push(t().thisExpression());
+    }
+
+    if (state.foundArguments) {
+      if (!state.foundThis) args.push(t().nullLiteral());
+      args.push(t().identifier("arguments"));
+    }
+  }
+
+  let call = t().callExpression(callee, args);
+  if (node.generator) call = t().yieldExpression(call, true);
+  return t().returnStatement(call);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/helper-call-delegate/package.json b/node_modules/@babel/helper-call-delegate/package.json
new file mode 100644
index 00000000..74db7c8d
--- /dev/null
+++ b/node_modules/@babel/helper-call-delegate/package.json
@@ -0,0 +1,13 @@
+{
+  "name": "@babel/helper-call-delegate",
+  "version": "7.0.0-beta.47",
+  "description": "Helper function to call delegate",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-helper-call-delegate",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/helper-hoist-variables": "7.0.0-beta.47",
+    "@babel/traverse": "7.0.0-beta.47",
+    "@babel/types": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/helper-define-map/README.md b/node_modules/@babel/helper-define-map/README.md
new file mode 100644
index 00000000..0bb31013
--- /dev/null
+++ b/node_modules/@babel/helper-define-map/README.md
@@ -0,0 +1,5 @@
+# @babel/helper-define-map
+
+## Usage
+
+TODO
diff --git a/node_modules/@babel/helper-define-map/lib/index.js b/node_modules/@babel/helper-define-map/lib/index.js
new file mode 100644
index 00000000..a98f7a46
--- /dev/null
+++ b/node_modules/@babel/helper-define-map/lib/index.js
@@ -0,0 +1,165 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.push = push;
+exports.hasComputed = hasComputed;
+exports.toComputedObjectFromClass = toComputedObjectFromClass;
+exports.toClassObject = toClassObject;
+exports.toDefineObject = toDefineObject;
+
+function _helperFunctionName() {
+  const data = _interopRequireDefault(require("@babel/helper-function-name"));
+
+  _helperFunctionName = function _helperFunctionName() {
+    return data;
+  };
+
+  return data;
+}
+
+function _has() {
+  const data = _interopRequireDefault(require("lodash/has"));
+
+  _has = function _has() {
+    return data;
+  };
+
+  return data;
+}
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function toKind(node) {
+  if (t().isClassMethod(node) || t().isObjectMethod(node)) {
+    if (node.kind === "get" || node.kind === "set") {
+      return node.kind;
+    }
+  }
+
+  return "value";
+}
+
+function push(mutatorMap, node, kind, file, scope) {
+  const alias = t().toKeyAlias(node);
+  let map = {};
+  if ((0, _has().default)(mutatorMap, alias)) map = mutatorMap[alias];
+  mutatorMap[alias] = map;
+  map._inherits = map._inherits || [];
+
+  map._inherits.push(node);
+
+  map._key = node.key;
+
+  if (node.computed) {
+    map._computed = true;
+  }
+
+  if (node.decorators) {
+    const decorators = map.decorators = map.decorators || t().arrayExpression([]);
+    decorators.elements = decorators.elements.concat(node.decorators.map(dec => dec.expression).reverse());
+  }
+
+  if (map.value || map.initializer) {
+    throw file.buildCodeFrameError(node, "Key conflict with sibling node");
+  }
+
+  let key, value;
+
+  if (t().isObjectProperty(node) || t().isObjectMethod(node) || t().isClassMethod(node)) {
+    key = t().toComputedKey(node, node.key);
+  }
+
+  if (t().isProperty(node)) {
+    value = node.value;
+  } else if (t().isObjectMethod(node) || t().isClassMethod(node)) {
+    value = t().functionExpression(null, node.params, node.body, node.generator, node.async);
+    value.returnType = node.returnType;
+  }
+
+  const inheritedKind = toKind(node);
+
+  if (!kind || inheritedKind !== "value") {
+    kind = inheritedKind;
+  }
+
+  if (scope && t().isStringLiteral(key) && (kind === "value" || kind === "initializer") && t().isFunctionExpression(value)) {
+    value = (0, _helperFunctionName().default)({
+      id: key,
+      node: value,
+      scope
+    });
+  }
+
+  if (value) {
+    t().inheritsComments(value, node);
+    map[kind] = value;
+  }
+
+  return map;
+}
+
+function hasComputed(mutatorMap) {
+  for (const key in mutatorMap) {
+    if (mutatorMap[key]._computed) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function toComputedObjectFromClass(obj) {
+  const objExpr = t().arrayExpression([]);
+
+  for (let i = 0; i < obj.properties.length; i++) {
+    const prop = obj.properties[i];
+    const val = prop.value;
+    val.properties.unshift(t().objectProperty(t().identifier("key"), t().toComputedKey(prop)));
+    objExpr.elements.push(val);
+  }
+
+  return objExpr;
+}
+
+function toClassObject(mutatorMap) {
+  const objExpr = t().objectExpression([]);
+  Object.keys(mutatorMap).forEach(function (mutatorMapKey) {
+    const map = mutatorMap[mutatorMapKey];
+    const mapNode = t().objectExpression([]);
+    const propNode = t().objectProperty(map._key, mapNode, map._computed);
+    Object.keys(map).forEach(function (key) {
+      const node = map[key];
+      if (key[0] === "_") return;
+      const prop = t().objectProperty(t().identifier(key), node);
+      t().inheritsComments(prop, node);
+      t().removeComments(node);
+      mapNode.properties.push(prop);
+    });
+    objExpr.properties.push(propNode);
+  });
+  return objExpr;
+}
+
+function toDefineObject(mutatorMap) {
+  Object.keys(mutatorMap).forEach(function (key) {
+    const map = mutatorMap[key];
+    if (map.value) map.writable = t().booleanLiteral(true);
+    map.configurable = t().booleanLiteral(true);
+    map.enumerable = t().booleanLiteral(true);
+  });
+  return toClassObject(mutatorMap);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/helper-define-map/package.json b/node_modules/@babel/helper-define-map/package.json
new file mode 100644
index 00000000..49ec3c2e
--- /dev/null
+++ b/node_modules/@babel/helper-define-map/package.json
@@ -0,0 +1,13 @@
+{
+  "name": "@babel/helper-define-map",
+  "version": "7.0.0-beta.47",
+  "description": "Helper function to define a map",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-helper-define-map",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/helper-function-name": "7.0.0-beta.47",
+    "@babel/types": "7.0.0-beta.47",
+    "lodash": "^4.17.5"
+  }
+}
diff --git a/node_modules/@babel/helper-explode-assignable-expression/README.md b/node_modules/@babel/helper-explode-assignable-expression/README.md
new file mode 100644
index 00000000..3229d394
--- /dev/null
+++ b/node_modules/@babel/helper-explode-assignable-expression/README.md
@@ -0,0 +1,5 @@
+# @babel/helper-explode-assignable-expression
+
+## Usage
+
+TODO
diff --git a/node_modules/@babel/helper-explode-assignable-expression/lib/index.js b/node_modules/@babel/helper-explode-assignable-expression/lib/index.js
new file mode 100644
index 00000000..757358ca
--- /dev/null
+++ b/node_modules/@babel/helper-explode-assignable-expression/lib/index.js
@@ -0,0 +1,86 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function getObjRef(node, nodes, file, scope) {
+  let ref;
+
+  if (t().isSuper(node)) {
+    return node;
+  } else if (t().isIdentifier(node)) {
+    if (scope.hasBinding(node.name)) {
+      return node;
+    } else {
+      ref = node;
+    }
+  } else if (t().isMemberExpression(node)) {
+    ref = node.object;
+
+    if (t().isSuper(ref) || t().isIdentifier(ref) && scope.hasBinding(ref.name)) {
+      return ref;
+    }
+  } else {
+    throw new Error(`We can't explode this node type ${node.type}`);
+  }
+
+  const temp = scope.generateUidIdentifierBasedOnNode(ref);
+  scope.push({
+    id: temp
+  });
+  nodes.push(t().assignmentExpression("=", t().cloneNode(temp), t().cloneNode(ref)));
+  return temp;
+}
+
+function getPropRef(node, nodes, file, scope) {
+  const prop = node.property;
+  const key = t().toComputedKey(node, prop);
+  if (t().isLiteral(key) && t().isPureish(key)) return key;
+  const temp = scope.generateUidIdentifierBasedOnNode(prop);
+  scope.push({
+    id: temp
+  });
+  nodes.push(t().assignmentExpression("=", t().cloneNode(temp), t().cloneNode(prop)));
+  return temp;
+}
+
+function _default(node, nodes, file, scope, allowedSingleIdent) {
+  let obj;
+
+  if (t().isIdentifier(node) && allowedSingleIdent) {
+    obj = node;
+  } else {
+    obj = getObjRef(node, nodes, file, scope);
+  }
+
+  let ref, uid;
+
+  if (t().isIdentifier(node)) {
+    ref = t().cloneNode(node);
+    uid = obj;
+  } else {
+    const prop = getPropRef(node, nodes, file, scope);
+    const computed = node.computed || t().isLiteral(prop);
+    uid = t().memberExpression(t().cloneNode(obj), t().cloneNode(prop), computed);
+    ref = t().memberExpression(t().cloneNode(obj), t().cloneNode(prop), computed);
+  }
+
+  return {
+    uid: uid,
+    ref: ref
+  };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/helper-explode-assignable-expression/package.json b/node_modules/@babel/helper-explode-assignable-expression/package.json
new file mode 100644
index 00000000..8f6fc4d2
--- /dev/null
+++ b/node_modules/@babel/helper-explode-assignable-expression/package.json
@@ -0,0 +1,12 @@
+{
+  "name": "@babel/helper-explode-assignable-expression",
+  "version": "7.0.0-beta.47",
+  "description": "Helper function to explode an assignable expression",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-helper-explode-assignable-expression",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/traverse": "7.0.0-beta.47",
+    "@babel/types": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/helper-function-name/README.md b/node_modules/@babel/helper-function-name/README.md
new file mode 100644
index 00000000..97b5b4de
--- /dev/null
+++ b/node_modules/@babel/helper-function-name/README.md
@@ -0,0 +1,5 @@
+# @babel/helper-function-name
+
+## Usage
+
+TODO
diff --git a/node_modules/@babel/helper-function-name/lib/index.js b/node_modules/@babel/helper-function-name/lib/index.js
new file mode 100644
index 00000000..1da3a241
--- /dev/null
+++ b/node_modules/@babel/helper-function-name/lib/index.js
@@ -0,0 +1,198 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+function _helperGetFunctionArity() {
+  const data = _interopRequireDefault(require("@babel/helper-get-function-arity"));
+
+  _helperGetFunctionArity = function _helperGetFunctionArity() {
+    return data;
+  };
+
+  return data;
+}
+
+function _template() {
+  const data = _interopRequireDefault(require("@babel/template"));
+
+  _template = function _template() {
+    return data;
+  };
+
+  return data;
+}
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const buildPropertyMethodAssignmentWrapper = (0, _template().default)(`
+  (function (FUNCTION_KEY) {
+    function FUNCTION_ID() {
+      return FUNCTION_KEY.apply(this, arguments);
+    }
+
+    FUNCTION_ID.toString = function () {
+      return FUNCTION_KEY.toString();
+    }
+
+    return FUNCTION_ID;
+  })(FUNCTION)
+`);
+const buildGeneratorPropertyMethodAssignmentWrapper = (0, _template().default)(`
+  (function (FUNCTION_KEY) {
+    function* FUNCTION_ID() {
+      return yield* FUNCTION_KEY.apply(this, arguments);
+    }
+
+    FUNCTION_ID.toString = function () {
+      return FUNCTION_KEY.toString();
+    };
+
+    return FUNCTION_ID;
+  })(FUNCTION)
+`);
+const visitor = {
+  "ReferencedIdentifier|BindingIdentifier"(path, state) {
+    if (path.node.name !== state.name) return;
+    const localDeclar = path.scope.getBindingIdentifier(state.name);
+    if (localDeclar !== state.outerDeclar) return;
+    state.selfReference = true;
+    path.stop();
+  }
+
+};
+
+function getNameFromLiteralId(id) {
+  if (t().isNullLiteral(id)) {
+    return "null";
+  }
+
+  if (t().isRegExpLiteral(id)) {
+    return `_${id.pattern}_${id.flags}`;
+  }
+
+  if (t().isTemplateLiteral(id)) {
+    return id.quasis.map(quasi => quasi.value.raw).join("");
+  }
+
+  if (id.value !== undefined) {
+    return id.value + "";
+  }
+
+  return "";
+}
+
+function wrap(state, method, id, scope) {
+  if (state.selfReference) {
+    if (scope.hasBinding(id.name) && !scope.hasGlobal(id.name)) {
+      scope.rename(id.name);
+    } else {
+      if (!t().isFunction(method)) return;
+      let build = buildPropertyMethodAssignmentWrapper;
+
+      if (method.generator) {
+        build = buildGeneratorPropertyMethodAssignmentWrapper;
+      }
+
+      const template = build({
+        FUNCTION: method,
+        FUNCTION_ID: id,
+        FUNCTION_KEY: scope.generateUidIdentifier(id.name)
+      }).expression;
+      const params = template.callee.body.body[0].params;
+
+      for (let i = 0, len = (0, _helperGetFunctionArity().default)(method); i < len; i++) {
+        params.push(scope.generateUidIdentifier("x"));
+      }
+
+      return template;
+    }
+  }
+
+  method.id = id;
+  scope.getProgramParent().references[id.name] = true;
+}
+
+function visit(node, name, scope) {
+  const state = {
+    selfAssignment: false,
+    selfReference: false,
+    outerDeclar: scope.getBindingIdentifier(name),
+    references: [],
+    name: name
+  };
+  const binding = scope.getOwnBinding(name);
+
+  if (binding) {
+    if (binding.kind === "param") {
+      state.selfReference = true;
+    } else {}
+  } else if (state.outerDeclar || scope.hasGlobal(name)) {
+    scope.traverse(node, visitor, state);
+  }
+
+  return state;
+}
+
+function _default({
+  node,
+  parent,
+  scope,
+  id
+}, localBinding = false) {
+  if (node.id) return;
+
+  if ((t().isObjectProperty(parent) || t().isObjectMethod(parent, {
+    kind: "method"
+  })) && (!parent.computed || t().isLiteral(parent.key))) {
+    id = parent.key;
+  } else if (t().isVariableDeclarator(parent)) {
+    id = parent.id;
+
+    if (t().isIdentifier(id) && !localBinding) {
+      const binding = scope.parent.getBinding(id.name);
+
+      if (binding && binding.constant && scope.getBinding(id.name) === binding) {
+        node.id = t().cloneNode(id);
+        node.id[t().NOT_LOCAL_BINDING] = true;
+        return;
+      }
+    }
+  } else if (t().isAssignmentExpression(parent)) {
+    id = parent.left;
+  } else if (!id) {
+    return;
+  }
+
+  let name;
+
+  if (id && t().isLiteral(id)) {
+    name = getNameFromLiteralId(id);
+  } else if (id && t().isIdentifier(id)) {
+    name = id.name;
+  }
+
+  if (name === undefined) {
+    return;
+  }
+
+  name = t().toBindingIdentifierName(name);
+  id = t().identifier(name);
+  id[t().NOT_LOCAL_BINDING] = true;
+  const state = visit(node, name, scope);
+  return wrap(state, node, id, scope) || node;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/helper-function-name/package.json b/node_modules/@babel/helper-function-name/package.json
new file mode 100644
index 00000000..a18770dd
--- /dev/null
+++ b/node_modules/@babel/helper-function-name/package.json
@@ -0,0 +1,13 @@
+{
+  "name": "@babel/helper-function-name",
+  "version": "7.0.0-beta.47",
+  "description": "Helper function to change the property 'name' of every function",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-helper-function-name",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/helper-get-function-arity": "7.0.0-beta.47",
+    "@babel/template": "7.0.0-beta.47",
+    "@babel/types": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/helper-get-function-arity/README.md b/node_modules/@babel/helper-get-function-arity/README.md
new file mode 100644
index 00000000..d341c9ce
--- /dev/null
+++ b/node_modules/@babel/helper-get-function-arity/README.md
@@ -0,0 +1,21 @@
+# @babel/helper-get-function-arity
+
+Function that returns the number of arguments that a function takes.
+* Examples of what is considered an argument can be found at [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/length)
+
+## Usage
+
+```javascript
+import getFunctionArity from "@babel/helper-get-function-arity";
+
+function wrap(state, method, id, scope) {
+  // ...
+  if (!t.isFunction(method)) {
+    return false;
+  }
+
+  const argumentsLength = getFunctionArity(method);
+
+  // ...
+}
+```
diff --git a/node_modules/@babel/helper-get-function-arity/lib/index.js b/node_modules/@babel/helper-get-function-arity/lib/index.js
new file mode 100644
index 00000000..71cfb032
--- /dev/null
+++ b/node_modules/@babel/helper-get-function-arity/lib/index.js
@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _default(node) {
+  const params = node.params;
+
+  for (let i = 0; i < params.length; i++) {
+    const param = params[i];
+
+    if (t().isAssignmentPattern(param) || t().isRestElement(param)) {
+      return i;
+    }
+  }
+
+  return params.length;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/helper-get-function-arity/package.json b/node_modules/@babel/helper-get-function-arity/package.json
new file mode 100644
index 00000000..27219ec8
--- /dev/null
+++ b/node_modules/@babel/helper-get-function-arity/package.json
@@ -0,0 +1,11 @@
+{
+  "name": "@babel/helper-get-function-arity",
+  "version": "7.0.0-beta.47",
+  "description": "Helper function to get function arity",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-helper-get-function-arity",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/types": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/helper-hoist-variables/README.md b/node_modules/@babel/helper-hoist-variables/README.md
new file mode 100644
index 00000000..a00b8559
--- /dev/null
+++ b/node_modules/@babel/helper-hoist-variables/README.md
@@ -0,0 +1,17 @@
+# @babel/helper-hoist-variables
+
+## Installation
+
+```sh
+npm install @babel/helper-hoist-variables --save
+```
+
+## API
+
+```javascript
+declare export default hoistVariables(path: NodePath, emit: Function, kind: "var" | "let" = "var");
+```
+
+## Usage
+
+TODO
diff --git a/node_modules/@babel/helper-hoist-variables/lib/index.js b/node_modules/@babel/helper-hoist-variables/lib/index.js
new file mode 100644
index 00000000..45eef222
--- /dev/null
+++ b/node_modules/@babel/helper-hoist-variables/lib/index.js
@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+const visitor = {
+  Scope(path, state) {
+    if (state.kind === "let") path.skip();
+  },
+
+  Function(path) {
+    path.skip();
+  },
+
+  VariableDeclaration(path, state) {
+    if (state.kind && path.node.kind !== state.kind) return;
+    const nodes = [];
+    const declarations = path.get("declarations");
+    let firstId;
+
+    for (var _iterator = declarations, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i >= _iterator.length) break;
+        _ref = _iterator[_i++];
+      } else {
+        _i = _iterator.next();
+        if (_i.done) break;
+        _ref = _i.value;
+      }
+
+      const declar = _ref;
+      firstId = declar.node.id;
+
+      if (declar.node.init) {
+        nodes.push(t().expressionStatement(t().assignmentExpression("=", declar.node.id, declar.node.init)));
+      }
+
+      for (const name in declar.getBindingIdentifiers()) {
+        state.emit(t().identifier(name), name);
+      }
+    }
+
+    if (path.parentPath.isFor({
+      left: path.node
+    })) {
+      path.replaceWith(firstId);
+    } else {
+      path.replaceWithMultiple(nodes);
+    }
+  }
+
+};
+
+function _default(path, emit, kind = "var") {
+  path.traverse(visitor, {
+    kind,
+    emit
+  });
+}
\ No newline at end of file
diff --git a/node_modules/@babel/helper-hoist-variables/package.json b/node_modules/@babel/helper-hoist-variables/package.json
new file mode 100644
index 00000000..94bf68f6
--- /dev/null
+++ b/node_modules/@babel/helper-hoist-variables/package.json
@@ -0,0 +1,11 @@
+{
+  "name": "@babel/helper-hoist-variables",
+  "version": "7.0.0-beta.47",
+  "description": "Helper function to hoist variables",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-helper-hoist-variables",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/types": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/helper-member-expression-to-functions/README.md b/node_modules/@babel/helper-member-expression-to-functions/README.md
new file mode 100644
index 00000000..31dd4c3c
--- /dev/null
+++ b/node_modules/@babel/helper-member-expression-to-functions/README.md
@@ -0,0 +1,75 @@
+# @babel/helper-member-expression-to-functions
+
+Helper function to replace certain member expressions with function calls
+
+## Usage
+
+> Designed for internal Babel use.
+
+Traverses the `path` using the supplied `visitor` and an augmented `state`.
+
+```js
+const visitor = {
+  MemberExpression(memberPath, state) {
+
+    if (someCondition(memberPath)) {
+
+      // The handle method is supplied by memberExpressionToFunctions.
+      // It should be called whenever a MemberExpression should be
+      // converted into the proper function calls.
+      state.handle(memberPath);
+
+    }
+
+  },
+};
+
+// The helper requires three special methods on state: `get`, `set`, and
+// `call`.
+// Optionally, a special `memoize` method may be defined, which gets
+// called if the member is in a self-referential update expression.
+// Everything else will be passed through as normal.
+const state = {
+  get(memberPath) {
+    // Return some AST that will get the member
+    return t.callExpression(
+      this.file.addHelper('superGet'),
+      [t.thisExpression(), memberPath.node.property]
+    );
+  },
+
+  set(memberPath, value) {
+    // Return some AST that will set the member
+    return t.callExpression(
+      this.file.addHelper('superSet'),
+      [t.thisExpression(), memberPath.node.property, value]
+    );
+  },
+
+  call(memberPath, args) {
+    // Return some AST that will call the member with the proper context
+    // and args
+    return t.callExpression(
+      t.memberExpression(this.get(memberPath), t.identifier("apply")),
+      [t.thisExpression(), t.arrayExpression(args)]
+    );
+  },
+
+  memoize(memberPath) {
+    const { node } = memberPath;
+    if (node.computed) {
+      MEMOIZED.set(node, ...);
+    }
+  },
+
+  // The handle method is provided by memberExpressionToFunctions.
+  // handle(memberPath) { ... }
+
+  // Other state stuff is left untouched.
+  someState: new Set(),
+};
+
+// Replace all the special MemberExpressions in rootPath, as determined
+// by our visitor, using the state methods.
+memberExpressionToFunctions(rootPath, visitor, state);
+```
diff --git a/node_modules/@babel/helper-member-expression-to-functions/lib/index.js b/node_modules/@babel/helper-member-expression-to-functions/lib/index.js
new file mode 100644
index 00000000..938dc918
--- /dev/null
+++ b/node_modules/@babel/helper-member-expression-to-functions/lib/index.js
@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = memberExpressionToFunctions;
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+const handle = {
+  handle(member) {
+    const node = member.node,
+          parent = member.parent,
+          parentPath = member.parentPath;
+
+    if (parentPath.isUpdateExpression({
+      argument: node
+    })) {
+      const operator = parent.operator,
+            prefix = parent.prefix;
+
+      if (this.memoize) {
+        this.memoize(member);
+      }
+
+      const value = t().binaryExpression(operator[0], t().unaryExpression("+", this.get(member)), t().numericLiteral(1));
+
+      if (prefix) {
+        parentPath.replaceWith(this.set(member, value));
+      } else {
+        const scope = member.scope;
+        const ref = scope.generateUidIdentifierBasedOnNode(node);
+        scope.push({
+          id: ref
+        });
+        value.left = t().assignmentExpression("=", t().cloneNode(ref), value.left);
+        parentPath.replaceWith(t().sequenceExpression([this.set(member, value), t().cloneNode(ref)]));
+      }
+
+      return;
+    }
+
+    if (parentPath.isAssignmentExpression({
+      left: node
+    })) {
+      const operator = parent.operator,
+            right = parent.right;
+      let value = right;
+
+      if (operator !== "=") {
+        if (this.memoize) {
+          this.memoize(member);
+        }
+
+        value = t().binaryExpression(operator.slice(0, -1), this.get(member), value);
+      }
+
+      parentPath.replaceWith(this.set(member, value));
+      return;
+    }
+
+    if (parentPath.isCallExpression({
+      callee: node
+    })) {
+      const args = parent.arguments;
+      parentPath.replaceWith(this.call(member, args));
+      return;
+    }
+
+    member.replaceWith(this.get(member));
+  }
+
+};
+
+function memberExpressionToFunctions(path, visitor, state) {
+  path.traverse(visitor, Object.assign({}, state, handle));
+}
\ No newline at end of file
diff --git a/node_modules/@babel/helper-member-expression-to-functions/package.json b/node_modules/@babel/helper-member-expression-to-functions/package.json
new file mode 100644
index 00000000..ce778d9f
--- /dev/null
+++ b/node_modules/@babel/helper-member-expression-to-functions/package.json
@@ -0,0 +1,12 @@
+{
+  "name": "@babel/helper-member-expression-to-functions",
+  "version": "7.0.0-beta.47",
+  "description": "Helper function to replace certain member expressions with function calls",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-helper-member-expression-to-functions",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "author": "Justin Ridgewell <justin@ridgewell.name>",
+  "dependencies": {
+    "@babel/types": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/helper-module-imports/README.md b/node_modules/@babel/helper-module-imports/README.md
new file mode 100644
index 00000000..93c134d0
--- /dev/null
+++ b/node_modules/@babel/helper-module-imports/README.md
@@ -0,0 +1,77 @@
+# @babel/helper-module-imports
+
+## Installation
+
+```sh
+npm install @babel/helper-module-imports --save
+```
+
+## Usage
+
+### `import "source"`
+
+```js
+import { addSideEffect } from "@babel/helper-module-imports";
+addSideEffect(path, 'source');
+```
+
+### `import { named } from "source"`
+
+```js
+import { addNamed } from "@babel/helper-module-imports";
+addNamed(path, 'named', 'source');
+```
+
+### `import { named as _hintedName } from "source"`
+
+```js
+import { addNamed } from "@babel/helper-module-imports";
+addNamed(path, 'named', 'source', { nameHint: "hintedName" });
+```
+
+### `import _default from "source"`
+
+```js
+import { addDefault } from "@babel/helper-module-imports";
+addDefault(path, 'source');
+```
+
+### `import hintedName from "source"`
+
+```js
+import { addDefault } from "@babel/helper-module-imports";
+addDefault(path, 'source', { nameHint: "hintedName" })
+```
+
+### `import * as _namespace from "source"`
+
+```js
+import { addNamespace } from "@babel/helper-module-imports";
+addNamespace(path, 'source');
+```
+
+## Examples
+
+### Adding a named import
+
+```js
+import { addNamed } from "@babel/helper-module-imports";
+
+export default function({ types: t }) {
+  return {
+    visitor: {
+      ReferencedIdentifier(path) {
+        let importName = this.importName;
+        if (importName) {
+          importName = t.cloneDeep(importName);
+        } else {
+          // require('bluebird').coroutine
+          importName = this.importName = addNamed(path, 'coroutine', 'bluebird');
+        }
+
+        path.replaceWith(importName);
+      }
+    },
+  };
+}
+```
diff --git a/node_modules/@babel/helper-module-imports/lib/import-builder.js b/node_modules/@babel/helper-module-imports/lib/import-builder.js
new file mode 100644
index 00000000..e944647a
--- /dev/null
+++ b/node_modules/@babel/helper-module-imports/lib/import-builder.js
@@ -0,0 +1,153 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+
+  _assert = function _assert() {
+    return data;
+  };
+
+  return data;
+}
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class ImportBuilder {
+  constructor(importedSource, scope, file) {
+    this._statements = [];
+    this._resultName = null;
+    this._scope = null;
+    this._file = null;
+    this._scope = scope;
+    this._file = file;
+    this._importedSource = importedSource;
+  }
+
+  done() {
+    return {
+      statements: this._statements,
+      resultName: this._resultName
+    };
+  }
+
+  import() {
+    this._statements.push(t().importDeclaration([], t().stringLiteral(this._importedSource)));
+
+    return this;
+  }
+
+  require() {
+    this._statements.push(t().expressionStatement(t().callExpression(t().identifier("require"), [t().stringLiteral(this._importedSource)])));
+
+    return this;
+  }
+
+  namespace(name = "namespace") {
+    name = this._scope.generateUidIdentifier(name);
+    const statement = this._statements[this._statements.length - 1];
+    (0, _assert().default)(statement.type === "ImportDeclaration");
+    (0, _assert().default)(statement.specifiers.length === 0);
+    statement.specifiers = [t().importNamespaceSpecifier(name)];
+    this._resultName = t().cloneNode(name);
+    return this;
+  }
+
+  default(name) {
+    name = this._scope.generateUidIdentifier(name);
+    const statement = this._statements[this._statements.length - 1];
+    (0, _assert().default)(statement.type === "ImportDeclaration");
+    (0, _assert().default)(statement.specifiers.length === 0);
+    statement.specifiers = [t().importDefaultSpecifier(name)];
+    this._resultName = t().cloneNode(name);
+    return this;
+  }
+
+  named(name, importName) {
+    if (importName === "default") return this.default(name);
+    name = this._scope.generateUidIdentifier(name);
+    const statement = this._statements[this._statements.length - 1];
+    (0, _assert().default)(statement.type === "ImportDeclaration");
+    (0, _assert().default)(statement.specifiers.length === 0);
+    statement.specifiers = [t().importSpecifier(name, t().identifier(importName))];
+    this._resultName = t().cloneNode(name);
+    return this;
+  }
+
+  var(name) {
+    name = this._scope.generateUidIdentifier(name);
+    let statement = this._statements[this._statements.length - 1];
+
+    if (statement.type !== "ExpressionStatement") {
+      (0, _assert().default)(this._resultName);
+      statement = t().expressionStatement(this._resultName);
+
+      this._statements.push(statement);
+    }
+
+    this._statements[this._statements.length - 1] = t().variableDeclaration("var", [t().variableDeclarator(name, statement.expression)]);
+    this._resultName = t().cloneNode(name);
+    return this;
+  }
+
+  defaultInterop() {
+    return this._interop(this._file.addHelper("interopRequireDefault"));
+  }
+
+  wildcardInterop() {
+    return this._interop(this._file.addHelper("interopRequireWildcard"));
+  }
+
+  _interop(callee) {
+    const statement = this._statements[this._statements.length - 1];
+
+    if (statement.type === "ExpressionStatement") {
+      statement.expression = t().callExpression(callee, [statement.expression]);
+    } else if (statement.type === "VariableDeclaration") {
+      (0, _assert().default)(statement.declarations.length === 1);
+      statement.declarations[0].init = t().callExpression(callee, [statement.declarations[0].init]);
+    } else {
+      _assert().default.fail("Unexpected type.");
+    }
+
+    return this;
+  }
+
+  prop(name) {
+    const statement = this._statements[this._statements.length - 1];
+
+    if (statement.type === "ExpressionStatement") {
+      statement.expression = t().memberExpression(statement.expression, t().identifier(name));
+    } else if (statement.type === "VariableDeclaration") {
+      (0, _assert().default)(statement.declarations.length === 1);
+      statement.declarations[0].init = t().memberExpression(statement.declarations[0].init, t().identifier(name));
+    } else {
+      _assert().default.fail("Unexpected type:" + statement.type);
+    }
+
+    return this;
+  }
+
+  read(name) {
+    this._resultName = t().memberExpression(this._resultName, t().identifier(name));
+  }
+
+}
+
+exports.default = ImportBuilder;
\ No newline at end of file
diff --git a/node_modules/@babel/helper-module-imports/lib/import-injector.js b/node_modules/@babel/helper-module-imports/lib/import-injector.js
new file mode 100644
index 00000000..01991f11
--- /dev/null
+++ b/node_modules/@babel/helper-module-imports/lib/import-injector.js
@@ -0,0 +1,283 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+
+  _assert = function _assert() {
+    return data;
+  };
+
+  return data;
+}
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+var _importBuilder = _interopRequireDefault(require("./import-builder"));
+
+var _isModule = _interopRequireDefault(require("./is-module"));
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class ImportInjector {
+  constructor(path, importedSource, opts) {
+    this._defaultOpts = {
+      importedSource: null,
+      importedType: "commonjs",
+      importedInterop: "babel",
+      importingInterop: "babel",
+      ensureLiveReference: false,
+      ensureNoContext: false
+    };
+    const programPath = path.find(p => p.isProgram());
+    this._programPath = programPath;
+    this._programScope = programPath.scope;
+    this._file = programPath.hub.file;
+    this._defaultOpts = this._applyDefaults(importedSource, opts, true);
+  }
+
+  addDefault(importedSourceIn, opts) {
+    return this.addNamed("default", importedSourceIn, opts);
+  }
+
+  addNamed(importName, importedSourceIn, opts) {
+    (0, _assert().default)(typeof importName === "string");
+    return this._generateImport(this._applyDefaults(importedSourceIn, opts), importName);
+  }
+
+  addNamespace(importedSourceIn, opts) {
+    return this._generateImport(this._applyDefaults(importedSourceIn, opts), null);
+  }
+
+  addSideEffect(importedSourceIn, opts) {
+    return this._generateImport(this._applyDefaults(importedSourceIn, opts), false);
+  }
+
+  _applyDefaults(importedSource, opts, isInit = false) {
+    const optsList = [];
+
+    if (typeof importedSource === "string") {
+      optsList.push({
+        importedSource
+      });
+      optsList.push(opts);
+    } else {
+      (0, _assert().default)(!opts, "Unexpected secondary arguments.");
+      optsList.push(importedSource);
+    }
+
+    const newOpts = Object.assign({}, this._defaultOpts);
+
+    for (var _i = 0; _i < optsList.length; _i++) {
+      const opts = optsList[_i];
+      if (!opts) continue;
+      Object.keys(newOpts).forEach(key => {
+        if (opts[key] !== undefined) newOpts[key] = opts[key];
+      });
+
+      if (!isInit) {
+        if (opts.nameHint !== undefined) newOpts.nameHint = opts.nameHint;
+        if (opts.blockHoist !== undefined) newOpts.blockHoist = opts.blockHoist;
+      }
+    }
+
+    return newOpts;
+  }
+
+  _generateImport(opts, importName) {
+    const isDefault = importName === "default";
+    const isNamed = !!importName && !isDefault;
+    const isNamespace = importName === null;
+    const importedSource = opts.importedSource,
+          importedType = opts.importedType,
+          importedInterop = opts.importedInterop,
+          importingInterop = opts.importingInterop,
+          ensureLiveReference = opts.ensureLiveReference,
+          ensureNoContext = opts.ensureNoContext,
+          nameHint = opts.nameHint,
+          blockHoist = opts.blockHoist;
+    let name = nameHint || importName;
+    const isMod = (0, _isModule.default)(this._programPath);
+    const isModuleForNode = isMod && importingInterop === "node";
+    const isModuleForBabel = isMod && importingInterop === "babel";
+    const builder = new _importBuilder.default(importedSource, this._programScope, this._file);
+
+    if (importedType === "es6") {
+      if (!isModuleForNode && !isModuleForBabel) {
+        throw new Error("Cannot import an ES6 module from CommonJS");
+      }
+
+      builder.import();
+
+      if (isNamespace) {
+        builder.namespace(nameHint || importedSource);
+      } else if (isDefault || isNamed) {
+        builder.named(name, importName);
+      }
+    } else if (importedType !== "commonjs") {
+      throw new Error(`Unexpected interopType "${importedType}"`);
+    } else if (importedInterop === "babel") {
+      if (isModuleForNode) {
+        name = name !== "default" ? name : importedSource;
+        const es6Default = `${importedSource}$es6Default`;
+        builder.import();
+
+        if (isNamespace) {
+          builder.default(es6Default).var(name || importedSource).wildcardInterop();
+        } else if (isDefault) {
+          if (ensureLiveReference) {
+            builder.default(es6Default).var(name || importedSource).defaultInterop().read("default");
+          } else {
+            builder.default(es6Default).var(name).defaultInterop().prop(importName);
+          }
+        } else if (isNamed) {
+          builder.default(es6Default).read(importName);
+        }
+      } else if (isModuleForBabel) {
+        builder.import();
+
+        if (isNamespace) {
+          builder.namespace(name || importedSource);
+        } else if (isDefault || isNamed) {
+          builder.named(name, importName);
+        }
+      } else {
+        builder.require();
+
+        if (isNamespace) {
+          builder.var(name || importedSource).wildcardInterop();
+        } else if ((isDefault || isNamed) && ensureLiveReference) {
+          if (isDefault) {
+            name = name !== "default" ? name : importedSource;
+            builder.var(name).read(importName);
+            builder.defaultInterop();
+          } else {
+            builder.var(importedSource).read(importName);
+          }
+        } else if (isDefault) {
+          builder.var(name).defaultInterop().prop(importName);
+        } else if (isNamed) {
+          builder.var(name).prop(importName);
+        }
+      }
+    } else if (importedInterop === "compiled") {
+      if (isModuleForNode) {
+        builder.import();
+
+        if (isNamespace) {
+          builder.default(name || importedSource);
+        } else if (isDefault || isNamed) {
+          builder.default(importedSource).read(name);
+        }
+      } else if (isModuleForBabel) {
+        builder.import();
+
+        if (isNamespace) {
+          builder.namespace(name || importedSource);
+        } else if (isDefault || isNamed) {
+          builder.named(name, importName);
+        }
+      } else {
+        builder.require();
+
+        if (isNamespace) {
+          builder.var(name || importedSource);
+        } else if (isDefault || isNamed) {
+          if (ensureLiveReference) {
+            builder.var(importedSource).read(name);
+          } else {
+            builder.prop(importName).var(name);
+          }
+        }
+      }
+    } else if (importedInterop === "uncompiled") {
+      if (isDefault && ensureLiveReference) {
+        throw new Error("No live reference for commonjs default");
+      }
+
+      if (isModuleForNode) {
+        builder.import();
+
+        if (isNamespace) {
+          builder.default(name || importedSource);
+        } else if (isDefault) {
+          builder.default(name);
+        } else if (isNamed) {
+          builder.default(importedSource).read(name);
+        }
+      } else if (isModuleForBabel) {
+        builder.import();
+
+        if (isNamespace) {
+          builder.default(name || importedSource);
+        } else if (isDefault) {
+          builder.default(name);
+        } else if (isNamed) {
+          builder.named(name, importName);
+        }
+      } else {
+        builder.require();
+
+        if (isNamespace) {
+          builder.var(name || importedSource);
+        } else if (isDefault) {
+          builder.var(name);
+        } else if (isNamed) {
+          if (ensureLiveReference) {
+            builder.var(importedSource).read(name);
+          } else {
+            builder.var(name).prop(importName);
+          }
+        }
+      }
+    } else {
+      throw new Error(`Unknown importedInterop "${importedInterop}".`);
+    }
+
+    const _builder$done = builder.done(),
+          statements = _builder$done.statements,
+          resultName = _builder$done.resultName;
+
+    this._insertStatements(statements, blockHoist);
+
+    if ((isDefault || isNamed) && ensureNoContext && resultName.type !== "Identifier") {
+      return t().sequenceExpression([t().numericLiteral(0), resultName]);
+    }
+
+    return resultName;
+  }
+
+  _insertStatements(statements, blockHoist = 3) {
+    statements.forEach(node => {
+      node._blockHoist = blockHoist;
+    });
+
+    const targetPath = this._programPath.get("body").filter(p => {
+      const val = p.node._blockHoist;
+      return Number.isFinite(val) && val < 4;
+    })[0];
+
+    if (targetPath) {
+      targetPath.insertBefore(statements);
+    } else {
+      this._programPath.unshiftContainer("body", statements);
+    }
+  }
+
+}
+
+exports.default = ImportInjector;
\ No newline at end of file
diff --git a/node_modules/@babel/helper-module-imports/lib/index.js b/node_modules/@babel/helper-module-imports/lib/index.js
new file mode 100644
index 00000000..425e6a91
--- /dev/null
+++ b/node_modules/@babel/helper-module-imports/lib/index.js
@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addDefault = addDefault;
+exports.addNamed = addNamed;
+exports.addNamespace = addNamespace;
+exports.addSideEffect = addSideEffect;
+Object.defineProperty(exports, "ImportInjector", {
+  enumerable: true,
+  get: function get() {
+    return _importInjector.default;
+  }
+});
+Object.defineProperty(exports, "isModule", {
+  enumerable: true,
+  get: function get() {
+    return _isModule.default;
+  }
+});
+
+var _importInjector = _interopRequireDefault(require("./import-injector"));
+
+var _isModule = _interopRequireDefault(require("./is-module"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function addDefault(path, importedSource, opts) {
+  return new _importInjector.default(path).addDefault(importedSource, opts);
+}
+
+function addNamed(path, name, importedSource, opts) {
+  return new _importInjector.default(path).addNamed(name, importedSource, opts);
+}
+
+function addNamespace(path, importedSource, opts) {
+  return new _importInjector.default(path).addNamespace(importedSource, opts);
+}
+
+function addSideEffect(path, importedSource, opts) {
+  return new _importInjector.default(path).addSideEffect(importedSource, opts);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/helper-module-imports/lib/is-module.js b/node_modules/@babel/helper-module-imports/lib/is-module.js
new file mode 100644
index 00000000..bdb24c33
--- /dev/null
+++ b/node_modules/@babel/helper-module-imports/lib/is-module.js
@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isModule;
+
+function isModule(path) {
+  const sourceType = path.node.sourceType;
+
+  if (sourceType !== "module" && sourceType !== "script") {
+    throw path.buildCodeFrameError(`Unknown sourceType "${sourceType}", cannot transform.`);
+  }
+
+  return path.node.sourceType === "module";
+}
\ No newline at end of file
diff --git a/node_modules/@babel/helper-module-imports/package.json b/node_modules/@babel/helper-module-imports/package.json
new file mode 100644
index 00000000..a235eb45
--- /dev/null
+++ b/node_modules/@babel/helper-module-imports/package.json
@@ -0,0 +1,17 @@
+{
+  "name": "@babel/helper-module-imports",
+  "version": "7.0.0-beta.47",
+  "description": "Babel helper functions for inserting module loads",
+  "author": "Logan Smyth <loganfsmyth@gmail.com>",
+  "homepage": "https://babeljs.io/",
+  "license": "MIT",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-helper-module-imports",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/types": "7.0.0-beta.47",
+    "lodash": "^4.17.5"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/helper-module-transforms/README.md b/node_modules/@babel/helper-module-transforms/README.md
new file mode 100644
index 00000000..f828100e
--- /dev/null
+++ b/node_modules/@babel/helper-module-transforms/README.md
@@ -0,0 +1,5 @@
+# @babel/helper-module-transforms
+
+## Usage
+
+TODO
diff --git a/node_modules/@babel/helper-module-transforms/lib/index.js b/node_modules/@babel/helper-module-transforms/lib/index.js
new file mode 100644
index 00000000..996f8b9d
--- /dev/null
+++ b/node_modules/@babel/helper-module-transforms/lib/index.js
@@ -0,0 +1,466 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.rewriteModuleStatementsAndPrepareHeader = rewriteModuleStatementsAndPrepareHeader;
+exports.ensureStatementsHoisted = ensureStatementsHoisted;
+exports.wrapInterop = wrapInterop;
+exports.buildNamespaceInitStatements = buildNamespaceInitStatements;
+Object.defineProperty(exports, "isModule", {
+  enumerable: true,
+  get: function get() {
+    return _helperModuleImports().isModule;
+  }
+});
+Object.defineProperty(exports, "hasExports", {
+  enumerable: true,
+  get: function get() {
+    return _normalizeAndLoadMetadata.hasExports;
+  }
+});
+Object.defineProperty(exports, "isSideEffectImport", {
+  enumerable: true,
+  get: function get() {
+    return _normalizeAndLoadMetadata.isSideEffectImport;
+  }
+});
+
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+
+  _assert = function _assert() {
+    return data;
+  };
+
+  return data;
+}
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _template() {
+  const data = _interopRequireDefault(require("@babel/template"));
+
+  _template = function _template() {
+    return data;
+  };
+
+  return data;
+}
+
+function _chunk() {
+  const data = _interopRequireDefault(require("lodash/chunk"));
+
+  _chunk = function _chunk() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperModuleImports() {
+  const data = require("@babel/helper-module-imports");
+
+  _helperModuleImports = function _helperModuleImports() {
+    return data;
+  };
+
+  return data;
+}
+
+var _rewriteThis = _interopRequireDefault(require("./rewrite-this"));
+
+var _rewriteLiveReferences = _interopRequireDefault(require("./rewrite-live-references"));
+
+var _normalizeAndLoadMetadata = _interopRequireWildcard(require("./normalize-and-load-metadata"));
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function rewriteModuleStatementsAndPrepareHeader(path, {
+  exportName,
+  strict,
+  allowTopLevelThis,
+  strictMode,
+  loose,
+  noInterop,
+  lazy,
+  esNamespaceOnly
+}) {
+  (0, _assert().default)((0, _helperModuleImports().isModule)(path), "Cannot process module statements in a script");
+  path.node.sourceType = "script";
+  const meta = (0, _normalizeAndLoadMetadata.default)(path, exportName, {
+    noInterop,
+    loose,
+    lazy,
+    esNamespaceOnly
+  });
+
+  if (!allowTopLevelThis) {
+    (0, _rewriteThis.default)(path);
+  }
+
+  (0, _rewriteLiveReferences.default)(path, meta);
+
+  if (strictMode !== false) {
+    const hasStrict = path.node.directives.some(directive => {
+      return directive.value.value === "use strict";
+    });
+
+    if (!hasStrict) {
+      path.unshiftContainer("directives", t().directive(t().directiveLiteral("use strict")));
+    }
+  }
+
+  const headers = [];
+
+  if ((0, _normalizeAndLoadMetadata.hasExports)(meta) && !strict) {
+    headers.push(buildESModuleHeader(meta, loose));
+  }
+
+  const nameList = buildExportNameListDeclaration(path, meta);
+
+  if (nameList) {
+    meta.exportNameListName = nameList.name;
+    headers.push(nameList.statement);
+  }
+
+  headers.push(...buildExportInitializationStatements(path, meta, loose));
+  return {
+    meta,
+    headers
+  };
+}
+
+function ensureStatementsHoisted(statements) {
+  statements.forEach(header => {
+    header._blockHoist = 3;
+  });
+}
+
+function wrapInterop(programPath, expr, type) {
+  if (type === "none") {
+    return null;
+  }
+
+  let helper;
+
+  if (type === "default") {
+    helper = "interopRequireDefault";
+  } else if (type === "namespace") {
+    helper = "interopRequireWildcard";
+  } else {
+    throw new Error(`Unknown interop: ${type}`);
+  }
+
+  return t().callExpression(programPath.hub.file.addHelper(helper), [expr]);
+}
+
+function buildNamespaceInitStatements(metadata, sourceMetadata, loose = false) {
+  const statements = [];
+  let srcNamespace = t().identifier(sourceMetadata.name);
+  if (sourceMetadata.lazy) srcNamespace = t().callExpression(srcNamespace, []);
+
+  for (var _iterator = sourceMetadata.importsNamespace, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref;
+
+    if (_isArray) {
+      if (_i >= _iterator.length) break;
+      _ref = _iterator[_i++];
+    } else {
+      _i = _iterator.next();
+      if (_i.done) break;
+      _ref = _i.value;
+    }
+
+    const localName = _ref;
+    if (localName === sourceMetadata.name) continue;
+    statements.push(_template().default.statement`var NAME = SOURCE;`({
+      NAME: localName,
+      SOURCE: t().cloneNode(srcNamespace)
+    }));
+  }
+
+  if (loose) {
+    statements.push(...buildReexportsFromMeta(metadata, sourceMetadata, loose));
+  }
+
+  for (var _iterator2 = sourceMetadata.reexportNamespace, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+    var _ref2;
+
+    if (_isArray2) {
+      if (_i2 >= _iterator2.length) break;
+      _ref2 = _iterator2[_i2++];
+    } else {
+      _i2 = _iterator2.next();
+      if (_i2.done) break;
+      _ref2 = _i2.value;
+    }
+
+    const exportName = _ref2;
+    statements.push((sourceMetadata.lazy ? _template().default.statement`
+            Object.defineProperty(EXPORTS, "NAME", {
+              enumerable: true,
+              get: function() {
+                return NAMESPACE;
+              }
+            });
+          ` : _template().default.statement`EXPORTS.NAME = NAMESPACE;`)({
+      EXPORTS: metadata.exportName,
+      NAME: exportName,
+      NAMESPACE: t().cloneNode(srcNamespace)
+    }));
+  }
+
+  if (sourceMetadata.reexportAll) {
+    const statement = buildNamespaceReexport(metadata, t().cloneNode(srcNamespace), loose);
+    statement.loc = sourceMetadata.reexportAll.loc;
+    statements.push(statement);
+  }
+
+  return statements;
+}
+
+const getTemplateForReexport = loose => {
+  return loose ? _template().default.statement`EXPORTS.EXPORT_NAME = NAMESPACE.IMPORT_NAME;` : _template().default`
+      Object.defineProperty(EXPORTS, "EXPORT_NAME", {
+        enumerable: true,
+        get: function() {
+          return NAMESPACE.IMPORT_NAME;
+        },
+      });
+    `;
+};
+
+const buildReexportsFromMeta = (meta, metadata, loose) => {
+  const namespace = metadata.lazy ? t().callExpression(t().identifier(metadata.name), []) : t().identifier(metadata.name);
+  const templateForCurrentMode = getTemplateForReexport(loose);
+  return Array.from(metadata.reexports, ([exportName, importName]) => templateForCurrentMode({
+    EXPORTS: meta.exportName,
+    EXPORT_NAME: exportName,
+    NAMESPACE: t().cloneNode(namespace),
+    IMPORT_NAME: importName
+  }));
+};
+
+function buildESModuleHeader(metadata, enumerable = false) {
+  return (enumerable ? _template().default.statement`
+        EXPORTS.__esModule = true;
+      ` : _template().default.statement`
+        Object.defineProperty(EXPORTS, "__esModule", {
+          value: true,
+        });
+      `)({
+    EXPORTS: metadata.exportName
+  });
+}
+
+function buildNamespaceReexport(metadata, namespace, loose) {
+  return (loose ? _template().default.statement`
+        Object.keys(NAMESPACE).forEach(function(key) {
+          if (key === "default" || key === "__esModule") return;
+          VERIFY_NAME_LIST;
+
+          EXPORTS[key] = NAMESPACE[key];
+        });
+      ` : _template().default.statement`
+        Object.keys(NAMESPACE).forEach(function(key) {
+          if (key === "default" || key === "__esModule") return;
+          VERIFY_NAME_LIST;
+
+          Object.defineProperty(EXPORTS, key, {
+            enumerable: true,
+            get: function() {
+              return NAMESPACE[key];
+            },
+          });
+        });
+    `)({
+    NAMESPACE: namespace,
+    EXPORTS: metadata.exportName,
+    VERIFY_NAME_LIST: metadata.exportNameListName ? _template().default`
+            if (Object.prototype.hasOwnProperty.call(EXPORTS_LIST, key)) return;
+          `({
+      EXPORTS_LIST: metadata.exportNameListName
+    }) : null
+  });
+}
+
+function buildExportNameListDeclaration(programPath, metadata) {
+  const exportedVars = Object.create(null);
+
+  for (var _iterator3 = metadata.local.values(), _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
+    var _ref3;
+
+    if (_isArray3) {
+      if (_i3 >= _iterator3.length) break;
+      _ref3 = _iterator3[_i3++];
+    } else {
+      _i3 = _iterator3.next();
+      if (_i3.done) break;
+      _ref3 = _i3.value;
+    }
+
+    const data = _ref3;
+
+    for (var _iterator5 = data.names, _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) {
+      var _ref5;
+
+      if (_isArray5) {
+        if (_i5 >= _iterator5.length) break;
+        _ref5 = _iterator5[_i5++];
+      } else {
+        _i5 = _iterator5.next();
+        if (_i5.done) break;
+        _ref5 = _i5.value;
+      }
+
+      const name = _ref5;
+      exportedVars[name] = true;
+    }
+  }
+
+  let hasReexport = false;
+
+  for (var _iterator4 = metadata.source.values(), _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
+    var _ref4;
+
+    if (_isArray4) {
+      if (_i4 >= _iterator4.length) break;
+      _ref4 = _iterator4[_i4++];
+    } else {
+      _i4 = _iterator4.next();
+      if (_i4.done) break;
+      _ref4 = _i4.value;
+    }
+
+    const data = _ref4;
+
+    for (var _iterator6 = data.reexports.keys(), _isArray6 = Array.isArray(_iterator6), _i6 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) {
+      var _ref6;
+
+      if (_isArray6) {
+        if (_i6 >= _iterator6.length) break;
+        _ref6 = _iterator6[_i6++];
+      } else {
+        _i6 = _iterator6.next();
+        if (_i6.done) break;
+        _ref6 = _i6.value;
+      }
+
+      const exportName = _ref6;
+      exportedVars[exportName] = true;
+    }
+
+    for (var _iterator7 = data.reexportNamespace, _isArray7 = Array.isArray(_iterator7), _i7 = 0, _iterator7 = _isArray7 ? _iterator7 : _iterator7[Symbol.iterator]();;) {
+      var _ref7;
+
+      if (_isArray7) {
+        if (_i7 >= _iterator7.length) break;
+        _ref7 = _iterator7[_i7++];
+      } else {
+        _i7 = _iterator7.next();
+        if (_i7.done) break;
+        _ref7 = _i7.value;
+      }
+
+      const exportName = _ref7;
+      exportedVars[exportName] = true;
+    }
+
+    hasReexport = hasReexport || data.reexportAll;
+  }
+
+  if (!hasReexport || Object.keys(exportedVars).length === 0) return null;
+  const name = programPath.scope.generateUidIdentifier("exportNames");
+  delete exportedVars.default;
+  return {
+    name: name.name,
+    statement: t().variableDeclaration("var", [t().variableDeclarator(name, t().valueToNode(exportedVars))])
+  };
+}
+
+function buildExportInitializationStatements(programPath, metadata, loose = false) {
+  const initStatements = [];
+  const exportNames = [];
+
+  for (var _iterator8 = metadata.local, _isArray8 = Array.isArray(_iterator8), _i8 = 0, _iterator8 = _isArray8 ? _iterator8 : _iterator8[Symbol.iterator]();;) {
+    var _ref8;
+
+    if (_isArray8) {
+      if (_i8 >= _iterator8.length) break;
+      _ref8 = _iterator8[_i8++];
+    } else {
+      _i8 = _iterator8.next();
+      if (_i8.done) break;
+      _ref8 = _i8.value;
+    }
+
+    const _ref10 = _ref8,
+          localName = _ref10[0],
+          data = _ref10[1];
+
+    if (data.kind === "import") {} else if (data.kind === "hoisted") {
+      initStatements.push(buildInitStatement(metadata, data.names, t().identifier(localName)));
+    } else {
+      exportNames.push(...data.names);
+    }
+  }
+
+  for (var _iterator9 = metadata.source.values(), _isArray9 = Array.isArray(_iterator9), _i9 = 0, _iterator9 = _isArray9 ? _iterator9 : _iterator9[Symbol.iterator]();;) {
+    var _ref9;
+
+    if (_isArray9) {
+      if (_i9 >= _iterator9.length) break;
+      _ref9 = _iterator9[_i9++];
+    } else {
+      _i9 = _iterator9.next();
+      if (_i9.done) break;
+      _ref9 = _i9.value;
+    }
+
+    const data = _ref9;
+
+    if (!loose) {
+      initStatements.push(...buildReexportsFromMeta(metadata, data, loose));
+    }
+
+    for (var _iterator10 = data.reexportNamespace, _isArray10 = Array.isArray(_iterator10), _i10 = 0, _iterator10 = _isArray10 ? _iterator10 : _iterator10[Symbol.iterator]();;) {
+      var _ref11;
+
+      if (_isArray10) {
+        if (_i10 >= _iterator10.length) break;
+        _ref11 = _iterator10[_i10++];
+      } else {
+        _i10 = _iterator10.next();
+        if (_i10.done) break;
+        _ref11 = _i10.value;
+      }
+
+      const exportName = _ref11;
+      exportNames.push(exportName);
+    }
+  }
+
+  initStatements.push(...(0, _chunk().default)(exportNames, 100).map(members => {
+    return buildInitStatement(metadata, members, programPath.scope.buildUndefinedNode());
+  }));
+  return initStatements;
+}
+
+function buildInitStatement(metadata, exportNames, initExpr) {
+  return t().expressionStatement(exportNames.reduce((acc, exportName) => _template().default.expression`EXPORTS.NAME = VALUE`({
+    EXPORTS: metadata.exportName,
+    NAME: exportName,
+    VALUE: acc
+  }), initExpr));
+}
\ No newline at end of file
diff --git a/node_modules/@babel/helper-module-transforms/lib/normalize-and-load-metadata.js b/node_modules/@babel/helper-module-transforms/lib/normalize-and-load-metadata.js
new file mode 100644
index 00000000..425f75df
--- /dev/null
+++ b/node_modules/@babel/helper-module-transforms/lib/normalize-and-load-metadata.js
@@ -0,0 +1,421 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hasExports = hasExports;
+exports.isSideEffectImport = isSideEffectImport;
+exports.default = normalizeModuleAndLoadMetadata;
+
+function _path() {
+  const data = require("path");
+
+  _path = function _path() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperSplitExportDeclaration() {
+  const data = _interopRequireDefault(require("@babel/helper-split-export-declaration"));
+
+  _helperSplitExportDeclaration = function _helperSplitExportDeclaration() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function hasExports(metadata) {
+  const local = metadata.local,
+        source = metadata.source;
+  return local.size > 0 || Array.from(source).some(([, meta]) => {
+    return meta.reexports.size > 0 || meta.reexportNamespace.size > 0 || !!meta.reexportAll;
+  });
+}
+
+function isSideEffectImport(source) {
+  return source.imports.size === 0 && source.importsNamespace.size === 0 && source.reexports.size === 0 && source.reexportNamespace.size === 0 && !source.reexportAll;
+}
+
+function normalizeModuleAndLoadMetadata(programPath, exportName, {
+  noInterop = false,
+  loose = false,
+  lazy = false,
+  esNamespaceOnly = false
+} = {}) {
+  if (!exportName) {
+    exportName = programPath.scope.generateUidIdentifier("exports").name;
+  }
+
+  nameAnonymousExports(programPath);
+
+  const _getModuleMetadata = getModuleMetadata(programPath, {
+    loose,
+    lazy
+  }),
+        local = _getModuleMetadata.local,
+        source = _getModuleMetadata.source;
+
+  removeModuleDeclarations(programPath);
+
+  for (var _iterator = source, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref;
+
+    if (_isArray) {
+      if (_i >= _iterator.length) break;
+      _ref = _iterator[_i++];
+    } else {
+      _i = _iterator.next();
+      if (_i.done) break;
+      _ref = _i.value;
+    }
+
+    const _ref2 = _ref,
+          metadata = _ref2[1];
+
+    if (metadata.importsNamespace.size > 0) {
+      metadata.name = metadata.importsNamespace.values().next().value;
+    }
+
+    if (noInterop) metadata.interop = "none";else if (esNamespaceOnly) {
+      if (metadata.interop === "namespace") {
+        metadata.interop = "default";
+      }
+    }
+  }
+
+  return {
+    exportName,
+    exportNameListName: null,
+    local,
+    source
+  };
+}
+
+function getModuleMetadata(programPath, {
+  loose,
+  lazy
+}) {
+  const localData = getLocalExportMetadata(programPath, loose);
+  const sourceData = new Map();
+
+  const getData = sourceNode => {
+    const source = sourceNode.value;
+    let data = sourceData.get(source);
+
+    if (!data) {
+      data = {
+        name: programPath.scope.generateUidIdentifier((0, _path().basename)(source, (0, _path().extname)(source))).name,
+        interop: "none",
+        loc: null,
+        imports: new Map(),
+        importsNamespace: new Set(),
+        reexports: new Map(),
+        reexportNamespace: new Set(),
+        reexportAll: null,
+        lazy: false
+      };
+      sourceData.set(source, data);
+    }
+
+    return data;
+  };
+
+  programPath.get("body").forEach(child => {
+    if (child.isImportDeclaration()) {
+      const data = getData(child.node.source);
+      if (!data.loc) data.loc = child.node.loc;
+      child.get("specifiers").forEach(spec => {
+        if (spec.isImportDefaultSpecifier()) {
+          const localName = spec.get("local").node.name;
+          data.imports.set(localName, "default");
+          const reexport = localData.get(localName);
+
+          if (reexport) {
+            localData.delete(localName);
+            reexport.names.forEach(name => {
+              data.reexports.set(name, "default");
+            });
+          }
+        } else if (spec.isImportNamespaceSpecifier()) {
+          const localName = spec.get("local").node.name;
+          data.importsNamespace.add(localName);
+          const reexport = localData.get(localName);
+
+          if (reexport) {
+            localData.delete(localName);
+            reexport.names.forEach(name => {
+              data.reexportNamespace.add(name);
+            });
+          }
+        } else if (spec.isImportSpecifier()) {
+          const importName = spec.get("imported").node.name;
+          const localName = spec.get("local").node.name;
+          data.imports.set(localName, importName);
+          const reexport = localData.get(localName);
+
+          if (reexport) {
+            localData.delete(localName);
+            reexport.names.forEach(name => {
+              data.reexports.set(name, importName);
+            });
+          }
+        }
+      });
+    } else if (child.isExportAllDeclaration()) {
+      const data = getData(child.node.source);
+      if (!data.loc) data.loc = child.node.loc;
+      data.reexportAll = {
+        loc: child.node.loc
+      };
+    } else if (child.isExportNamedDeclaration() && child.node.source) {
+      const data = getData(child.node.source);
+      if (!data.loc) data.loc = child.node.loc;
+      child.get("specifiers").forEach(spec => {
+        if (!spec.isExportSpecifier()) {
+          throw spec.buildCodeFrameError("Unexpected export specifier type");
+        }
+
+        const importName = spec.get("local").node.name;
+        const exportName = spec.get("exported").node.name;
+        data.reexports.set(exportName, importName);
+
+        if (exportName === "__esModule") {
+          throw exportName.buildCodeFrameError('Illegal export "__esModule".');
+        }
+      });
+    }
+  });
+
+  for (var _iterator2 = sourceData.values(), _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+    var _ref3;
+
+    if (_isArray2) {
+      if (_i2 >= _iterator2.length) break;
+      _ref3 = _iterator2[_i2++];
+    } else {
+      _i2 = _iterator2.next();
+      if (_i2.done) break;
+      _ref3 = _i2.value;
+    }
+
+    const metadata = _ref3;
+
+    if (metadata.importsNamespace.size > 0) {
+      metadata.interop = "namespace";
+      continue;
+    }
+
+    let needsDefault = false;
+    let needsNamed = false;
+
+    for (var _iterator4 = metadata.imports.values(), _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
+      var _ref5;
+
+      if (_isArray4) {
+        if (_i4 >= _iterator4.length) break;
+        _ref5 = _iterator4[_i4++];
+      } else {
+        _i4 = _iterator4.next();
+        if (_i4.done) break;
+        _ref5 = _i4.value;
+      }
+
+      const importName = _ref5;
+      if (importName === "default") needsDefault = true;else needsNamed = true;
+    }
+
+    for (var _iterator5 = metadata.reexports.values(), _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) {
+      var _ref6;
+
+      if (_isArray5) {
+        if (_i5 >= _iterator5.length) break;
+        _ref6 = _iterator5[_i5++];
+      } else {
+        _i5 = _iterator5.next();
+        if (_i5.done) break;
+        _ref6 = _i5.value;
+      }
+
+      const importName = _ref6;
+      if (importName === "default") needsDefault = true;else needsNamed = true;
+    }
+
+    if (needsDefault && needsNamed) {
+      metadata.interop = "namespace";
+    } else if (needsDefault) {
+      metadata.interop = "default";
+    }
+  }
+
+  for (var _iterator3 = sourceData, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
+    var _ref4;
+
+    if (_isArray3) {
+      if (_i3 >= _iterator3.length) break;
+      _ref4 = _iterator3[_i3++];
+    } else {
+      _i3 = _iterator3.next();
+      if (_i3.done) break;
+      _ref4 = _i3.value;
+    }
+
+    const _ref7 = _ref4,
+          source = _ref7[0],
+          metadata = _ref7[1];
+
+    if (lazy !== false && !(isSideEffectImport(metadata) || metadata.reexportAll)) {
+      if (lazy === true) {
+        metadata.lazy = !/\./.test(source);
+      } else if (Array.isArray(lazy)) {
+        metadata.lazy = lazy.indexOf(source);
+      } else if (typeof lazy === "function") {
+        metadata.lazy = lazy(source);
+      } else {
+        throw new Error(`.lazy must be a boolean, string array, or function`);
+      }
+    }
+  }
+
+  return {
+    local: localData,
+    source: sourceData
+  };
+}
+
+function getLocalExportMetadata(programPath, loose) {
+  const bindingKindLookup = new Map();
+  programPath.get("body").forEach(child => {
+    let kind;
+
+    if (child.isImportDeclaration()) {
+      kind = "import";
+    } else {
+      if (child.isExportDefaultDeclaration()) child = child.get("declaration");
+
+      if (child.isExportNamedDeclaration()) {
+        if (child.node.declaration) {
+          child = child.get("declaration");
+        } else if (loose && child.node.source && child.get("source").isStringLiteral()) {
+          child.node.specifiers.forEach(specifier => {
+            bindingKindLookup.set(specifier.local.name, "block");
+          });
+          return;
+        }
+      }
+
+      if (child.isFunctionDeclaration()) {
+        kind = "hoisted";
+      } else if (child.isClassDeclaration()) {
+        kind = "block";
+      } else if (child.isVariableDeclaration({
+        kind: "var"
+      })) {
+        kind = "var";
+      } else if (child.isVariableDeclaration()) {
+        kind = "block";
+      } else {
+        return;
+      }
+    }
+
+    Object.keys(child.getOuterBindingIdentifiers()).forEach(name => {
+      bindingKindLookup.set(name, kind);
+    });
+  });
+  const localMetadata = new Map();
+
+  const getLocalMetadata = idPath => {
+    const localName = idPath.node.name;
+    let metadata = localMetadata.get(localName);
+
+    if (!metadata) {
+      const kind = bindingKindLookup.get(localName);
+
+      if (kind === undefined) {
+        throw idPath.buildCodeFrameError(`Exporting local "${localName}", which is not declared.`);
+      }
+
+      metadata = {
+        names: [],
+        kind
+      };
+      localMetadata.set(localName, metadata);
+    }
+
+    return metadata;
+  };
+
+  programPath.get("body").forEach(child => {
+    if (child.isExportNamedDeclaration() && (loose || !child.node.source)) {
+      if (child.node.declaration) {
+        const declaration = child.get("declaration");
+        const ids = declaration.getOuterBindingIdentifierPaths();
+        Object.keys(ids).forEach(name => {
+          if (name === "__esModule") {
+            throw declaration.buildCodeFrameError('Illegal export "__esModule".');
+          }
+
+          getLocalMetadata(ids[name]).names.push(name);
+        });
+      } else {
+        child.get("specifiers").forEach(spec => {
+          const local = spec.get("local");
+          const exported = spec.get("exported");
+
+          if (exported.node.name === "__esModule") {
+            throw exported.buildCodeFrameError('Illegal export "__esModule".');
+          }
+
+          getLocalMetadata(local).names.push(exported.node.name);
+        });
+      }
+    } else if (child.isExportDefaultDeclaration()) {
+      const declaration = child.get("declaration");
+
+      if (declaration.isFunctionDeclaration() || declaration.isClassDeclaration()) {
+        getLocalMetadata(declaration.get("id")).names.push("default");
+      } else {
+        throw declaration.buildCodeFrameError("Unexpected default expression export.");
+      }
+    }
+  });
+  return localMetadata;
+}
+
+function nameAnonymousExports(programPath) {
+  programPath.get("body").forEach(child => {
+    if (!child.isExportDefaultDeclaration()) return;
+    (0, _helperSplitExportDeclaration().default)(child);
+  });
+}
+
+function removeModuleDeclarations(programPath) {
+  programPath.get("body").forEach(child => {
+    if (child.isImportDeclaration()) {
+      child.remove();
+    } else if (child.isExportNamedDeclaration()) {
+      if (child.node.declaration) {
+        child.node.declaration._blockHoist = child.node._blockHoist;
+        child.replaceWith(child.node.declaration);
+      } else {
+        child.remove();
+      }
+    } else if (child.isExportDefaultDeclaration()) {
+      const declaration = child.get("declaration");
+
+      if (declaration.isFunctionDeclaration() || declaration.isClassDeclaration()) {
+        declaration._blockHoist = child.node._blockHoist;
+        child.replaceWith(declaration);
+      } else {
+        throw declaration.buildCodeFrameError("Unexpected default expression export.");
+      }
+    } else if (child.isExportAllDeclaration()) {
+      child.remove();
+    }
+  });
+}
\ No newline at end of file
diff --git a/node_modules/@babel/helper-module-transforms/lib/rewrite-live-references.js b/node_modules/@babel/helper-module-transforms/lib/rewrite-live-references.js
new file mode 100644
index 00000000..1a02039a
--- /dev/null
+++ b/node_modules/@babel/helper-module-transforms/lib/rewrite-live-references.js
@@ -0,0 +1,327 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = rewriteLiveReferences;
+
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+
+  _assert = function _assert() {
+    return data;
+  };
+
+  return data;
+}
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _template() {
+  const data = _interopRequireDefault(require("@babel/template"));
+
+  _template = function _template() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperSimpleAccess() {
+  const data = _interopRequireDefault(require("@babel/helper-simple-access"));
+
+  _helperSimpleAccess = function _helperSimpleAccess() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function rewriteLiveReferences(programPath, metadata) {
+  const imported = new Map();
+  const exported = new Map();
+
+  const requeueInParent = path => {
+    programPath.requeue(path);
+  };
+
+  for (var _iterator = metadata.source, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref;
+
+    if (_isArray) {
+      if (_i >= _iterator.length) break;
+      _ref = _iterator[_i++];
+    } else {
+      _i = _iterator.next();
+      if (_i.done) break;
+      _ref = _i.value;
+    }
+
+    const _ref3 = _ref,
+          source = _ref3[0],
+          data = _ref3[1];
+
+    for (var _iterator3 = data.imports, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
+      var _ref4;
+
+      if (_isArray3) {
+        if (_i3 >= _iterator3.length) break;
+        _ref4 = _iterator3[_i3++];
+      } else {
+        _i3 = _iterator3.next();
+        if (_i3.done) break;
+        _ref4 = _i3.value;
+      }
+
+      const _ref6 = _ref4,
+            localName = _ref6[0],
+            importName = _ref6[1];
+      imported.set(localName, [source, importName, null]);
+    }
+
+    for (var _iterator4 = data.importsNamespace, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
+      var _ref5;
+
+      if (_isArray4) {
+        if (_i4 >= _iterator4.length) break;
+        _ref5 = _iterator4[_i4++];
+      } else {
+        _i4 = _iterator4.next();
+        if (_i4.done) break;
+        _ref5 = _i4.value;
+      }
+
+      const localName = _ref5;
+      imported.set(localName, [source, null, localName]);
+    }
+  }
+
+  for (var _iterator2 = metadata.local, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+    var _ref2;
+
+    if (_isArray2) {
+      if (_i2 >= _iterator2.length) break;
+      _ref2 = _iterator2[_i2++];
+    } else {
+      _i2 = _iterator2.next();
+      if (_i2.done) break;
+      _ref2 = _i2.value;
+    }
+
+    const _ref7 = _ref2,
+          local = _ref7[0],
+          data = _ref7[1];
+    let exportMeta = exported.get(local);
+
+    if (!exportMeta) {
+      exportMeta = [];
+      exported.set(local, exportMeta);
+    }
+
+    exportMeta.push(...data.names);
+  }
+
+  programPath.traverse(rewriteBindingInitVisitor, {
+    metadata,
+    requeueInParent,
+    scope: programPath.scope,
+    exported
+  });
+  (0, _helperSimpleAccess().default)(programPath, new Set([...Array.from(imported.keys()), ...Array.from(exported.keys())]));
+  programPath.traverse(rewriteReferencesVisitor, {
+    seen: new WeakSet(),
+    metadata,
+    requeueInParent,
+    scope: programPath.scope,
+    imported,
+    exported,
+    buildImportReference: ([source, importName, localName], identNode) => {
+      const meta = metadata.source.get(source);
+
+      if (localName) {
+        if (meta.lazy) identNode = t().callExpression(identNode, []);
+        return identNode;
+      }
+
+      let namespace = t().identifier(meta.name);
+      if (meta.lazy) namespace = t().callExpression(namespace, []);
+      return t().memberExpression(namespace, t().identifier(importName));
+    }
+  });
+}
+
+const rewriteBindingInitVisitor = {
+  ClassProperty(path) {
+    path.skip();
+  },
+
+  Function(path) {
+    path.skip();
+  },
+
+  ClassDeclaration(path) {
+    const requeueInParent = this.requeueInParent,
+          exported = this.exported,
+          metadata = this.metadata;
+    const id = path.node.id;
+    if (!id) throw new Error("Expected class to have a name");
+    const localName = id.name;
+    const exportNames = exported.get(localName) || [];
+
+    if (exportNames.length > 0) {
+      const statement = t().expressionStatement(buildBindingExportAssignmentExpression(metadata, exportNames, t().identifier(localName)));
+      statement._blockHoist = path.node._blockHoist;
+      requeueInParent(path.insertAfter(statement)[0]);
+    }
+  },
+
+  VariableDeclaration(path) {
+    const requeueInParent = this.requeueInParent,
+          exported = this.exported,
+          metadata = this.metadata;
+    Object.keys(path.getOuterBindingIdentifiers()).forEach(localName => {
+      const exportNames = exported.get(localName) || [];
+
+      if (exportNames.length > 0) {
+        const statement = t().expressionStatement(buildBindingExportAssignmentExpression(metadata, exportNames, t().identifier(localName)));
+        statement._blockHoist = path.node._blockHoist;
+        requeueInParent(path.insertAfter(statement)[0]);
+      }
+    });
+  }
+
+};
+
+const buildBindingExportAssignmentExpression = (metadata, exportNames, localExpr) => {
+  return (exportNames || []).reduce((expr, exportName) => {
+    return t().assignmentExpression("=", t().memberExpression(t().identifier(metadata.exportName), t().identifier(exportName)), expr);
+  }, localExpr);
+};
+
+const buildImportThrow = localName => {
+  return _template().default.expression.ast`
+    (function() {
+      throw new Error('"' + '${localName}' + '" is read-only.');
+    })()
+  `;
+};
+
+const rewriteReferencesVisitor = {
+  ReferencedIdentifier(path) {
+    const seen = this.seen,
+          buildImportReference = this.buildImportReference,
+          scope = this.scope,
+          imported = this.imported,
+          requeueInParent = this.requeueInParent;
+    if (seen.has(path.node)) return;
+    seen.add(path.node);
+    const localName = path.node.name;
+    const localBinding = path.scope.getBinding(localName);
+    const rootBinding = scope.getBinding(localName);
+    if (rootBinding !== localBinding) return;
+    const importData = imported.get(localName);
+
+    if (importData) {
+      const ref = buildImportReference(importData, path.node);
+      ref.loc = path.node.loc;
+
+      if (path.parentPath.isCallExpression({
+        callee: path.node
+      }) && t().isMemberExpression(ref)) {
+        path.replaceWith(t().sequenceExpression([t().numericLiteral(0), ref]));
+      } else if (path.isJSXIdentifier() && t().isMemberExpression(ref)) {
+        const object = ref.object,
+              property = ref.property;
+        path.replaceWith(t().JSXMemberExpression(t().JSXIdentifier(object.name), t().JSXIdentifier(property.name)));
+      } else {
+        path.replaceWith(ref);
+      }
+
+      requeueInParent(path);
+      path.skip();
+    }
+  },
+
+  AssignmentExpression: {
+    exit(path) {
+      const scope = this.scope,
+            seen = this.seen,
+            imported = this.imported,
+            exported = this.exported,
+            requeueInParent = this.requeueInParent,
+            buildImportReference = this.buildImportReference;
+      if (seen.has(path.node)) return;
+      seen.add(path.node);
+      const left = path.get("left");
+
+      if (left.isIdentifier()) {
+        const localName = left.node.name;
+
+        if (scope.getBinding(localName) !== path.scope.getBinding(localName)) {
+          return;
+        }
+
+        const exportedNames = exported.get(localName) || [];
+        const importData = imported.get(localName);
+
+        if (exportedNames.length > 0 || importData) {
+          (0, _assert().default)(path.node.operator === "=", "Path was not simplified");
+          const assignment = path.node;
+
+          if (importData) {
+            assignment.left = buildImportReference(importData, assignment.left);
+            assignment.right = t().sequenceExpression([assignment.right, buildImportThrow(localName)]);
+          }
+
+          path.replaceWith(buildBindingExportAssignmentExpression(this.metadata, exportedNames, assignment));
+          requeueInParent(path);
+        }
+      } else if (left.isMemberExpression()) {} else {
+        const ids = left.getOuterBindingIdentifiers();
+        const id = Object.keys(ids).filter(localName => imported.has(localName)).pop();
+
+        if (id) {
+          path.node.right = t().sequenceExpression([path.node.right, buildImportThrow(id)]);
+        }
+
+        const items = [];
+        Object.keys(ids).forEach(localName => {
+          if (scope.getBinding(localName) !== path.scope.getBinding(localName)) {
+            return;
+          }
+
+          const exportedNames = exported.get(localName) || [];
+
+          if (exportedNames.length > 0) {
+            items.push(buildBindingExportAssignmentExpression(this.metadata, exportedNames, t().identifier(localName)));
+          }
+        });
+
+        if (items.length > 0) {
+          let node = t().sequenceExpression(items);
+
+          if (path.parentPath.isExpressionStatement()) {
+            node = t().expressionStatement(node);
+            node._blockHoist = path.parentPath.node._blockHoist;
+          }
+
+          const statement = path.insertAfter(node)[0];
+          requeueInParent(statement);
+        }
+      }
+    }
+
+  }
+};
\ No newline at end of file
diff --git a/node_modules/@babel/helper-module-transforms/lib/rewrite-this.js b/node_modules/@babel/helper-module-transforms/lib/rewrite-this.js
new file mode 100644
index 00000000..e75cc39a
--- /dev/null
+++ b/node_modules/@babel/helper-module-transforms/lib/rewrite-this.js
@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = rewriteThis;
+
+function rewriteThis(programPath) {
+  programPath.traverse(rewriteThisVisitor);
+}
+
+const rewriteThisVisitor = {
+  ThisExpression(path) {
+    path.replaceWith(path.scope.buildUndefinedNode());
+  },
+
+  Function(path) {
+    if (!path.isArrowFunctionExpression()) path.skip();
+  },
+
+  ClassProperty(path) {
+    path.skip();
+  }
+
+};
\ No newline at end of file
diff --git a/node_modules/@babel/helper-module-transforms/package.json b/node_modules/@babel/helper-module-transforms/package.json
new file mode 100644
index 00000000..4133dd0d
--- /dev/null
+++ b/node_modules/@babel/helper-module-transforms/package.json
@@ -0,0 +1,18 @@
+{
+  "name": "@babel/helper-module-transforms",
+  "version": "7.0.0-beta.47",
+  "description": "Babel helper functions for implementing ES6 module transformations",
+  "author": "Logan Smyth <loganfsmyth@gmail.com>",
+  "homepage": "https://babeljs.io/",
+  "license": "MIT",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-helper-module-transforms",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/helper-module-imports": "7.0.0-beta.47",
+    "@babel/helper-simple-access": "7.0.0-beta.47",
+    "@babel/helper-split-export-declaration": "7.0.0-beta.47",
+    "@babel/template": "7.0.0-beta.47",
+    "@babel/types": "7.0.0-beta.47",
+    "lodash": "^4.17.5"
+  }
+}
diff --git a/node_modules/@babel/helper-optimise-call-expression/README.md b/node_modules/@babel/helper-optimise-call-expression/README.md
new file mode 100644
index 00000000..3a35872e
--- /dev/null
+++ b/node_modules/@babel/helper-optimise-call-expression/README.md
@@ -0,0 +1,5 @@
+# @babel/helper-optimise-call-expression
+
+## Usage
+
+TODO
diff --git a/node_modules/@babel/helper-optimise-call-expression/lib/index.js b/node_modules/@babel/helper-optimise-call-expression/lib/index.js
new file mode 100644
index 00000000..f2f2e58e
--- /dev/null
+++ b/node_modules/@babel/helper-optimise-call-expression/lib/index.js
@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _default(callee, thisNode, args) {
+  if (args.length === 1 && t().isSpreadElement(args[0]) && t().isIdentifier(args[0].argument, {
+    name: "arguments"
+  })) {
+    return t().callExpression(t().memberExpression(callee, t().identifier("apply")), [thisNode, args[0].argument]);
+  } else {
+    return t().callExpression(t().memberExpression(callee, t().identifier("call")), [thisNode, ...args]);
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/helper-optimise-call-expression/package.json b/node_modules/@babel/helper-optimise-call-expression/package.json
new file mode 100644
index 00000000..c9583053
--- /dev/null
+++ b/node_modules/@babel/helper-optimise-call-expression/package.json
@@ -0,0 +1,11 @@
+{
+  "name": "@babel/helper-optimise-call-expression",
+  "version": "7.0.0-beta.47",
+  "description": "Helper function to optimise call expression",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-helper-optimise-call-expression",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/types": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/helper-plugin-utils/lib/index.js b/node_modules/@babel/helper-plugin-utils/lib/index.js
new file mode 100644
index 00000000..adb0656f
--- /dev/null
+++ b/node_modules/@babel/helper-plugin-utils/lib/index.js
@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.declare = declare;
+
+function declare(builder) {
+  return (api, options, dirname) => {
+    if (!api.assertVersion) {
+      api = Object.assign(copyApiObject(api), {
+        assertVersion(range) {
+          throwVersionError(range, api.version);
+        }
+
+      });
+    }
+
+    return builder(api, options || {}, dirname);
+  };
+}
+
+function copyApiObject(api) {
+  let proto = null;
+
+  if (typeof api.version === "string" && /^7\./.test(api.version)) {
+    proto = Object.getPrototypeOf(api);
+
+    if (proto && (!has(proto, "version") || !has(proto, "transform") || !has(proto, "template") || !has(proto, "types"))) {
+      proto = null;
+    }
+  }
+
+  return Object.assign({}, proto, api);
+}
+
+function has(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+function throwVersionError(range, version) {
+  if (typeof range === "number") {
+    if (!Number.isInteger(range)) {
+      throw new Error("Expected string or integer value.");
+    }
+
+    range = `^${range}.0.0-0`;
+  }
+
+  if (typeof range !== "string") {
+    throw new Error("Expected string or integer value.");
+  }
+
+  const limit = Error.stackTraceLimit;
+
+  if (typeof limit === "number" && limit < 25) {
+    Error.stackTraceLimit = 25;
+  }
+
+  let err;
+
+  if (version.slice(0, 2) === "7.") {
+    err = new Error(`Requires Babel "^7.0.0-beta.41", but was loaded with "${version}". ` + `You'll need to update your @babel/core version.`);
+  } else {
+    err = new Error(`Requires Babel "${range}", but was loaded with "${version}". ` + `If you are sure you have a compatible version of @babel/core, ` + `it is likely that something in your build process is loading the ` + `wrong version. Inspect the stack trace of this error to look for ` + `the first entry that doesn't mention "@babel/core" or "babel-core" ` + `to see what is calling Babel.`);
+  }
+
+  if (typeof limit === "number") {
+    Error.stackTraceLimit = limit;
+  }
+
+  throw Object.assign(err, {
+    code: "BABEL_VERSION_UNSUPPORTED",
+    version,
+    range
+  });
+}
\ No newline at end of file
diff --git a/node_modules/@babel/helper-plugin-utils/package.json b/node_modules/@babel/helper-plugin-utils/package.json
new file mode 100644
index 00000000..c1042d45
--- /dev/null
+++ b/node_modules/@babel/helper-plugin-utils/package.json
@@ -0,0 +1,10 @@
+{
+  "name": "@babel/helper-plugin-utils",
+  "version": "7.0.0-beta.47",
+  "description": "General utilities for plugins to use",
+  "author": "Logan Smyth <loganfsmyth@gmail.com>",
+  "homepage": "https://babeljs.io/",
+  "license": "MIT",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-helper-plugin-utils",
+  "main": "lib/index.js"
+}
diff --git a/node_modules/@babel/helper-plugin-utils/src/README.md b/node_modules/@babel/helper-plugin-utils/src/README.md
new file mode 100644
index 00000000..4079c2d4
--- /dev/null
+++ b/node_modules/@babel/helper-plugin-utils/src/README.md
@@ -0,0 +1,41 @@
+# @babel/helper-plugin-utils
+
+The intention of this module is to provide a place for us to expose a
+standardized API layer over top of what Babel's core API provides on its own.
+
+This is not aiming to implement APIs that are missing on a given Babel version,
+but it is means to provide clear error messages if a plugin is run on a version
+of Babel that doesn't have the APIs that the plugin is trying to use.
+
+Every one of Babel's core plugins and presets will use this module, and ideally
+because of that its size should be kept to a miminum because this may or may
+not be deduplicated when installed.
+
+
+## Usage
+
+```js
+import { declare } from "@babel/helper-plugin-utils";
+
+export default declare((api, options, dirname) => {
+  return {};
+});
+```
+
+
+## What this does
+
+Currently, this plugin provides a few services to ensure that plugins function
+well-enough to throw useful errors.
+
+### `options` is always passed
+
+Babel 6 does not pass a second parameter. This frequently means that plugins
+written for Babel 7 that use `options` will attempt to destructure options
+out of an `undefined` value. By supplying the default, we avoid that risk.
+
+### `api.assertVersion` always exists
+
+Babel 6 and early betas of Babel 7 do not have `assertVersion`, so this
+wrapper ensures that it exists and throws a useful error message when not
+supplied by Babel itself.
diff --git a/node_modules/@babel/helper-plugin-utils/src/index.js b/node_modules/@babel/helper-plugin-utils/src/index.js
new file mode 100644
index 00000000..f0ecb83a
--- /dev/null
+++ b/node_modules/@babel/helper-plugin-utils/src/index.js
@@ -0,0 +1,95 @@
+export function declare(builder) {
+  return (api, options, dirname) => {
+    if (!api.assertVersion) {
+      // Inject a custom version of 'assertVersion' for Babel 6 and early
+      // versions of Babel 7's beta that didn't have it.
+      api = Object.assign(copyApiObject(api), {
+        assertVersion(range) {
+          throwVersionError(range, api.version);
+        },
+      });
+    }
+
+    return builder(api, options || {}, dirname);
+  };
+}
+
+function copyApiObject(api) {
+  // Babel >= 7 <= beta.41 passed the API as a new object that had
+  // babel/core as the prototype. While slightly faster, it also
+  // means that the Object.assign copy below fails. Rather than
+  // keep complexity, the Babel 6 behavior has been reverted and this
+  // normalizes all that for Babel 7.
+  let proto = null;
+  if (typeof api.version === "string" && /^7\./.test(api.version)) {
+    proto = Object.getPrototypeOf(api);
+    if (
+      proto &&
+      (!has(proto, "version") ||
+        !has(proto, "transform") ||
+        !has(proto, "template") ||
+        !has(proto, "types"))
+    ) {
+      proto = null;
+    }
+  }
+
+  return {
+    ...proto,
+    ...api,
+  };
+}
+
+function has(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+function throwVersionError(range, version) {
+  if (typeof range === "number") {
+    if (!Number.isInteger(range)) {
+      throw new Error("Expected string or integer value.");
+    }
+    range = `^${range}.0.0-0`;
+  }
+  if (typeof range !== "string") {
+    throw new Error("Expected string or integer value.");
+  }
+
+  const limit = Error.stackTraceLimit;
+
+  if (typeof limit === "number" && limit < 25) {
+    // Bump up the limit if needed so that users are more likely
+    // to be able to see what is calling Babel.
+    Error.stackTraceLimit = 25;
+  }
+
+  let err;
+  if (version.slice(0, 2) === "7.") {
+    err = new Error(
+      `Requires Babel "^7.0.0-beta.41", but was loaded with "${version}". ` +
+        `You'll need to update your @babel/core version.`,
+    );
+  } else {
+    err = new Error(
+      `Requires Babel "${range}", but was loaded with "${version}". ` +
+        `If you are sure you have a compatible version of @babel/core, ` +
+        `it is likely that something in your build process is loading the ` +
+        `wrong version. Inspect the stack trace of this error to look for ` +
+        `the first entry that doesn't mention "@babel/core" or "babel-core" ` +
+        `to see what is calling Babel.`,
+    );
+  }
+
+  if (typeof limit === "number") {
+    Error.stackTraceLimit = limit;
+  }
+
+  throw Object.assign(
+    err,
+    ({
+      code: "BABEL_VERSION_UNSUPPORTED",
+      version,
+      range,
+    }: any),
+  );
+}
diff --git a/node_modules/@babel/helper-regex/README.md b/node_modules/@babel/helper-regex/README.md
new file mode 100644
index 00000000..d66d094a
--- /dev/null
+++ b/node_modules/@babel/helper-regex/README.md
@@ -0,0 +1,5 @@
+# @babel/helper-regex
+
+## Usage
+
+TODO
diff --git a/node_modules/@babel/helper-regex/lib/index.js b/node_modules/@babel/helper-regex/lib/index.js
new file mode 100644
index 00000000..3b731567
--- /dev/null
+++ b/node_modules/@babel/helper-regex/lib/index.js
@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.is = is;
+exports.pullFlag = pullFlag;
+
+function _pull() {
+  const data = _interopRequireDefault(require("lodash/pull"));
+
+  _pull = function _pull() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function is(node, flag) {
+  return node.type === "RegExpLiteral" && node.flags.indexOf(flag) >= 0;
+}
+
+function pullFlag(node, flag) {
+  const flags = node.flags.split("");
+  if (node.flags.indexOf(flag) < 0) return;
+  (0, _pull().default)(flags, flag);
+  node.flags = flags.join("");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/helper-regex/package.json b/node_modules/@babel/helper-regex/package.json
new file mode 100644
index 00000000..1ff10ee7
--- /dev/null
+++ b/node_modules/@babel/helper-regex/package.json
@@ -0,0 +1,11 @@
+{
+  "name": "@babel/helper-regex",
+  "version": "7.0.0-beta.47",
+  "description": "Helper function to check for literal RegEx",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-helper-regex",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "dependencies": {
+    "lodash": "^4.17.5"
+  }
+}
diff --git a/node_modules/@babel/helper-remap-async-to-generator/README.md b/node_modules/@babel/helper-remap-async-to-generator/README.md
new file mode 100644
index 00000000..d1d6ca65
--- /dev/null
+++ b/node_modules/@babel/helper-remap-async-to-generator/README.md
@@ -0,0 +1,5 @@
+# @babel/helper-remap-async-to-generator
+
+## Usage
+
+TODO
diff --git a/node_modules/@babel/helper-remap-async-to-generator/lib/index.js b/node_modules/@babel/helper-remap-async-to-generator/lib/index.js
new file mode 100644
index 00000000..8fa634c8
--- /dev/null
+++ b/node_modules/@babel/helper-remap-async-to-generator/lib/index.js
@@ -0,0 +1,96 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+function _helperWrapFunction() {
+  const data = _interopRequireDefault(require("@babel/helper-wrap-function"));
+
+  _helperWrapFunction = function _helperWrapFunction() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperAnnotateAsPure() {
+  const data = _interopRequireDefault(require("@babel/helper-annotate-as-pure"));
+
+  _helperAnnotateAsPure = function _helperAnnotateAsPure() {
+    return data;
+  };
+
+  return data;
+}
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const awaitVisitor = {
+  Function(path) {
+    path.skip();
+  },
+
+  AwaitExpression(path, {
+    wrapAwait
+  }) {
+    const argument = path.get("argument");
+
+    if (path.parentPath.isYieldExpression()) {
+      path.replaceWith(argument.node);
+      return;
+    }
+
+    path.replaceWith(t().yieldExpression(wrapAwait ? t().callExpression(t().cloneNode(wrapAwait), [argument.node]) : argument.node));
+  }
+
+};
+
+function _default(path, helpers) {
+  path.traverse(awaitVisitor, {
+    wrapAwait: helpers.wrapAwait
+  });
+  const isIIFE = checkIsIIFE(path);
+  path.node.async = false;
+  path.node.generator = true;
+  (0, _helperWrapFunction().default)(path, t().cloneNode(helpers.wrapAsync));
+  const isProperty = path.isObjectMethod() || path.isClassMethod() || path.parentPath.isObjectProperty() || path.parentPath.isClassProperty();
+
+  if (!isProperty && !isIIFE && path.isExpression()) {
+    (0, _helperAnnotateAsPure().default)(path);
+  }
+
+  function checkIsIIFE(path) {
+    if (path.parentPath.isCallExpression({
+      callee: path.node
+    })) {
+      return true;
+    }
+
+    const parentPath = path.parentPath;
+
+    if (parentPath.isMemberExpression() && t().isIdentifier(parentPath.node.property, {
+      name: "bind"
+    })) {
+      const bindCall = parentPath.parentPath;
+      return bindCall.isCallExpression() && bindCall.node.arguments.length === 1 && t().isThisExpression(bindCall.node.arguments[0]) && bindCall.parentPath.isCallExpression({
+        callee: bindCall.node
+      });
+    }
+
+    return false;
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/helper-remap-async-to-generator/package.json b/node_modules/@babel/helper-remap-async-to-generator/package.json
new file mode 100644
index 00000000..f5c4f809
--- /dev/null
+++ b/node_modules/@babel/helper-remap-async-to-generator/package.json
@@ -0,0 +1,15 @@
+{
+  "name": "@babel/helper-remap-async-to-generator",
+  "version": "7.0.0-beta.47",
+  "description": "Helper function to remap async functions to generators",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-helper-remap-async-to-generator",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/helper-annotate-as-pure": "7.0.0-beta.47",
+    "@babel/helper-wrap-function": "7.0.0-beta.47",
+    "@babel/template": "7.0.0-beta.47",
+    "@babel/traverse": "7.0.0-beta.47",
+    "@babel/types": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/helper-replace-supers/README.md b/node_modules/@babel/helper-replace-supers/README.md
new file mode 100644
index 00000000..4c259e53
--- /dev/null
+++ b/node_modules/@babel/helper-replace-supers/README.md
@@ -0,0 +1,5 @@
+# @babel/helper-replace-supers
+
+## Usage
+
+TODO
diff --git a/node_modules/@babel/helper-replace-supers/lib/index.js b/node_modules/@babel/helper-replace-supers/lib/index.js
new file mode 100644
index 00000000..e3e6bef4
--- /dev/null
+++ b/node_modules/@babel/helper-replace-supers/lib/index.js
@@ -0,0 +1,246 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.environmentVisitor = void 0;
+
+function _traverse() {
+  const data = _interopRequireDefault(require("@babel/traverse"));
+
+  _traverse = function _traverse() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperMemberExpressionToFunctions() {
+  const data = _interopRequireDefault(require("@babel/helper-member-expression-to-functions"));
+
+  _helperMemberExpressionToFunctions = function _helperMemberExpressionToFunctions() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperOptimiseCallExpression() {
+  const data = _interopRequireDefault(require("@babel/helper-optimise-call-expression"));
+
+  _helperOptimiseCallExpression = function _helperOptimiseCallExpression() {
+    return data;
+  };
+
+  return data;
+}
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function getPrototypeOfExpression(objectRef, isStatic, file) {
+  objectRef = t().cloneNode(objectRef);
+  const targetRef = isStatic ? objectRef : t().memberExpression(objectRef, t().identifier("prototype"));
+  return t().callExpression(file.addHelper("getPrototypeOf"), [targetRef]);
+}
+
+function skipAllButComputedKey(path) {
+  if (!path.node.computed) {
+    path.skip();
+    return;
+  }
+
+  const keys = t().VISITOR_KEYS[path.type];
+
+  for (var _iterator = keys, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref;
+
+    if (_isArray) {
+      if (_i >= _iterator.length) break;
+      _ref = _iterator[_i++];
+    } else {
+      _i = _iterator.next();
+      if (_i.done) break;
+      _ref = _i.value;
+    }
+
+    const key = _ref;
+    if (key !== "key") path.skipKey(key);
+  }
+}
+
+const environmentVisitor = {
+  Function(path) {
+    if (path.isMethod()) return;
+    if (path.isArrowFunctionExpression()) return;
+    path.skip();
+  },
+
+  Method(path) {
+    skipAllButComputedKey(path);
+  },
+
+  "ClassProperty|ClassPrivateProperty"(path) {
+    if (path.node.static) return;
+    skipAllButComputedKey(path);
+  }
+
+};
+exports.environmentVisitor = environmentVisitor;
+
+const visitor = _traverse().default.visitors.merge([environmentVisitor, {
+  Super(path, state) {
+    const node = path.node,
+          parentPath = path.parentPath;
+    if (!parentPath.isMemberExpression({
+      object: node
+    })) return;
+    state.handle(parentPath);
+  }
+
+}]);
+
+const memoized = new WeakMap();
+const specHandlers = {
+  memoize(superMember) {
+    const scope = superMember.scope,
+          node = superMember.node;
+    const computed = node.computed,
+          property = node.property;
+
+    if (!computed) {
+      return;
+    }
+
+    const memo = scope.maybeGenerateMemoised(property);
+
+    if (!memo) {
+      return;
+    }
+
+    memoized.set(property, memo);
+  },
+
+  get(superMember) {
+    const _superMember$node = superMember.node,
+          computed = _superMember$node.computed,
+          property = _superMember$node.property;
+    const thisExpr = t().thisExpression();
+    let prop;
+
+    if (computed && memoized.has(property)) {
+      prop = t().cloneNode(memoized.get(property));
+    } else {
+      prop = computed ? property : t().stringLiteral(property.name);
+    }
+
+    return t().callExpression(this.file.addHelper("get"), [getPrototypeOfExpression(this.getObjectRef(), this.isStatic, this.file), prop, thisExpr]);
+  },
+
+  set(superMember, value) {
+    const _superMember$node2 = superMember.node,
+          computed = _superMember$node2.computed,
+          property = _superMember$node2.property;
+    let prop;
+
+    if (computed && memoized.has(property)) {
+      prop = t().assignmentExpression("=", t().cloneNode(memoized.get(property)), property);
+    } else {
+      prop = computed ? property : t().stringLiteral(property.name);
+    }
+
+    return t().callExpression(this.file.addHelper("set"), [getPrototypeOfExpression(this.getObjectRef(), this.isStatic, this.file), prop, value, t().thisExpression(), t().booleanLiteral(superMember.isInStrictMode())]);
+  },
+
+  call(superMember, args) {
+    return (0, _helperOptimiseCallExpression().default)(this.get(superMember), t().thisExpression(), args);
+  }
+
+};
+const looseHandlers = {
+  memoize: specHandlers.memoize,
+  call: specHandlers.call,
+
+  get(superMember) {
+    const isStatic = this.isStatic,
+          superRef = this.superRef;
+    const _superMember$node3 = superMember.node,
+          property = _superMember$node3.property,
+          computed = _superMember$node3.computed;
+    let object;
+
+    if (isStatic) {
+      object = superRef ? t().cloneNode(superRef) : t().memberExpression(t().identifier("Function"), t().identifier("prototype"));
+    } else {
+      object = superRef ? t().memberExpression(t().cloneNode(superRef), t().identifier("prototype")) : t().memberExpression(t().identifier("Object"), t().identifier("prototype"));
+    }
+
+    let prop;
+
+    if (computed && memoized.has(property)) {
+      prop = t().cloneNode(memoized.get(property));
+    } else {
+      prop = property;
+    }
+
+    return t().memberExpression(object, prop, computed);
+  },
+
+  set(superMember, value) {
+    const _superMember$node4 = superMember.node,
+          property = _superMember$node4.property,
+          computed = _superMember$node4.computed;
+    let prop;
+
+    if (computed && memoized.has(property)) {
+      prop = t().assignmentExpression("=", t().cloneNode(memoized.get(property)), property);
+    } else {
+      prop = property;
+    }
+
+    return t().assignmentExpression("=", t().memberExpression(t().thisExpression(), prop, computed), value);
+  }
+
+};
+
+class ReplaceSupers {
+  constructor(opts) {
+    const path = opts.methodPath;
+    this.methodPath = path;
+    this.isStatic = path.isClassMethod({
+      static: true
+    }) || path.isObjectMethod();
+    this.file = opts.file;
+    this.superRef = opts.superRef;
+    this.isLoose = opts.isLoose;
+    this.opts = opts;
+  }
+
+  getObjectRef() {
+    return t().cloneNode(this.opts.objectRef || this.opts.getObjectRef());
+  }
+
+  replace() {
+    const handler = this.isLoose ? looseHandlers : specHandlers;
+    (0, _helperMemberExpressionToFunctions().default)(this.methodPath, visitor, Object.assign({
+      file: this.file,
+      isStatic: this.isStatic,
+      getObjectRef: this.getObjectRef.bind(this),
+      superRef: this.superRef
+    }, handler));
+  }
+
+}
+
+exports.default = ReplaceSupers;
\ No newline at end of file
diff --git a/node_modules/@babel/helper-replace-supers/package.json b/node_modules/@babel/helper-replace-supers/package.json
new file mode 100644
index 00000000..ae6964a5
--- /dev/null
+++ b/node_modules/@babel/helper-replace-supers/package.json
@@ -0,0 +1,14 @@
+{
+  "name": "@babel/helper-replace-supers",
+  "version": "7.0.0-beta.47",
+  "description": "Helper function to replace supers",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-helper-replace-supers",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/helper-member-expression-to-functions": "7.0.0-beta.47",
+    "@babel/helper-optimise-call-expression": "7.0.0-beta.47",
+    "@babel/traverse": "7.0.0-beta.47",
+    "@babel/types": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/helper-simple-access/README.md b/node_modules/@babel/helper-simple-access/README.md
new file mode 100644
index 00000000..81660daf
--- /dev/null
+++ b/node_modules/@babel/helper-simple-access/README.md
@@ -0,0 +1,26 @@
+# @babel/helper-simple-assignment
+
+There are many cases where it is hard to perform transformations because a
+piece of code is using complex structures. Say you want to rewrite all accesses
+to a given variable, and there are cases like
+
+```
+i += 1
+--i;
+```
+
+It is difficult to work with.
+
+This helper can handle converting these to simple access patterns of standard
+assignment. This plugin does _not_ handle
+
+```
+{ a } = foo;
+```
+
+so assignment to patterns still needs to be handled when you are processing
+updates to values.
+
+## Usage
+
+TODO
diff --git a/node_modules/@babel/helper-simple-access/lib/index.js b/node_modules/@babel/helper-simple-access/lib/index.js
new file mode 100644
index 00000000..bb227456
--- /dev/null
+++ b/node_modules/@babel/helper-simple-access/lib/index.js
@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = simplifyAccess;
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function simplifyAccess(path, bindingNames) {
+  path.traverse(simpleAssignmentVisitor, {
+    scope: path.scope,
+    bindingNames,
+    seen: new WeakSet()
+  });
+}
+
+const simpleAssignmentVisitor = {
+  UpdateExpression: {
+    exit(path) {
+      const scope = this.scope,
+            bindingNames = this.bindingNames;
+      const arg = path.get("argument");
+      if (!arg.isIdentifier()) return;
+      const localName = arg.node.name;
+      if (!bindingNames.has(localName)) return;
+
+      if (scope.getBinding(localName) !== path.scope.getBinding(localName)) {
+        return;
+      }
+
+      if (path.parentPath.isExpressionStatement() && !path.isCompletionRecord()) {
+        const operator = path.node.operator == "++" ? "+=" : "-=";
+        path.replaceWith(t().assignmentExpression(operator, arg.node, t().numericLiteral(1)));
+      } else if (path.node.prefix) {
+        path.replaceWith(t().assignmentExpression("=", t().identifier(localName), t().binaryExpression(path.node.operator[0], t().unaryExpression("+", arg.node), t().numericLiteral(1))));
+      } else {
+        const old = path.scope.generateUidIdentifierBasedOnNode(arg.node, "old");
+        const varName = old.name;
+        path.scope.push({
+          id: old
+        });
+        const binary = t().binaryExpression(path.node.operator[0], t().identifier(varName), t().numericLiteral(1));
+        path.replaceWith(t().sequenceExpression([t().assignmentExpression("=", t().identifier(varName), t().unaryExpression("+", arg.node)), t().assignmentExpression("=", t().cloneNode(arg.node), binary), t().identifier(varName)]));
+      }
+    }
+
+  },
+  AssignmentExpression: {
+    exit(path) {
+      const scope = this.scope,
+            seen = this.seen,
+            bindingNames = this.bindingNames;
+      if (path.node.operator === "=") return;
+      if (seen.has(path.node)) return;
+      seen.add(path.node);
+      const left = path.get("left");
+      if (!left.isIdentifier()) return;
+      const localName = left.node.name;
+      if (!bindingNames.has(localName)) return;
+
+      if (scope.getBinding(localName) !== path.scope.getBinding(localName)) {
+        return;
+      }
+
+      path.node.right = t().binaryExpression(path.node.operator.slice(0, -1), t().cloneNode(path.node.left), path.node.right);
+      path.node.operator = "=";
+    }
+
+  }
+};
\ No newline at end of file
diff --git a/node_modules/@babel/helper-simple-access/package.json b/node_modules/@babel/helper-simple-access/package.json
new file mode 100644
index 00000000..0a01c724
--- /dev/null
+++ b/node_modules/@babel/helper-simple-access/package.json
@@ -0,0 +1,15 @@
+{
+  "name": "@babel/helper-simple-access",
+  "version": "7.0.0-beta.47",
+  "description": "Babel helper for ensuring that access to a given value is performed through simple accesses",
+  "author": "Logan Smyth <loganfsmyth@gmail.com>",
+  "homepage": "https://babeljs.io/",
+  "license": "MIT",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-helper-simple-access",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/template": "7.0.0-beta.47",
+    "@babel/types": "7.0.0-beta.47",
+    "lodash": "^4.17.5"
+  }
+}
diff --git a/node_modules/@babel/helper-split-export-declaration/README.md b/node_modules/@babel/helper-split-export-declaration/README.md
new file mode 100644
index 00000000..195f151e
--- /dev/null
+++ b/node_modules/@babel/helper-split-export-declaration/README.md
@@ -0,0 +1,23 @@
+# @babel/helper-split-export-declaration
+
+## API
+
+```js
+declare export default splitExportDeclaration(path: NodePath);
+```
+
+## Usage
+
+```js
+import traverse from "@babel/traverse";
+import splitExportDeclaration from "@babel/helper-split-export-declaration";
+
+// ...
+
+traverse(file, {
+  ExportDefaultDeclaration(path) {
+    if (!path.get("declaration").isClassDeclaration()) return;
+    splitExportDeclaration(path);
+  },
+});
+```
diff --git a/node_modules/@babel/helper-split-export-declaration/lib/index.js b/node_modules/@babel/helper-split-export-declaration/lib/index.js
new file mode 100644
index 00000000..8cffb19b
--- /dev/null
+++ b/node_modules/@babel/helper-split-export-declaration/lib/index.js
@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = splitExportDeclaration;
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function splitExportDeclaration(exportDeclaration) {
+  if (!exportDeclaration.isExportDeclaration()) {
+    throw new Error("Only export declarations can be splitted.");
+  }
+
+  const isDefault = exportDeclaration.isExportDefaultDeclaration();
+  const declaration = exportDeclaration.get("declaration");
+  const isClassDeclaration = declaration.isClassDeclaration();
+
+  if (isDefault) {
+    const standaloneDeclaration = declaration.isFunctionDeclaration() || isClassDeclaration;
+    const scope = declaration.isScope() ? declaration.scope.parent : declaration.scope;
+    let id = declaration.node.id;
+    let needBindingRegistration = false;
+
+    if (!id) {
+      needBindingRegistration = true;
+      id = scope.generateUidIdentifier("default");
+
+      if (standaloneDeclaration || declaration.isFunctionExpression() || declaration.isClassExpression()) {
+        declaration.node.id = t().cloneNode(id);
+      }
+    }
+
+    const updatedDeclaration = standaloneDeclaration ? declaration : t().variableDeclaration("var", [t().variableDeclarator(t().cloneNode(id), declaration.node)]);
+    const updatedExportDeclaration = t().exportNamedDeclaration(null, [t().exportSpecifier(t().cloneNode(id), t().identifier("default"))]);
+    exportDeclaration.insertAfter(updatedExportDeclaration);
+    exportDeclaration.replaceWith(updatedDeclaration);
+
+    if (needBindingRegistration) {
+      scope.registerBinding(isClassDeclaration ? "let" : "var", exportDeclaration);
+    }
+
+    return exportDeclaration;
+  }
+
+  if (exportDeclaration.get("specifiers").length > 0) {
+    throw new Error("It doesn't make sense to split exported specifiers.");
+  }
+
+  const bindingIdentifiers = declaration.getOuterBindingIdentifiers();
+  const specifiers = Object.keys(bindingIdentifiers).map(name => {
+    return t().exportSpecifier(t().identifier(name), t().identifier(name));
+  });
+  const aliasDeclar = t().exportNamedDeclaration(null, specifiers);
+  exportDeclaration.insertAfter(aliasDeclar);
+  exportDeclaration.replaceWith(declaration.node);
+  return exportDeclaration;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/helper-split-export-declaration/package.json b/node_modules/@babel/helper-split-export-declaration/package.json
new file mode 100644
index 00000000..9f9db79d
--- /dev/null
+++ b/node_modules/@babel/helper-split-export-declaration/package.json
@@ -0,0 +1,11 @@
+{
+  "name": "@babel/helper-split-export-declaration",
+  "version": "7.0.0-beta.47",
+  "description": "",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-helper-split-export-declaration",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/types": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/helper-wrap-function/README.md b/node_modules/@babel/helper-wrap-function/README.md
new file mode 100644
index 00000000..25b7eaa2
--- /dev/null
+++ b/node_modules/@babel/helper-wrap-function/README.md
@@ -0,0 +1,27 @@
+# @babel/helper-wrap-function
+
+This helper wraps a function within a call expression. It works with any function: statements, expressions and methods; both named and anonymous.
+
+## Example
+
+**In**
+
+```js
+(function () {
+}());
+```
+
+**Out**
+
+```js
+_wrapper(function () {
+})();
+```
+
+## Usage
+
+```js
+import wrapFunction from "@babel/helper-wrap-function";
+
+wrapFunction(nodePathOfTheFunction, nodeWhichReferencesToTheWrapper);
+```
diff --git a/node_modules/@babel/helper-wrap-function/lib/index.js b/node_modules/@babel/helper-wrap-function/lib/index.js
new file mode 100644
index 00000000..953654c7
--- /dev/null
+++ b/node_modules/@babel/helper-wrap-function/lib/index.js
@@ -0,0 +1,132 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = wrapFunction;
+
+function _helperFunctionName() {
+  const data = _interopRequireDefault(require("@babel/helper-function-name"));
+
+  _helperFunctionName = function _helperFunctionName() {
+    return data;
+  };
+
+  return data;
+}
+
+function _template() {
+  const data = _interopRequireDefault(require("@babel/template"));
+
+  _template = function _template() {
+    return data;
+  };
+
+  return data;
+}
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const buildExpressionWrapper = _template().default.expression(`
+  (function () {
+    var REF = FUNCTION;
+    return function NAME(PARAMS) {
+      return REF.apply(this, arguments);
+    };
+  })()
+`);
+
+const buildDeclarationWrapper = (0, _template().default)(`
+  function NAME(PARAMS) { return REF.apply(this, arguments); }
+  function REF() {
+    REF = FUNCTION;
+    return REF.apply(this, arguments);
+  }
+`);
+
+function classOrObjectMethod(path, callId) {
+  const node = path.node;
+  const body = node.body;
+  const container = t().functionExpression(null, [], t().blockStatement(body.body), true);
+  body.body = [t().returnStatement(t().callExpression(t().callExpression(callId, [container]), []))];
+  node.async = false;
+  node.generator = false;
+  path.get("body.body.0.argument.callee.arguments.0").unwrapFunctionEnvironment();
+}
+
+function plainFunction(path, callId) {
+  const node = path.node;
+  const isDeclaration = path.isFunctionDeclaration();
+  const functionId = node.id;
+  const wrapper = isDeclaration ? buildDeclarationWrapper : buildExpressionWrapper;
+
+  if (path.isArrowFunctionExpression()) {
+    path.arrowFunctionToExpression();
+  }
+
+  node.id = null;
+
+  if (isDeclaration) {
+    node.type = "FunctionExpression";
+  }
+
+  const built = t().callExpression(callId, [node]);
+  const container = wrapper({
+    NAME: functionId || null,
+    REF: path.scope.generateUidIdentifier(functionId ? functionId.name : "ref"),
+    FUNCTION: built,
+    PARAMS: node.params.reduce((acc, param) => {
+      acc.done = acc.done || t().isAssignmentPattern(param) || t().isRestElement(param);
+
+      if (!acc.done) {
+        acc.params.push(path.scope.generateUidIdentifier("x"));
+      }
+
+      return acc;
+    }, {
+      params: [],
+      done: false
+    }).params
+  });
+
+  if (isDeclaration) {
+    path.replaceWith(container[0]);
+    path.insertAfter(container[1]);
+  } else {
+    const retFunction = container.callee.body.body[1].argument;
+
+    if (!functionId) {
+      (0, _helperFunctionName().default)({
+        node: retFunction,
+        parent: path.parent,
+        scope: path.scope
+      });
+    }
+
+    if (!retFunction || retFunction.id || node.params.length) {
+      path.replaceWith(container);
+    } else {
+      path.replaceWith(built);
+    }
+  }
+}
+
+function wrapFunction(path, callId) {
+  if (path.isClassMethod() || path.isObjectMethod()) {
+    classOrObjectMethod(path, callId);
+  } else {
+    plainFunction(path, callId);
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/helper-wrap-function/package.json b/node_modules/@babel/helper-wrap-function/package.json
new file mode 100644
index 00000000..0ad0f97d
--- /dev/null
+++ b/node_modules/@babel/helper-wrap-function/package.json
@@ -0,0 +1,14 @@
+{
+  "name": "@babel/helper-wrap-function",
+  "version": "7.0.0-beta.47",
+  "description": "Helper to wrap functions inside a function call.",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-helper-wrap-function",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/helper-function-name": "7.0.0-beta.47",
+    "@babel/template": "7.0.0-beta.47",
+    "@babel/traverse": "7.0.0-beta.47",
+    "@babel/types": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/helpers/README.md b/node_modules/@babel/helpers/README.md
new file mode 100644
index 00000000..ce5288bf
--- /dev/null
+++ b/node_modules/@babel/helpers/README.md
@@ -0,0 +1,56 @@
+# @babel/helpers
+
+> Collection of helper functions used by Babel transforms.
+
+## Install
+
+```sh
+npm install --save-dev @babel/helpers
+```
+
+## Usage
+
+Direct:
+
+```js
+import * as helpers from '@babel/helpers';
+import * as t from '@babel/types';
+
+const typeofHelper = helpers.get('typeof');
+
+t.isExpressionStatement(typeofHelper);
+// true
+```
+
+Inside a plugin:
+
+```js
+export default {
+  visitor: {
+    UnaryExpression(path) {
+      // The .addHelper function adds, if needed, the helper to the file
+      // and returns an expression which references the helper
+      const typeofHelper = this.addHelper("typeof");
+      t.isExpression(typeofHelper); // true
+  }
+};
+```
+
+## Defining Helpers
+
+> **NOTE**: This package is only meant to be used by the packages inluded in this repository. There is currently no way for third-party plugins to define an helper.
+
+Helpers are defined in the `src/helpers.js` file, and they must be valid modules which follow these guidelines:
+ - They must have a default export, which is their entry-point.
+ - They can import other helpers, exclusively by using default imports.
+ - They can't have named exports.
+
+```js
+helpers.customHelper = defineHelper(`
+  import dep from "dependency";
+  const foo = 2;
+  export default function getFooTimesDepPlusX(x) {
+    return foo * dep() + x;
+  }
+`);
+```
diff --git a/node_modules/@babel/helpers/lib/helpers.js b/node_modules/@babel/helpers/lib/helpers.js
new file mode 100644
index 00000000..a8977ab8
--- /dev/null
+++ b/node_modules/@babel/helpers/lib/helpers.js
@@ -0,0 +1,954 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _template() {
+  const data = _interopRequireDefault(require("@babel/template"));
+
+  _template = function _template() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const helpers = {};
+var _default = helpers;
+exports.default = _default;
+
+helpers.typeof = () => _template().default.program.ast`
+  export default function _typeof(obj) {
+    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+      _typeof = function (obj) { return typeof obj; };
+    } else {
+      _typeof = function (obj) {
+        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype
+          ? "symbol"
+          : typeof obj;
+      };
+    }
+
+    return _typeof(obj);
+  }
+`;
+
+helpers.jsx = () => _template().default.program.ast`
+  var REACT_ELEMENT_TYPE;
+
+  export default function _createRawReactElement(type, props, key, children) {
+    if (!REACT_ELEMENT_TYPE) {
+      REACT_ELEMENT_TYPE = (
+        typeof Symbol === "function" && Symbol.for && Symbol.for("react.element")
+      ) || 0xeac7;
+    }
+
+    var defaultProps = type && type.defaultProps;
+    var childrenLength = arguments.length - 3;
+
+    if (!props && childrenLength !== 0) {
+      // If we're going to assign props.children, we create a new object now
+      // to avoid mutating defaultProps.
+      props = {
+        children: void 0,
+      };
+    }
+    if (props && defaultProps) {
+      for (var propName in defaultProps) {
+        if (props[propName] === void 0) {
+          props[propName] = defaultProps[propName];
+        }
+      }
+    } else if (!props) {
+      props = defaultProps || {};
+    }
+
+    if (childrenLength === 1) {
+      props.children = children;
+    } else if (childrenLength > 1) {
+      var childArray = new Array(childrenLength);
+      for (var i = 0; i < childrenLength; i++) {
+        childArray[i] = arguments[i + 3];
+      }
+      props.children = childArray;
+    }
+
+    return {
+      $$typeof: REACT_ELEMENT_TYPE,
+      type: type,
+      key: key === undefined ? null : '' + key,
+      ref: null,
+      props: props,
+      _owner: null,
+    };
+  }
+`;
+
+helpers.asyncIterator = () => _template().default.program.ast`
+  export default function _asyncIterator(iterable) {
+    var method
+    if (typeof Symbol === "function") {
+      if (Symbol.asyncIterator) {
+        method = iterable[Symbol.asyncIterator]
+        if (method != null) return method.call(iterable);
+      }
+      if (Symbol.iterator) {
+        method = iterable[Symbol.iterator]
+        if (method != null) return method.call(iterable);
+      }
+    }
+    throw new TypeError("Object is not async iterable");
+  }
+`;
+
+helpers.AwaitValue = () => _template().default.program.ast`
+  export default function _AwaitValue(value) {
+    this.wrapped = value;
+  }
+`;
+
+helpers.AsyncGenerator = () => _template().default.program.ast`
+  import AwaitValue from "AwaitValue";
+
+  export default function AsyncGenerator(gen) {
+    var front, back;
+
+    function send(key, arg) {
+      return new Promise(function (resolve, reject) {
+        var request = {
+          key: key,
+          arg: arg,
+          resolve: resolve,
+          reject: reject,
+          next: null,
+        };
+
+        if (back) {
+          back = back.next = request;
+        } else {
+          front = back = request;
+          resume(key, arg);
+        }
+      });
+    }
+
+    function resume(key, arg) {
+      try {
+        var result = gen[key](arg)
+        var value = result.value;
+        var wrappedAwait = value instanceof AwaitValue;
+
+        Promise.resolve(wrappedAwait ? value.wrapped : value).then(
+          function (arg) {
+            if (wrappedAwait) {
+              resume("next", arg);
+              return
+            }
+
+            settle(result.done ? "return" : "normal", arg);
+          },
+          function (err) { resume("throw", err); });
+      } catch (err) {
+        settle("throw", err);
+      }
+    }
+
+    function settle(type, value) {
+      switch (type) {
+        case "return":
+          front.resolve({ value: value, done: true });
+          break;
+        case "throw":
+          front.reject(value);
+          break;
+        default:
+          front.resolve({ value: value, done: false });
+          break;
+      }
+
+      front = front.next;
+      if (front) {
+        resume(front.key, front.arg);
+      } else {
+        back = null;
+      }
+    }
+
+    this._invoke = send;
+
+    // Hide "return" method if generator return is not supported
+    if (typeof gen.return !== "function") {
+      this.return = undefined;
+    }
+  }
+
+  if (typeof Symbol === "function" && Symbol.asyncIterator) {
+    AsyncGenerator.prototype[Symbol.asyncIterator] = function () { return this; };
+  }
+
+  AsyncGenerator.prototype.next = function (arg) { return this._invoke("next", arg); };
+  AsyncGenerator.prototype.throw = function (arg) { return this._invoke("throw", arg); };
+  AsyncGenerator.prototype.return = function (arg) { return this._invoke("return", arg); };
+`;
+
+helpers.wrapAsyncGenerator = () => _template().default.program.ast`
+  import AsyncGenerator from "AsyncGenerator";
+
+  export default function _wrapAsyncGenerator(fn) {
+    return function () {
+      return new AsyncGenerator(fn.apply(this, arguments));
+    };
+  }
+`;
+
+helpers.awaitAsyncGenerator = () => _template().default.program.ast`
+  import AwaitValue from "AwaitValue";
+
+  export default function _awaitAsyncGenerator(value) {
+    return new AwaitValue(value);
+  }
+`;
+
+helpers.asyncGeneratorDelegate = () => _template().default.program.ast`
+  export default function _asyncGeneratorDelegate(inner, awaitWrap) {
+    var iter = {}, waiting = false;
+
+    function pump(key, value) {
+      waiting = true;
+      value = new Promise(function (resolve) { resolve(inner[key](value)); });
+      return { done: false, value: awaitWrap(value) };
+    };
+
+    if (typeof Symbol === "function" && Symbol.iterator) {
+      iter[Symbol.iterator] = function () { return this; };
+    }
+
+    iter.next = function (value) {
+      if (waiting) {
+        waiting = false;
+        return value;
+      }
+      return pump("next", value);
+    };
+
+    if (typeof inner.throw === "function") {
+      iter.throw = function (value) {
+        if (waiting) {
+          waiting = false;
+          throw value;
+        }
+        return pump("throw", value);
+      };
+    }
+
+    if (typeof inner.return === "function") {
+      iter.return = function (value) {
+        return pump("return", value);
+      };
+    }
+
+    return iter;
+  }
+`;
+
+helpers.asyncToGenerator = () => _template().default.program.ast`
+  export default function _asyncToGenerator(fn) {
+    return function () {
+      var self = this, args = arguments;
+      return new Promise(function (resolve, reject) {
+        var gen = fn.apply(self, args);
+        function step(key, arg) {
+          try {
+            var info = gen[key](arg);
+            var value = info.value;
+          } catch (error) {
+            reject(error);
+            return;
+          }
+
+          if (info.done) {
+            resolve(value);
+          } else {
+            Promise.resolve(value).then(_next, _throw);
+          }
+        }
+        function _next(value) { step("next", value); }
+        function _throw(err) { step("throw", err); }
+
+        _next();
+      });
+    };
+  }
+`;
+
+helpers.classCallCheck = () => _template().default.program.ast`
+  export default function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+`;
+
+helpers.createClass = () => _template().default.program.ast`
+  function _defineProperties(target, props) {
+    for (var i = 0; i < props.length; i ++) {
+      var descriptor = props[i];
+      descriptor.enumerable = descriptor.enumerable || false;
+      descriptor.configurable = true;
+      if ("value" in descriptor) descriptor.writable = true;
+      Object.defineProperty(target, descriptor.key, descriptor);
+    }
+  }
+
+  export default function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+  }
+`;
+
+helpers.defineEnumerableProperties = () => _template().default.program.ast`
+  export default function _defineEnumerableProperties(obj, descs) {
+    for (var key in descs) {
+      var desc = descs[key];
+      desc.configurable = desc.enumerable = true;
+      if ("value" in desc) desc.writable = true;
+      Object.defineProperty(obj, key, desc);
+    }
+
+    // Symbols are not enumerated over by for-in loops. If native
+    // Symbols are available, fetch all of the descs object's own
+    // symbol properties and define them on our target object too.
+    if (Object.getOwnPropertySymbols) {
+      var objectSymbols = Object.getOwnPropertySymbols(descs);
+      for (var i = 0; i < objectSymbols.length; i++) {
+        var sym = objectSymbols[i];
+        var desc = descs[sym];
+        desc.configurable = desc.enumerable = true;
+        if ("value" in desc) desc.writable = true;
+        Object.defineProperty(obj, sym, desc);
+      }
+    }
+    return obj;
+  }
+`;
+
+helpers.defaults = () => _template().default.program.ast`
+  export default function _defaults(obj, defaults) {
+    var keys = Object.getOwnPropertyNames(defaults);
+    for (var i = 0; i < keys.length; i++) {
+      var key = keys[i];
+      var value = Object.getOwnPropertyDescriptor(defaults, key);
+      if (value && value.configurable && obj[key] === undefined) {
+        Object.defineProperty(obj, key, value);
+      }
+    }
+    return obj;
+  }
+`;
+
+helpers.defineProperty = () => _template().default.program.ast`
+  export default function _defineProperty(obj, key, value) {
+    // Shortcircuit the slow defineProperty path when possible.
+    // We are trying to avoid issues where setters defined on the
+    // prototype cause side effects under the fast path of simple
+    // assignment. By checking for existence of the property with
+    // the in operator, we can optimize most of this overhead away.
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+`;
+
+helpers.extends = () => _template().default.program.ast`
+  export default function _extends() {
+    _extends = Object.assign || function (target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i];
+        for (var key in source) {
+          if (Object.prototype.hasOwnProperty.call(source, key)) {
+            target[key] = source[key];
+          }
+        }
+      }
+      return target;
+    };
+
+    return _extends.apply(this, arguments);
+  }
+`;
+
+helpers.objectSpread = () => _template().default.program.ast`
+  import defineProperty from "defineProperty";
+
+  export default function _objectSpread(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = (arguments[i] != null) ? arguments[i] : {};
+      var ownKeys = Object.keys(source);
+      if (typeof Object.getOwnPropertySymbols === 'function') {
+        ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+          return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+        }));
+      }
+      ownKeys.forEach(function(key) {
+        defineProperty(target, key, source[key]);
+      });
+    }
+    return target;
+  }
+`;
+
+helpers.inherits = () => _template().default.program.ast`
+  import setPrototypeOf from "setPrototypeOf";
+
+  export default function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+    setPrototypeOf(subClass.prototype, superClass && superClass.prototype);
+    if (superClass) setPrototypeOf(subClass, superClass);
+  }
+`;
+
+helpers.inheritsLoose = () => _template().default.program.ast`
+  export default function _inheritsLoose(subClass, superClass) {
+    subClass.prototype.__proto__ = superClass && superClass.prototype;
+    subClass.__proto__ = superClass;
+  }
+`;
+
+helpers.getPrototypeOf = () => _template().default.program.ast`
+  export default function _getPrototypeOf(o) {
+    _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) {
+      return o.__proto__;
+    };
+    return _getPrototypeOf(o);
+  }
+`;
+
+helpers.setPrototypeOf = () => _template().default.program.ast`
+  export default function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+      o.__proto__ = p;
+      return o;
+    };
+    return _setPrototypeOf(o, p);
+  }
+`;
+
+helpers.construct = () => _template().default.program.ast`
+  import setPrototypeOf from "setPrototypeOf";
+
+  export default function _construct(Parent, args, Class) {
+    if (typeof Reflect !== "undefined" && Reflect.construct) {
+      _construct = Reflect.construct;
+    } else {
+      _construct = function _construct(Parent, args, Class) {
+        var a = [null];
+        a.push.apply(a, args);
+        var Constructor = Parent.bind.apply(Parent, a);
+        var instance = new Constructor();
+        if (Class) setPrototypeOf(instance, Class.prototype);
+        return instance;
+      };
+    }
+    // Avoid issues with Class being present but undefined when it wasn't
+    // present in the original call.
+    return _construct.apply(null, arguments);
+  }
+`;
+
+helpers.wrapNativeSuper = () => _template().default.program.ast`
+  import _gPO from "getPrototypeOf";
+  import _sPO from "setPrototypeOf";
+  import construct from "construct";
+
+  export default function _wrapNativeSuper(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+
+    _wrapNativeSuper = function _wrapNativeSuper(Class) {
+      if (typeof Class !== "function") {
+        throw new TypeError("Super expression must either be null or a function");
+      }
+      if (typeof _cache !== "undefined") {
+        if (_cache.has(Class)) return _cache.get(Class);
+        _cache.set(Class, Wrapper);
+      }
+      function Wrapper() {}
+      Wrapper.prototype = Object.create(Class.prototype, {
+        constructor: {
+          value: Wrapper,
+          enumerable: false,
+          writable: true,
+          configurable: true,
+        }
+      });
+      return _sPO(
+        Wrapper,
+        _sPO(
+          function Super() {
+            return construct(Class, arguments, _gPO(this).constructor);
+          },
+          Class
+        )
+      );
+    }
+
+    return _wrapNativeSuper(Class)
+  }
+`;
+
+helpers.instanceof = () => _template().default.program.ast`
+  export default function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+      return right[Symbol.hasInstance](left);
+    } else {
+      return left instanceof right;
+    }
+  }
+`;
+
+helpers.interopRequireDefault = () => _template().default.program.ast`
+  export default function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : { default: obj };
+  }
+`;
+
+helpers.interopRequireWildcard = () => _template().default.program.ast`
+  export default function _interopRequireWildcard(obj) {
+    if (obj && obj.__esModule) {
+      return obj;
+    } else {
+      var newObj = {};
+      if (obj != null) {
+        for (var key in obj) {
+          if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = Object.defineProperty && Object.getOwnPropertyDescriptor
+              ? Object.getOwnPropertyDescriptor(obj, key)
+              : {};
+            if (desc.get || desc.set) {
+              Object.defineProperty(newObj, key, desc);
+            } else {
+              newObj[key] = obj[key];
+            }
+          }
+        }
+      }
+      newObj.default = obj;
+      return newObj;
+    }
+  }
+`;
+
+helpers.newArrowCheck = () => _template().default.program.ast`
+  export default function _newArrowCheck(innerThis, boundThis) {
+    if (innerThis !== boundThis) {
+      throw new TypeError("Cannot instantiate an arrow function");
+    }
+  }
+`;
+
+helpers.objectDestructuringEmpty = () => _template().default.program.ast`
+  export default function _objectDestructuringEmpty(obj) {
+    if (obj == null) throw new TypeError("Cannot destructure undefined");
+  }
+`;
+
+helpers.objectWithoutProperties = () => _template().default.program.ast`
+  export default function _objectWithoutProperties(source, excluded) {
+    if (source == null) return {};
+
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+
+    for (i = 0; i < sourceKeys.length; i++) {
+      key = sourceKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      target[key] = source[key];
+    }
+
+    if (Object.getOwnPropertySymbols) {
+      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+      for (i = 0; i < sourceSymbolKeys.length; i++) {
+        key = sourceSymbolKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+        target[key] = source[key];
+      }
+    }
+
+    return target;
+  }
+`;
+
+helpers.assertThisInitialized = () => _template().default.program.ast`
+  export default function _assertThisInitialized(self) {
+    if (self === void 0) {
+      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+  }
+`;
+
+helpers.possibleConstructorReturn = () => _template().default.program.ast`
+  import assertThisInitialized from "assertThisInitialized";
+
+  export default function _possibleConstructorReturn(self, call) {
+    if (call && (typeof call === "object" || typeof call === "function")) {
+      return call;
+    }
+    return assertThisInitialized(self);
+  }
+`;
+
+helpers.superPropBase = () => _template().default.program.ast`
+  import getPrototypeOf from "getPrototypeOf";
+
+  export default function _superPropBase(object, property) {
+    // Yes, this throws if object is null to being with, that's on purpose.
+    while (!Object.prototype.hasOwnProperty.call(object, property)) {
+      object = getPrototypeOf(object);
+      if (object === null) break;
+    }
+    return object;
+  }
+`;
+
+helpers.get = () => _template().default.program.ast`
+  import getPrototypeOf from "getPrototypeOf";
+  import superPropBase from "superPropBase";
+
+  export default function _get(target, property, receiver) {
+    if (typeof Reflect !== "undefined" && Reflect.get) {
+      _get = Reflect.get;
+    } else {
+      _get = function _get(target, property, receiver) {
+        var base = superPropBase(target, property);
+
+        if (!base) return;
+
+        var desc = Object.getOwnPropertyDescriptor(base, property);
+        if (desc.get) {
+          return desc.get.call(receiver);
+        }
+
+        return desc.value;
+      };
+    }
+    return _get(target, property, receiver || target);
+  }
+`;
+
+helpers.set = () => _template().default.program.ast`
+  import getPrototypeOf from "getPrototypeOf";
+  import superPropBase from "superPropBase";
+  import defineProperty from "defineProperty";
+
+  function set(target, property, value, receiver) {
+    if (typeof Reflect !== "undefined" && Reflect.set) {
+      set = Reflect.set;
+    } else {
+      set = function set(target, property, value, receiver) {
+        var base = superPropBase(target, property);
+        var desc;
+
+        if (base) {
+          desc = Object.getOwnPropertyDescriptor(base, property);
+          if (desc.set) {
+            desc.set.call(receiver, value);
+            return true;
+          } else if (!desc.writable) {
+            // Both getter and non-writable fall into this.
+            return false;
+          }
+        }
+
+        // Without a super that defines the property, spec boils down to
+        // "define on receiver" for some reason.
+        desc = Object.getOwnPropertyDescriptor(receiver, property);
+        if (desc) {
+          if (!desc.writable) {
+            // Setter, getter, and non-writable fall into this.
+            return false;
+          }
+
+          desc.value = value;
+          Object.defineProperty(receiver, property, desc);
+        } else {
+          // Avoid setters that may be defined on Sub's prototype, but not on
+          // the instance.
+          defineProperty(receiver, property, value);
+        }
+
+        return true;
+      };
+    }
+
+    return set(target, property, value, receiver);
+  }
+
+  export default function _set(target, property, value, receiver, isStrict) {
+    var s = set(target, property, value, receiver || target);
+    if (!s && isStrict) {
+      throw new Error('failed to set property');
+    }
+
+    return value;
+  }
+`;
+
+helpers.taggedTemplateLiteral = () => _template().default.program.ast`
+  export default function _taggedTemplateLiteral(strings, raw) {
+    if (!raw) { raw = strings.slice(0); }
+    return Object.freeze(Object.defineProperties(strings, {
+        raw: { value: Object.freeze(raw) }
+    }));
+  }
+`;
+
+helpers.taggedTemplateLiteralLoose = () => _template().default.program.ast`
+  export default function _taggedTemplateLiteralLoose(strings, raw) {
+    if (!raw) { raw = strings.slice(0); }
+    strings.raw = raw;
+    return strings;
+  }
+`;
+
+helpers.temporalRef = () => _template().default.program.ast`
+  import undef from "temporalUndefined";
+
+  export default function _temporalRef(val, name) {
+    if (val === undef) {
+      throw new ReferenceError(name + " is not defined - temporal dead zone");
+    } else {
+      return val;
+    }
+  }
+`;
+
+helpers.readOnlyError = () => _template().default.program.ast`
+  export default function _readOnlyError(name) {
+    throw new Error("\\"" + name + "\\" is read-only");
+  }
+`;
+
+helpers.classNameTDZError = () => _template().default.program.ast`
+  export default function _classNameTDZError(name) {
+    throw new Error("Class \\"" + name + "\\" cannot be referenced in computed property keys.");
+  }
+`;
+
+helpers.temporalUndefined = () => _template().default.program.ast`
+  export default {};
+`;
+
+helpers.slicedToArray = () => _template().default.program.ast`
+  import arrayWithHoles from "arrayWithHoles";
+  import iterableToArrayLimit from "iterableToArrayLimit";
+  import nonIterableRest from "nonIterableRest";
+
+  export default function _slicedToArray(arr, i) {
+    return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || nonIterableRest();
+  }
+`;
+
+helpers.slicedToArrayLoose = () => _template().default.program.ast`
+  import arrayWithHoles from "arrayWithHoles";
+  import iterableToArrayLimitLoose from "iterableToArrayLimitLoose";
+  import nonIterableRest from "nonIterableRest";
+
+  export default function _slicedToArrayLoose(arr, i) {
+    return arrayWithHoles(arr) || iterableToArrayLimitLoose(arr, i) || nonIterableRest();
+  }
+`;
+
+helpers.toArray = () => _template().default.program.ast`
+  import arrayWithHoles from "arrayWithHoles";
+  import iterableToArray from "iterableToArray";
+  import nonIterableRest from "nonIterableRest";
+
+  export default function _toArray(arr) {
+    return arrayWithHoles(arr) || iterableToArray(arr) || nonIterableRest();
+  }
+`;
+
+helpers.toConsumableArray = () => _template().default.program.ast`
+  import arrayWithoutHoles from "arrayWithoutHoles";
+  import iterableToArray from "iterableToArray";
+  import nonIterableSpread from "nonIterableSpread";
+
+  export default function _toConsumableArray(arr) {
+    return arrayWithoutHoles(arr) || iterableToArray(arr) || nonIterableSpread();
+  }
+`;
+
+helpers.arrayWithoutHoles = () => _template().default.program.ast`
+  export default function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) {
+      for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
+      return arr2;
+    }
+  }
+`;
+
+helpers.arrayWithHoles = () => _template().default.program.ast`
+  export default function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+  }
+`;
+
+helpers.iterableToArray = () => _template().default.program.ast`
+  export default function _iterableToArray(iter) {
+    if (
+      Symbol.iterator in Object(iter) ||
+      Object.prototype.toString.call(iter) === "[object Arguments]"
+    ) return Array.from(iter);
+  }
+`;
+
+helpers.iterableToArrayLimit = () => _template().default.program.ast`
+  export default function _iterableToArrayLimit(arr, i) {
+    // this is an expanded form of \`for...of\` that properly supports abrupt completions of
+    // iterators etc. variable names have been minimised to reduce the size of this massive
+    // helper. sometimes spec compliancy is annoying :(
+    //
+    // _n = _iteratorNormalCompletion
+    // _d = _didIteratorError
+    // _e = _iteratorError
+    // _i = _iterator
+    // _s = _step
+
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _e = undefined;
+    try {
+      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+        _arr.push(_s.value);
+        if (i && _arr.length === i) break;
+      }
+    } catch (err) {
+      _d = true;
+      _e = err;
+    } finally {
+      try {
+        if (!_n && _i["return"] != null) _i["return"]();
+      } finally {
+        if (_d) throw _e;
+      }
+    }
+    return _arr;
+  }
+`;
+
+helpers.iterableToArrayLimitLoose = () => _template().default.program.ast`
+  export default function _iterableToArrayLimitLoose(arr, i) {
+    var _arr = [];
+    for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) {
+      _arr.push(_step.value);
+      if (i && _arr.length === i) break;
+    }
+    return _arr;
+  }
+`;
+
+helpers.nonIterableSpread = () => _template().default.program.ast`
+  export default function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance");
+  }
+`;
+
+helpers.nonIterableRest = () => _template().default.program.ast`
+  export default function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance");
+  }
+`;
+
+helpers.skipFirstGeneratorNext = () => _template().default.program.ast`
+  export default function _skipFirstGeneratorNext(fn) {
+    return function () {
+      var it = fn.apply(this, arguments);
+      it.next();
+      return it;
+    }
+  }
+`;
+
+helpers.toPropertyKey = () => _template().default.program.ast`
+  export default function _toPropertyKey(key) {
+    if (typeof key === "symbol") {
+      return key;
+    } else {
+      return String(key);
+    }
+  }
+`;
+
+helpers.initializerWarningHelper = () => _template().default.program.ast`
+    export default function _initializerWarningHelper(descriptor, context){
+        throw new Error(
+          'Decorating class property failed. Please ensure that ' +
+          'proposal-class-properties is enabled and set to use loose mode. ' +
+          'To use proposal-class-properties in spec mode with decorators, wait for ' +
+          'the next major version of decorators in stage 2.'
+        );
+    }
+`;
+
+helpers.initializerDefineProperty = () => _template().default.program.ast`
+    export default function _initializerDefineProperty(target, property, descriptor, context){
+        if (!descriptor) return;
+
+        Object.defineProperty(target, property, {
+            enumerable: descriptor.enumerable,
+            configurable: descriptor.configurable,
+            writable: descriptor.writable,
+            value: descriptor.initializer ? descriptor.initializer.call(context) : void 0,
+        });
+    }
+`;
+
+helpers.applyDecoratedDescriptor = () => _template().default.program.ast`
+    export default function _applyDecoratedDescriptor(target, property, decorators, descriptor, context){
+        var desc = {};
+        Object['ke' + 'ys'](descriptor).forEach(function(key){
+            desc[key] = descriptor[key];
+        });
+        desc.enumerable = !!desc.enumerable;
+        desc.configurable = !!desc.configurable;
+        if ('value' in desc || desc.initializer){
+            desc.writable = true;
+        }
+
+        desc = decorators.slice().reverse().reduce(function(desc, decorator){
+            return decorator(target, property, desc) || desc;
+        }, desc);
+
+        if (context && desc.initializer !== void 0){
+            desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
+            desc.initializer = undefined;
+        }
+
+        if (desc.initializer === void 0){
+            // This is a hack to avoid this being processed by 'transform-runtime'.
+            // See issue #9.
+            Object['define' + 'Property'](target, property, desc);
+            desc = null;
+        }
+
+        return desc;
+    }
+`;
\ No newline at end of file
diff --git a/node_modules/@babel/helpers/lib/index.js b/node_modules/@babel/helpers/lib/index.js
new file mode 100644
index 00000000..f60b67c8
--- /dev/null
+++ b/node_modules/@babel/helpers/lib/index.js
@@ -0,0 +1,293 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.get = get;
+exports.getDependencies = getDependencies;
+exports.default = exports.list = void 0;
+
+function _traverse() {
+  const data = _interopRequireDefault(require("@babel/traverse"));
+
+  _traverse = function _traverse() {
+    return data;
+  };
+
+  return data;
+}
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+var _helpers = _interopRequireDefault(require("./helpers"));
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function makePath(path) {
+  const parts = [];
+
+  for (; path.parentPath; path = path.parentPath) {
+    parts.push(path.key);
+    if (path.inList) parts.push(path.listKey);
+  }
+
+  return parts.reverse().join(".");
+}
+
+function getHelperMetadata(file) {
+  const globals = new Set();
+  const localBindingNames = new Set();
+  const dependencies = new Map();
+  let exportName;
+  let exportPath;
+  const exportBindingAssignments = [];
+  const importPaths = [];
+  const importBindingsReferences = [];
+  (0, _traverse().default)(file, {
+    ImportDeclaration(child) {
+      const name = child.node.source.value;
+
+      if (!_helpers.default[name]) {
+        throw child.buildCodeFrameError(`Unknown helper ${name}`);
+      }
+
+      if (child.get("specifiers").length !== 1 || !child.get("specifiers.0").isImportDefaultSpecifier()) {
+        throw child.buildCodeFrameError("Helpers can only import a default value");
+      }
+
+      const bindingIdentifier = child.node.specifiers[0].local;
+      dependencies.set(bindingIdentifier, name);
+      importPaths.push(makePath(child));
+    },
+
+    ExportDefaultDeclaration(child) {
+      const decl = child.get("declaration");
+
+      if (decl.isFunctionDeclaration()) {
+        if (!decl.node.id) {
+          throw decl.buildCodeFrameError("Helpers should give names to their exported func declaration");
+        }
+
+        exportName = decl.node.id.name;
+      }
+
+      exportPath = makePath(child);
+    },
+
+    ExportAllDeclaration(child) {
+      throw child.buildCodeFrameError("Helpers can only export default");
+    },
+
+    ExportNamedDeclaration(child) {
+      throw child.buildCodeFrameError("Helpers can only export default");
+    },
+
+    Statement(child) {
+      if (child.isModuleDeclaration()) return;
+      child.skip();
+    }
+
+  });
+  (0, _traverse().default)(file, {
+    Program(path) {
+      const bindings = path.scope.getAllBindings();
+      Object.keys(bindings).forEach(name => {
+        if (name === exportName) return;
+        if (dependencies.has(bindings[name].identifier)) return;
+        localBindingNames.add(name);
+      });
+    },
+
+    ReferencedIdentifier(child) {
+      const name = child.node.name;
+      const binding = child.scope.getBinding(name, true);
+
+      if (!binding) {
+        globals.add(name);
+      } else if (dependencies.has(binding.identifier)) {
+        importBindingsReferences.push(makePath(child));
+      }
+    },
+
+    AssignmentExpression(child) {
+      const left = child.get("left");
+      if (!(exportName in left.getBindingIdentifiers())) return;
+
+      if (!left.isIdentifier()) {
+        throw left.buildCodeFrameError("Only simple assignments to exports are allowed in helpers");
+      }
+
+      const binding = child.scope.getBinding(exportName);
+
+      if (binding && binding.scope.path.isProgram()) {
+        exportBindingAssignments.push(makePath(child));
+      }
+    }
+
+  });
+  if (!exportPath) throw new Error("Helpers must default-export something.");
+  exportBindingAssignments.reverse();
+  return {
+    globals: Array.from(globals),
+    localBindingNames: Array.from(localBindingNames),
+    dependencies,
+    exportBindingAssignments,
+    exportPath,
+    exportName,
+    importBindingsReferences,
+    importPaths
+  };
+}
+
+function permuteHelperAST(file, metadata, id, localBindings, getDependency) {
+  if (localBindings && !id) {
+    throw new Error("Unexpected local bindings for module-based helpers.");
+  }
+
+  if (!id) return;
+  const localBindingNames = metadata.localBindingNames,
+        dependencies = metadata.dependencies,
+        exportBindingAssignments = metadata.exportBindingAssignments,
+        exportPath = metadata.exportPath,
+        exportName = metadata.exportName,
+        importBindingsReferences = metadata.importBindingsReferences,
+        importPaths = metadata.importPaths;
+  const dependenciesRefs = {};
+  dependencies.forEach((name, id) => {
+    dependenciesRefs[id.name] = typeof getDependency === "function" && getDependency(name) || id;
+  });
+  const toRename = {};
+  const bindings = new Set(localBindings || []);
+  localBindingNames.forEach(name => {
+    let newName = name;
+
+    while (bindings.has(newName)) newName = "_" + newName;
+
+    if (newName !== name) toRename[name] = newName;
+  });
+
+  if (id.type === "Identifier" && exportName !== id.name) {
+    toRename[exportName] = id.name;
+  }
+
+  (0, _traverse().default)(file, {
+    Program(path) {
+      const exp = path.get(exportPath);
+      const imps = importPaths.map(p => path.get(p));
+      const impsBindingRefs = importBindingsReferences.map(p => path.get(p));
+      const decl = exp.get("declaration");
+
+      if (id.type === "Identifier") {
+        if (decl.isFunctionDeclaration()) {
+          exp.replaceWith(decl);
+        } else {
+          exp.replaceWith(t().variableDeclaration("var", [t().variableDeclarator(id, decl.node)]));
+        }
+      } else if (id.type === "MemberExpression") {
+        if (decl.isFunctionDeclaration()) {
+          exportBindingAssignments.forEach(assignPath => {
+            const assign = path.get(assignPath);
+            assign.replaceWith(t().assignmentExpression("=", id, assign.node));
+          });
+          exp.replaceWith(decl);
+          path.pushContainer("body", t().expressionStatement(t().assignmentExpression("=", id, t().identifier(exportName))));
+        } else {
+          exp.replaceWith(t().expressionStatement(t().assignmentExpression("=", id, decl.node)));
+        }
+      } else {
+        throw new Error("Unexpected helper format.");
+      }
+
+      Object.keys(toRename).forEach(name => {
+        path.scope.rename(name, toRename[name]);
+      });
+
+      for (var _iterator = imps, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+        var _ref;
+
+        if (_isArray) {
+          if (_i >= _iterator.length) break;
+          _ref = _iterator[_i++];
+        } else {
+          _i = _iterator.next();
+          if (_i.done) break;
+          _ref = _i.value;
+        }
+
+        const path = _ref;
+        path.remove();
+      }
+
+      for (var _iterator2 = impsBindingRefs, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+        var _ref2;
+
+        if (_isArray2) {
+          if (_i2 >= _iterator2.length) break;
+          _ref2 = _iterator2[_i2++];
+        } else {
+          _i2 = _iterator2.next();
+          if (_i2.done) break;
+          _ref2 = _i2.value;
+        }
+
+        const path = _ref2;
+        const node = t().cloneNode(dependenciesRefs[path.node.name]);
+        path.replaceWith(node);
+      }
+
+      path.stop();
+    }
+
+  });
+}
+
+const helperData = {};
+
+function loadHelper(name) {
+  if (!helperData[name]) {
+    if (!_helpers.default[name]) throw new ReferenceError(`Unknown helper ${name}`);
+
+    const fn = () => {
+      return t().file(_helpers.default[name]());
+    };
+
+    const metadata = getHelperMetadata(fn());
+    helperData[name] = {
+      build(getDependency, id, localBindings) {
+        const file = fn();
+        permuteHelperAST(file, metadata, id, localBindings, getDependency);
+        return {
+          nodes: file.program.body,
+          globals: metadata.globals
+        };
+      },
+
+      dependencies: metadata.dependencies
+    };
+  }
+
+  return helperData[name];
+}
+
+function get(name, getDependency, id, localBindings) {
+  return loadHelper(name).build(getDependency, id, localBindings);
+}
+
+function getDependencies(name) {
+  return Array.from(loadHelper(name).dependencies.values());
+}
+
+const list = Object.keys(_helpers.default).map(name => name.replace(/^_/, "")).filter(name => name !== "__esModule");
+exports.list = list;
+var _default = get;
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/helpers/package.json b/node_modules/@babel/helpers/package.json
new file mode 100644
index 00000000..ccdb8d32
--- /dev/null
+++ b/node_modules/@babel/helpers/package.json
@@ -0,0 +1,18 @@
+{
+  "name": "@babel/helpers",
+  "version": "7.0.0-beta.47",
+  "description": "Collection of helper functions used by Babel transforms.",
+  "author": "Sebastian McKenzie <sebmck@gmail.com>",
+  "homepage": "https://babeljs.io/",
+  "license": "MIT",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-helpers",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/template": "7.0.0-beta.47",
+    "@babel/traverse": "7.0.0-beta.47",
+    "@babel/types": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/highlight/README.md b/node_modules/@babel/highlight/README.md
new file mode 100644
index 00000000..36143844
--- /dev/null
+++ b/node_modules/@babel/highlight/README.md
@@ -0,0 +1,41 @@
+# @babel/highlight
+
+> Syntax highlight JavaScript strings for output in terminals.
+
+## Install
+
+```sh
+npm install --save @babel/highlight
+```
+
+## Usage
+
+```js
+import highlight from "@babel/highlight";
+
+const code = `class Foo {
+  constructor()
+}`;
+
+const result = highlight(code);
+
+console.log(result);
+```
+
+```js
+class Foo {
+  constructor()
+}
+```
+
+By default, `highlight` will not highlight your code if your terminal does not support color. To force colors, pass `{ forceColor: true }` as the second argument to `highlight`.
+
+```js
+import highlight from "@babel/highlight";
+
+const code = `class Foo {
+  constructor()
+}`;
+
+const result = highlight(code, { forceColor: true });
+```
diff --git a/node_modules/@babel/highlight/lib/index.js b/node_modules/@babel/highlight/lib/index.js
new file mode 100644
index 00000000..e3e37258
--- /dev/null
+++ b/node_modules/@babel/highlight/lib/index.js
@@ -0,0 +1,132 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.shouldHighlight = shouldHighlight;
+exports.getChalk = getChalk;
+exports.default = highlight;
+
+function _jsTokens() {
+  const data = _interopRequireWildcard(require("js-tokens"));
+
+  _jsTokens = function _jsTokens() {
+    return data;
+  };
+
+  return data;
+}
+
+function _esutils() {
+  const data = _interopRequireDefault(require("esutils"));
+
+  _esutils = function _esutils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _chalk() {
+  const data = _interopRequireDefault(require("chalk"));
+
+  _chalk = function _chalk() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function getDefs(chalk) {
+  return {
+    keyword: chalk.cyan,
+    capitalized: chalk.yellow,
+    jsx_tag: chalk.yellow,
+    punctuator: chalk.yellow,
+    number: chalk.magenta,
+    string: chalk.green,
+    regex: chalk.magenta,
+    comment: chalk.grey,
+    invalid: chalk.white.bgRed.bold
+  };
+}
+
+const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
+const JSX_TAG = /^[a-z][\w-]*$/i;
+const BRACKET = /^[()[\]{}]$/;
+
+function getTokenType(match) {
+  const _match$slice = match.slice(-2),
+        offset = _match$slice[0],
+        text = _match$slice[1];
+
+  const token = (0, _jsTokens().matchToToken)(match);
+
+  if (token.type === "name") {
+    if (_esutils().default.keyword.isReservedWordES6(token.value)) {
+      return "keyword";
+    }
+
+    if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.substr(offset - 2, 2) == "</")) {
+      return "jsx_tag";
+    }
+
+    if (token.value[0] !== token.value[0].toLowerCase()) {
+      return "capitalized";
+    }
+  }
+
+  if (token.type === "punctuator" && BRACKET.test(token.value)) {
+    return "bracket";
+  }
+
+  if (token.type === "invalid" && (token.value === "@" || token.value === "#")) {
+    return "punctuator";
+  }
+
+  return token.type;
+}
+
+function highlightTokens(defs, text) {
+  return text.replace(_jsTokens().default, function (...args) {
+    const type = getTokenType(args);
+    const colorize = defs[type];
+
+    if (colorize) {
+      return args[0].split(NEWLINE).map(str => colorize(str)).join("\n");
+    } else {
+      return args[0];
+    }
+  });
+}
+
+function shouldHighlight(options) {
+  return _chalk().default.supportsColor || options.forceColor;
+}
+
+function getChalk(options) {
+  let chalk = _chalk().default;
+
+  if (options.forceColor) {
+    chalk = new (_chalk().default.constructor)({
+      enabled: true,
+      level: 1
+    });
+  }
+
+  return chalk;
+}
+
+function highlight(code, options = {}) {
+  if (shouldHighlight(options)) {
+    const chalk = getChalk(options);
+    const defs = getDefs(chalk);
+    return highlightTokens(defs, code);
+  } else {
+    return code;
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/highlight/package.json b/node_modules/@babel/highlight/package.json
new file mode 100644
index 00000000..18dc0e02
--- /dev/null
+++ b/node_modules/@babel/highlight/package.json
@@ -0,0 +1,18 @@
+{
+  "name": "@babel/highlight",
+  "version": "7.0.0-beta.47",
+  "description": "Syntax highlight JavaScript strings for output in terminals.",
+  "author": "suchipi <me@suchipi.com>",
+  "homepage": "https://babeljs.io/",
+  "license": "MIT",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-highlight",
+  "main": "lib/index.js",
+  "dependencies": {
+    "chalk": "^2.0.0",
+    "esutils": "^2.0.2",
+    "js-tokens": "^3.0.0"
+  },
+  "devDependencies": {
+    "strip-ansi": "^4.0.0"
+  }
+}
diff --git a/node_modules/@babel/plugin-proposal-async-generator-functions/README.md b/node_modules/@babel/plugin-proposal-async-generator-functions/README.md
new file mode 100644
index 00000000..543d5bfc
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-async-generator-functions/README.md
@@ -0,0 +1,107 @@
+# @babel/plugin-proposal-async-generator-functions
+
+> Turn async generator functions and for-await statements to ES2015 generators
+
+## Example
+
+**In**
+
+```javascript
+async function* agf() {
+  await 1;
+  yield 2;
+}
+```
+
+**Out**
+
+```javascript
+var _asyncGenerator = ...
+
+let agf = (() => {
+  var _ref = _asyncGenerator.wrap(function* () {
+    yield _asyncGenerator.await(1);
+    yield 2;
+  });
+
+  return function agf() {
+    return _ref.apply(this, arguments);
+  };
+})();
+```
+
+For await example
+
+```js
+async function f() {
+  for await (let x of y) {
+    g(x);
+  }
+}
+```
+
+**Example Usage**
+
+```js
+async function* genAnswers() {
+  var stream = [ Promise.resolve(4), Promise.resolve(9), Promise.resolve(12) ];
+  var total = 0;
+  for await (let val of stream) {
+    total += await val;
+    yield total;
+  }
+}
+
+function forEach(ai, fn) {
+  return ai.next().then(function (r) {
+    if (!r.done) {
+      fn(r);
+      return forEach(ai, fn);
+    }
+  });
+}
+
+var output = 0;
+forEach(genAnswers(), function(val) { output += val.value })
+.then(function () {
+  console.log(output); // 42
+});
+```
+
+[Try it Out in the REPL](https://babeljs.io/repl/#?babili=false&evaluate=true&lineWrap=false&presets=stage-3&code=async%20function*%20genAnswers()%20%7B%0A%20%20var%20stream%20%3D%20%5B%20Promise.resolve(4)%2C%20Promise.resolve(9)%2C%20Promise.resolve(12)%20%5D%3B%0A%20%20var%20total%20%3D%200%3B%0A%20%20for%20await%20(let%20val%20of%20stream)%20%7B%0A%20%20%20%20total%20%2B%3D%20await%20val%3B%0A%20%20%20%20yield%20total%3B%0A%20%20%7D%0A%7D%0A%0Afunction%20forEach(ai%2C%20fn)%20%7B%0A%20%20return%20ai.next().then(function%20(r)%20%7B%0A%20%20%20%20if%20(!r.done)%20%7B%0A%20%20%20%20%20%20fn(r)%3B%0A%20%20%20%20%20%20return%20forEach(ai%2C%20fn)%3B%0A%20%20%20%20%7D%0A%20%20%7D)%3B%0A%7D%0A%0Avar%20output%20%3D%200%3B%0AforEach(genAnswers()%2C%20function(val)%20%7B%20output%20%2B%3D%20val.value%20%7D)%0A.then(function%20()%20%7B%0A%20%20console.log(output)%3B%20%2F%2F%2042%0A%7D)%3B&experimental=true&loose=false&spec=false&playground=true&stage=0)
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-proposal-async-generator-functions
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-proposal-async-generator-functions"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-proposal-async-generator-functions script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-proposal-async-generator-functions"]
+});
+```
+
+## References
+
+* [Proposal: Asynchronous iteration for ECMAScript](https://github.com/tc39/proposal-async-iteration)
diff --git a/node_modules/@babel/plugin-proposal-async-generator-functions/lib/for-await.js b/node_modules/@babel/plugin-proposal-async-generator-functions/lib/for-await.js
new file mode 100644
index 00000000..54571bc3
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-async-generator-functions/lib/for-await.js
@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+const buildForAwait = (0, _core().template)(`
+  async function wrapper() {
+    var ITERATOR_COMPLETION = true;
+    var ITERATOR_HAD_ERROR_KEY = false;
+    var ITERATOR_ERROR_KEY;
+    try {
+      for (
+        var ITERATOR_KEY = GET_ITERATOR(OBJECT), STEP_KEY, STEP_VALUE;
+        (
+          STEP_KEY = await ITERATOR_KEY.next(),
+          ITERATOR_COMPLETION = STEP_KEY.done,
+          STEP_VALUE = await STEP_KEY.value,
+          !ITERATOR_COMPLETION
+        );
+        ITERATOR_COMPLETION = true) {
+      }
+    } catch (err) {
+      ITERATOR_HAD_ERROR_KEY = true;
+      ITERATOR_ERROR_KEY = err;
+    } finally {
+      try {
+        if (!ITERATOR_COMPLETION && ITERATOR_KEY.return != null) {
+          await ITERATOR_KEY.return();
+        }
+      } finally {
+        if (ITERATOR_HAD_ERROR_KEY) {
+          throw ITERATOR_ERROR_KEY;
+        }
+      }
+    }
+  }
+`);
+
+function _default(path, {
+  getAsyncIterator
+}) {
+  const node = path.node,
+        scope = path.scope,
+        parent = path.parent;
+  const stepKey = scope.generateUidIdentifier("step");
+  const stepValue = scope.generateUidIdentifier("value");
+  const left = node.left;
+  let declar;
+
+  if (_core().types.isIdentifier(left) || _core().types.isPattern(left) || _core().types.isMemberExpression(left)) {
+    declar = _core().types.expressionStatement(_core().types.assignmentExpression("=", left, stepValue));
+  } else if (_core().types.isVariableDeclaration(left)) {
+    declar = _core().types.variableDeclaration(left.kind, [_core().types.variableDeclarator(left.declarations[0].id, stepValue)]);
+  }
+
+  let template = buildForAwait({
+    ITERATOR_HAD_ERROR_KEY: scope.generateUidIdentifier("didIteratorError"),
+    ITERATOR_COMPLETION: scope.generateUidIdentifier("iteratorNormalCompletion"),
+    ITERATOR_ERROR_KEY: scope.generateUidIdentifier("iteratorError"),
+    ITERATOR_KEY: scope.generateUidIdentifier("iterator"),
+    GET_ITERATOR: getAsyncIterator,
+    OBJECT: node.right,
+    STEP_VALUE: stepValue,
+    STEP_KEY: stepKey
+  });
+  template = template.body.body;
+
+  const isLabeledParent = _core().types.isLabeledStatement(parent);
+
+  const tryBody = template[3].block.body;
+  const loop = tryBody[0];
+
+  if (isLabeledParent) {
+    tryBody[0] = _core().types.labeledStatement(parent.label, loop);
+  }
+
+  return {
+    replaceParent: isLabeledParent,
+    node: template,
+    declar,
+    loop
+  };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-proposal-async-generator-functions/lib/index.js b/node_modules/@babel/plugin-proposal-async-generator-functions/lib/index.js
new file mode 100644
index 00000000..534575b8
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-async-generator-functions/lib/index.js
@@ -0,0 +1,128 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperRemapAsyncToGenerator() {
+  const data = _interopRequireDefault(require("@babel/helper-remap-async-to-generator"));
+
+  _helperRemapAsyncToGenerator = function _helperRemapAsyncToGenerator() {
+    return data;
+  };
+
+  return data;
+}
+
+function _pluginSyntaxAsyncGenerators() {
+  const data = _interopRequireDefault(require("@babel/plugin-syntax-async-generators"));
+
+  _pluginSyntaxAsyncGenerators = function _pluginSyntaxAsyncGenerators() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+var _forAwait = _interopRequireDefault(require("./for-await"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+  const yieldStarVisitor = {
+    Function(path) {
+      path.skip();
+    },
+
+    YieldExpression({
+      node
+    }, state) {
+      if (!node.delegate) return;
+      const callee = state.addHelper("asyncGeneratorDelegate");
+      node.argument = _core().types.callExpression(callee, [_core().types.callExpression(state.addHelper("asyncIterator"), [node.argument]), state.addHelper("awaitAsyncGenerator")]);
+    }
+
+  };
+  const forAwaitVisitor = {
+    Function(path) {
+      path.skip();
+    },
+
+    ForOfStatement(path, {
+      file
+    }) {
+      const node = path.node;
+      if (!node.await) return;
+      const build = (0, _forAwait.default)(path, {
+        getAsyncIterator: file.addHelper("asyncIterator")
+      });
+      const declar = build.declar,
+            loop = build.loop;
+      const block = loop.body;
+      path.ensureBlock();
+
+      if (declar) {
+        block.body.push(declar);
+      }
+
+      block.body = block.body.concat(node.body.body);
+
+      _core().types.inherits(loop, node);
+
+      _core().types.inherits(loop.body, node.body);
+
+      if (build.replaceParent) {
+        path.parentPath.replaceWithMultiple(build.node);
+      } else {
+        path.replaceWithMultiple(build.node);
+      }
+    }
+
+  };
+  const visitor = {
+    Function(path, state) {
+      if (!path.node.async) return;
+      path.traverse(forAwaitVisitor, state);
+      if (!path.node.generator) return;
+      path.traverse(yieldStarVisitor, state);
+      (0, _helperRemapAsyncToGenerator().default)(path, {
+        wrapAsync: state.addHelper("wrapAsyncGenerator"),
+        wrapAwait: state.addHelper("awaitAsyncGenerator")
+      });
+    }
+
+  };
+  return {
+    inherits: _pluginSyntaxAsyncGenerators().default,
+    visitor: {
+      Program(path, state) {
+        path.traverse(visitor, state);
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-proposal-async-generator-functions/package.json b/node_modules/@babel/plugin-proposal-async-generator-functions/package.json
new file mode 100644
index 00000000..6afb5c38
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-async-generator-functions/package.json
@@ -0,0 +1,23 @@
+{
+  "name": "@babel/plugin-proposal-async-generator-functions",
+  "version": "7.0.0-beta.47",
+  "description": "Turn async generator functions into ES2015 generators",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-proposal-async-generator-functions",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47",
+    "@babel/helper-remap-async-to-generator": "7.0.0-beta.47",
+    "@babel/plugin-syntax-async-generators": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-proposal-class-properties/README.md b/node_modules/@babel/plugin-proposal-class-properties/README.md
new file mode 100644
index 00000000..dee62c85
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-class-properties/README.md
@@ -0,0 +1,149 @@
+# @babel/plugin-proposal-class-properties
+
+> This plugin transforms class properties
+
+## Example
+
+Below is a class with four class properties which will be transformed.
+
+```js
+  class Bork {
+    //Property initializer syntax
+    instanceProperty = "bork";
+    boundFunction = () => {
+      return this.instanceProperty;
+    };
+
+    //Static class properties
+    static staticProperty = "babelIsCool";
+    static staticFunction = function() {
+      return Bork.staticProperty;
+    };
+  }
+
+  let myBork = new Bork;
+
+  //Property initializers are not on the prototype.
+  console.log(myBork.__proto__.boundFunction); // > undefined
+
+  //Bound functions are bound to the class instance.
+  console.log(myBork.boundFunction.call(undefined)); // > "bork"
+
+  //Static function exists on the class.
+  console.log(Bork.staticFunction()); // > "babelIsCool"
+```
+
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-proposal-class-properties
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+Without options:
+
+```json
+{
+  "plugins": ["@babel/plugin-proposal-class-properties"]
+}
+```
+
+With options:
+
+```json
+{
+  "plugins": [
+    ["@babel/plugin-proposal-class-properties", { "loose": true }]
+  ]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-proposal-class-properties script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-proposal-class-properties"]
+});
+```
+
+## Options
+
+### `loose`
+
+`boolean`, defaults to `false`.
+
+When `true`, class properties are compiled to use an assignment expression instead of `Object.defineProperty`.
+
+#### Example
+
+```js
+  class Bork {
+    static a = 'foo';
+    static b;
+
+    x = 'bar';
+    y;
+  }
+```
+
+Without `{ "loose": true }`, the above code will compile to the following, using `Object.defineProperty`:
+
+```js
+var Bork = function Bork() {
+  babelHelpers.classCallCheck(this, Bork);
+  Object.defineProperty(this, "x", {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    value: 'bar'
+  });
+  Object.defineProperty(this, "y", {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    value: void 0
+  });
+};
+
+Object.defineProperty(Bork, "a", {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  value: 'foo'
+});
+Object.defineProperty(Bork, "b", {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  value: void 0
+});
+```
+
+However, with `{ "loose": true }`, it will compile using assignment expressions:
+
+```js
+var Bork = function Bork() {
+  babelHelpers.classCallCheck(this, Bork);
+  this.x = 'bar';
+  this.y = void 0;
+};
+
+Bork.a = 'foo';
+Bork.b = void 0;
+```
+
+## References
+
+* [Proposal: ES Class Fields & Static Properties](https://github.com/jeffmo/es-class-static-properties-and-fields)
diff --git a/node_modules/@babel/plugin-proposal-class-properties/lib/index.js b/node_modules/@babel/plugin-proposal-class-properties/lib/index.js
new file mode 100644
index 00000000..8ca749dd
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-class-properties/lib/index.js
@@ -0,0 +1,265 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperFunctionName() {
+  const data = _interopRequireDefault(require("@babel/helper-function-name"));
+
+  _helperFunctionName = function _helperFunctionName() {
+    return data;
+  };
+
+  return data;
+}
+
+function _pluginSyntaxClassProperties() {
+  const data = _interopRequireDefault(require("@babel/plugin-syntax-class-properties"));
+
+  _pluginSyntaxClassProperties = function _pluginSyntaxClassProperties() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperReplaceSupers() {
+  const data = require("@babel/helper-replace-supers");
+
+  _helperReplaceSupers = function _helperReplaceSupers() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _helperPluginUtils().declare)((api, options) => {
+  api.assertVersion(7);
+  const loose = options.loose;
+
+  const findBareSupers = _core().traverse.visitors.merge([{
+    Super(path) {
+      const node = path.node,
+            parentPath = path.parentPath;
+
+      if (parentPath.isCallExpression({
+        callee: node
+      })) {
+        this.push(parentPath);
+      }
+    }
+
+  }, _helperReplaceSupers().environmentVisitor]);
+
+  const referenceVisitor = {
+    "TSTypeAnnotation|TypeAnnotation"(path) {
+      path.skip();
+    },
+
+    ReferencedIdentifier(path) {
+      if (this.scope.hasOwnBinding(path.node.name)) {
+        this.scope.rename(path.node.name);
+        path.skip();
+      }
+    }
+
+  };
+
+  const classFieldDefinitionEvaluationTDZVisitor = _core().traverse.visitors.merge([{
+    ReferencedIdentifier(path) {
+      if (this.classRef === path.scope.getBinding(path.node.name)) {
+        const classNameTDZError = this.file.addHelper("classNameTDZError");
+
+        const throwNode = _core().types.callExpression(classNameTDZError, [_core().types.stringLiteral(path.node.name)]);
+
+        path.replaceWith(_core().types.sequenceExpression([throwNode, path.node]));
+        path.skip();
+      }
+    }
+
+  }, _helperReplaceSupers().environmentVisitor]);
+
+  const buildClassPropertySpec = (ref, {
+    key,
+    value,
+    computed
+  }, scope, state) => {
+    return _core().types.expressionStatement(_core().types.callExpression(state.addHelper("defineProperty"), [ref, _core().types.isIdentifier(key) && !computed ? _core().types.stringLiteral(key.name) : key, value || scope.buildUndefinedNode()]));
+  };
+
+  const buildClassPropertyLoose = (ref, {
+    key,
+    value,
+    computed
+  }, scope) => {
+    return _core().template.statement`MEMBER = VALUE`({
+      MEMBER: _core().types.memberExpression(_core().types.cloneNode(ref), key, computed || _core().types.isLiteral(key)),
+      VALUE: value || scope.buildUndefinedNode()
+    });
+  };
+
+  const buildClassProperty = loose ? buildClassPropertyLoose : buildClassPropertySpec;
+  return {
+    inherits: _pluginSyntaxClassProperties().default,
+    visitor: {
+      Class(path, state) {
+        const isDerived = !!path.node.superClass;
+        let constructor;
+        const props = [];
+        const computedPaths = [];
+        const body = path.get("body");
+
+        for (var _iterator = body.get("body"), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+          var _ref;
+
+          if (_isArray) {
+            if (_i >= _iterator.length) break;
+            _ref = _iterator[_i++];
+          } else {
+            _i = _iterator.next();
+            if (_i.done) break;
+            _ref = _i.value;
+          }
+
+          const path = _ref;
+
+          if (path.node.computed) {
+            computedPaths.push(path);
+          }
+
+          if (path.isClassProperty()) {
+            props.push(path);
+          } else if (path.isClassMethod({
+            kind: "constructor"
+          })) {
+            constructor = path;
+          }
+        }
+
+        if (!props.length) return;
+        let ref;
+
+        if (path.isClassExpression() || !path.node.id) {
+          (0, _helperFunctionName().default)(path);
+          ref = path.scope.generateUidIdentifier("class");
+        } else {
+          ref = path.node.id;
+        }
+
+        const computedNodes = [];
+        const staticNodes = [];
+        const instanceBody = [];
+
+        for (var _i2 = 0; _i2 < computedPaths.length; _i2++) {
+          const computedPath = computedPaths[_i2];
+          const computedNode = computedPath.node;
+
+          if (!computedPath.get("key").isConstantExpression()) {
+            computedPath.traverse(classFieldDefinitionEvaluationTDZVisitor, {
+              classRef: path.scope.getBinding(ref.name),
+              file: this.file
+            });
+            const ident = path.scope.generateUidIdentifierBasedOnNode(computedNode.key);
+            computedNodes.push(_core().types.variableDeclaration("var", [_core().types.variableDeclarator(ident, computedNode.key)]));
+            computedNode.key = _core().types.cloneNode(ident);
+          }
+        }
+
+        for (var _i3 = 0; _i3 < props.length; _i3++) {
+          const prop = props[_i3];
+          const propNode = prop.node;
+          if (propNode.decorators && propNode.decorators.length > 0) continue;
+
+          if (propNode.static) {
+            staticNodes.push(buildClassProperty(ref, propNode, path.scope, state));
+          } else {
+            instanceBody.push(buildClassProperty(_core().types.thisExpression(), propNode, path.scope, state));
+          }
+        }
+
+        if (instanceBody.length) {
+          if (!constructor) {
+            const newConstructor = _core().types.classMethod("constructor", _core().types.identifier("constructor"), [], _core().types.blockStatement([]));
+
+            if (isDerived) {
+              newConstructor.params = [_core().types.restElement(_core().types.identifier("args"))];
+              newConstructor.body.body.push(_core().types.returnStatement(_core().types.callExpression(_core().types.super(), [_core().types.spreadElement(_core().types.identifier("args"))])));
+            }
+
+            var _body$unshiftContaine = body.unshiftContainer("body", newConstructor);
+
+            constructor = _body$unshiftContaine[0];
+          }
+
+          const state = {
+            scope: constructor.scope
+          };
+
+          for (var _i4 = 0; _i4 < props.length; _i4++) {
+            const prop = props[_i4];
+            if (prop.node.static) continue;
+            prop.traverse(referenceVisitor, state);
+          }
+
+          if (isDerived) {
+            const bareSupers = [];
+            constructor.traverse(findBareSupers, bareSupers);
+
+            for (var _i5 = 0; _i5 < bareSupers.length; _i5++) {
+              const bareSuper = bareSupers[_i5];
+              bareSuper.insertAfter(instanceBody);
+            }
+          } else {
+            constructor.get("body").unshiftContainer("body", instanceBody);
+          }
+        }
+
+        for (var _i6 = 0; _i6 < props.length; _i6++) {
+          const prop = props[_i6];
+          prop.remove();
+        }
+
+        if (computedNodes.length === 0 && staticNodes.length === 0) return;
+
+        if (path.isClassExpression()) {
+          path.scope.push({
+            id: ref
+          });
+          path.replaceWith(_core().types.assignmentExpression("=", _core().types.cloneNode(ref), path.node));
+        } else if (!path.node.id) {
+          path.node.id = ref;
+        }
+
+        path.insertBefore(computedNodes);
+        path.insertAfter(staticNodes);
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-proposal-class-properties/package.json b/node_modules/@babel/plugin-proposal-class-properties/package.json
new file mode 100644
index 00000000..7dc7ffff
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-class-properties/package.json
@@ -0,0 +1,24 @@
+{
+  "name": "@babel/plugin-proposal-class-properties",
+  "version": "7.0.0-beta.47",
+  "description": "This plugin transforms static class properties as well as properties declared with the property initializer syntax",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-proposal-class-properties",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-function-name": "7.0.0-beta.47",
+    "@babel/helper-plugin-utils": "7.0.0-beta.47",
+    "@babel/helper-replace-supers": "7.0.0-beta.47",
+    "@babel/plugin-syntax-class-properties": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-proposal-decorators/README.md b/node_modules/@babel/plugin-proposal-decorators/README.md
new file mode 100644
index 00000000..b5bf1a1b
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-decorators/README.md
@@ -0,0 +1,126 @@
+# @babel/plugin-proposal-decorators
+
+> Compile class and object decorators to ES5
+
+## Example
+
+(examples are from proposal)
+
+### Simple class decorator
+
+```js
+@annotation
+class MyClass { }
+
+function annotation(target) {
+   target.annotated = true;
+}
+```
+
+### Class decorator
+
+```js
+@isTestable(true)
+class MyClass { }
+
+function isTestable(value) {
+   return function decorator(target) {
+      target.isTestable = value;
+   }
+}
+```
+
+### Class function decorator
+
+```js
+class C {
+  @enumerable(false)
+  method() { }
+}
+
+function enumerable(value) {
+  return function (target, key, descriptor) {
+     descriptor.enumerable = value;
+     return descriptor;
+  }
+}
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-proposal-decorators
+```
+
+## Usage
+
+Add the following line to your .babelrc file:
+
+```json
+{
+  "plugins": ["@babel/plugin-proposal-decorators"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-proposal-decorators script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-proposal-decorators"]
+});
+```
+
+## Options
+
+### `legacy`
+
+`boolean`, defaults to `false`.
+
+Use the legacy (stage 1) decorators syntax and behavior.
+
+#### NOTE: Compatibility with `@babel/plugin-proposal-class-properties`
+
+If you are including your plugins manually and using `@babel/plugin-proposal-class-properties`, make sure that `@babel/plugin-proposal-decorators` comes *before* `@babel/plugin-proposal-class-properties`.
+
+When using the `legacy: true` mode, `@babel/plugin-proposal-class-properties` must be used in `loose` mode to support the `@babel/plugin-proposal-decorators`.
+
+Wrong:
+
+```json
+{
+  "plugins": [
+    "@babel/plugin-proposal-class-properties",
+    "@babel/plugin-proposal-decorators"
+  ]
+}
+```
+
+Right:
+
+```json
+{
+  "plugins": [
+    "@babel/plugin-proposal-decorators",
+    "@babel/plugin-proposal-class-properties"
+  ]
+}
+```
+
+```json
+{
+  "plugins": [
+    ["@babel/plugin-proposal-decorators", { "legacy": true }],
+    ["@babel/plugin-proposal-class-properties", { "loose" : true }]
+  ]
+}
+```
+
+## References
+
+* [Proposal: JavaScript Decorators](https://github.com/wycats/javascript-decorators/blob/master/README.md)
diff --git a/node_modules/@babel/plugin-proposal-decorators/lib/index.js b/node_modules/@babel/plugin-proposal-decorators/lib/index.js
new file mode 100644
index 00000000..0a3b5eb1
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-decorators/lib/index.js
@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _pluginSyntaxDecorators() {
+  const data = _interopRequireDefault(require("@babel/plugin-syntax-decorators"));
+
+  _pluginSyntaxDecorators = function _pluginSyntaxDecorators() {
+    return data;
+  };
+
+  return data;
+}
+
+var _transformer = _interopRequireDefault(require("./transformer"));
+
+var _transformerLegacy = _interopRequireDefault(require("./transformer-legacy"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _helperPluginUtils().declare)((api, options) => {
+  api.assertVersion(7);
+  const _options$legacy = options.legacy,
+        legacy = _options$legacy === void 0 ? false : _options$legacy;
+
+  if (typeof legacy !== "boolean") {
+    throw new Error("'legacy' must be a boolean.");
+  }
+
+  if (legacy !== true) {
+    throw new Error("The new decorators proposal is not supported yet." + ' You must pass the `"legacy": true` option to' + " @babel/plugin-proposal-decorators");
+  }
+
+  return {
+    inherits: _pluginSyntaxDecorators().default,
+    visitor: legacy ? _transformerLegacy.default : _transformer.default
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-proposal-decorators/lib/transformer-legacy.js b/node_modules/@babel/plugin-proposal-decorators/lib/transformer-legacy.js
new file mode 100644
index 00000000..1b549d4b
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-decorators/lib/transformer-legacy.js
@@ -0,0 +1,159 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+const buildClassDecorator = (0, _core().template)(`
+  DECORATOR(CLASS_REF = INNER) || CLASS_REF;
+`);
+const buildClassPrototype = (0, _core().template)(`
+  CLASS_REF.prototype;
+`);
+const buildGetDescriptor = (0, _core().template)(`
+    Object.getOwnPropertyDescriptor(TARGET, PROPERTY);
+`);
+const buildGetObjectInitializer = (0, _core().template)(`
+    (TEMP = Object.getOwnPropertyDescriptor(TARGET, PROPERTY), (TEMP = TEMP ? TEMP.value : undefined), {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        initializer: function(){
+            return TEMP;
+        }
+    })
+`);
+const WARNING_CALLS = new WeakSet();
+
+function applyEnsureOrdering(path) {
+  const decorators = (path.isClass() ? [path].concat(path.get("body.body")) : path.get("properties")).reduce((acc, prop) => acc.concat(prop.node.decorators || []), []);
+  const identDecorators = decorators.filter(decorator => !_core().types.isIdentifier(decorator.callee));
+  if (identDecorators.length === 0) return;
+  return _core().types.sequenceExpression(identDecorators.map(decorator => {
+    const callee = decorator.callee;
+    const id = decorator.callee = path.scope.generateDeclaredUidIdentifier("dec");
+    return _core().types.assignmentExpression("=", id, callee);
+  }).concat([path.node]));
+}
+
+function applyClassDecorators(classPath) {
+  if (!hasClassDecorators(classPath.node)) return;
+  const decorators = classPath.node.decorators || [];
+  classPath.node.decorators = null;
+  const name = classPath.scope.generateDeclaredUidIdentifier("class");
+  return decorators.map(dec => dec.callee).reverse().reduce(function (acc, decorator) {
+    return buildClassDecorator({
+      CLASS_REF: _core().types.cloneNode(name),
+      DECORATOR: _core().types.cloneNode(decorator),
+      INNER: acc
+    }).expression;
+  }, classPath.node);
+}
+
+function hasClassDecorators(classNode) {
+  return !!(classNode.decorators && classNode.decorators.length);
+}
+
+function applyMethodDecorators(path, state) {
+  if (!hasMethodDecorators(path.node.body.body)) return;
+  return applyTargetDecorators(path, state, path.node.body.body);
+}
+
+function hasMethodDecorators(body) {
+  return body.some(node => node.decorators && node.decorators.length);
+}
+
+function applyObjectDecorators(path, state) {
+  if (!hasMethodDecorators(path.node.properties)) return;
+  return applyTargetDecorators(path, state, path.node.properties);
+}
+
+function applyTargetDecorators(path, state, decoratedProps) {
+  const name = path.scope.generateDeclaredUidIdentifier(path.isClass() ? "class" : "obj");
+  const exprs = decoratedProps.reduce(function (acc, node) {
+    const decorators = node.decorators || [];
+    node.decorators = null;
+    if (decorators.length === 0) return acc;
+
+    if (node.computed) {
+      throw path.buildCodeFrameError("Computed method/property decorators are not yet supported.");
+    }
+
+    const property = _core().types.isLiteral(node.key) ? node.key : _core().types.stringLiteral(node.key.name);
+    const target = path.isClass() && !node.static ? buildClassPrototype({
+      CLASS_REF: name
+    }).expression : name;
+
+    if (_core().types.isClassProperty(node, {
+      static: false
+    })) {
+      const descriptor = path.scope.generateDeclaredUidIdentifier("descriptor");
+      const initializer = node.value ? _core().types.functionExpression(null, [], _core().types.blockStatement([_core().types.returnStatement(node.value)])) : _core().types.nullLiteral();
+      node.value = _core().types.callExpression(state.addHelper("initializerWarningHelper"), [descriptor, _core().types.thisExpression()]);
+      WARNING_CALLS.add(node.value);
+      acc = acc.concat([_core().types.assignmentExpression("=", descriptor, _core().types.callExpression(state.addHelper("applyDecoratedDescriptor"), [_core().types.cloneNode(target), _core().types.cloneNode(property), _core().types.arrayExpression(decorators.map(dec => _core().types.cloneNode(dec.callee))), _core().types.objectExpression([_core().types.objectProperty(_core().types.identifier("enumerable"), _core().types.booleanLiteral(true)), _core().types.objectProperty(_core().types.identifier("initializer"), initializer)])]))]);
+    } else {
+      acc = acc.concat(_core().types.callExpression(state.addHelper("applyDecoratedDescriptor"), [_core().types.cloneNode(target), _core().types.cloneNode(property), _core().types.arrayExpression(decorators.map(dec => _core().types.cloneNode(dec.callee))), _core().types.isObjectProperty(node) || _core().types.isClassProperty(node, {
+        static: true
+      }) ? buildGetObjectInitializer({
+        TEMP: path.scope.generateDeclaredUidIdentifier("init"),
+        TARGET: _core().types.cloneNode(target),
+        PROPERTY: _core().types.cloneNode(property)
+      }).expression : buildGetDescriptor({
+        TARGET: _core().types.cloneNode(target),
+        PROPERTY: _core().types.cloneNode(property)
+      }).expression, _core().types.cloneNode(target)]));
+    }
+
+    return acc;
+  }, []);
+  return _core().types.sequenceExpression([_core().types.assignmentExpression("=", _core().types.cloneNode(name), path.node), _core().types.sequenceExpression(exprs), _core().types.cloneNode(name)]);
+}
+
+var _default = {
+  ClassDeclaration(path) {
+    const node = path.node;
+
+    if (!hasClassDecorators(node) && !hasMethodDecorators(node.body.body)) {
+      return;
+    }
+
+    const ref = node.id ? _core().types.cloneNode(node.id) : path.scope.generateUidIdentifier("class");
+
+    const letDeclaration = _core().types.variableDeclaration("let", [_core().types.variableDeclarator(ref, _core().types.toExpression(node))]);
+
+    if (path.parentPath.isExportDefaultDeclaration()) {
+      path.parentPath.replaceWithMultiple([letDeclaration, _core().types.exportNamedDeclaration(null, [_core().types.exportSpecifier(_core().types.cloneNode(ref), _core().types.identifier("default"))])]);
+    } else {
+      path.replaceWith(letDeclaration);
+    }
+  },
+
+  ClassExpression(path, state) {
+    const decoratedClass = applyEnsureOrdering(path) || applyClassDecorators(path, state) || applyMethodDecorators(path, state);
+    if (decoratedClass) path.replaceWith(decoratedClass);
+  },
+
+  ObjectExpression(path, state) {
+    const decoratedObject = applyEnsureOrdering(path) || applyObjectDecorators(path, state);
+    if (decoratedObject) path.replaceWith(decoratedObject);
+  },
+
+  AssignmentExpression(path, state) {
+    if (!WARNING_CALLS.has(path.node.right)) return;
+    path.replaceWith(_core().types.callExpression(state.addHelper("initializerDefineProperty"), [_core().types.cloneNode(path.get("left.object").node), _core().types.stringLiteral(path.get("left.property").node.name), _core().types.cloneNode(path.get("right.arguments")[0].node), _core().types.cloneNode(path.get("right.arguments")[1].node)]));
+  }
+
+};
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-proposal-decorators/lib/transformer.js b/node_modules/@babel/plugin-proposal-decorators/lib/transformer.js
new file mode 100644
index 00000000..4e7a7b3f
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-decorators/lib/transformer.js
@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = {};
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-proposal-decorators/package.json b/node_modules/@babel/plugin-proposal-decorators/package.json
new file mode 100644
index 00000000..1a35ad49
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-decorators/package.json
@@ -0,0 +1,25 @@
+{
+  "name": "@babel/plugin-proposal-decorators",
+  "version": "7.0.0-beta.47",
+  "author": "Logan Smyth <loganfsmyth@gmail.com>",
+  "license": "MIT",
+  "description": "Compile class and object decorators to ES5",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-proposal-decorators",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel",
+    "babel-plugin",
+    "decorators"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47",
+    "@babel/plugin-syntax-decorators": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-proposal-export-namespace-from/README.md b/node_modules/@babel/plugin-proposal-export-namespace-from/README.md
new file mode 100644
index 00000000..bb4ff789
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-export-namespace-from/README.md
@@ -0,0 +1,45 @@
+# @babel/plugin-proposal-export-namespace-from
+
+> Compile export-ns-from statements to ES2015
+
+## Example
+
+```js
+export * as ns from 'mod';
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-proposal-export-namespace-from
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-proposal-export-namespace-from"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-proposal-export-namespace-from script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-proposal-export-namespace-from"]
+});
+```
+## References
+
+* ~~[Proposal: Additional export-from statements in ES7](https://github.com/leebyron/ecmascript-more-export-from)~~ (Withdrawn)
+* [ECMAScript Proposal: export ns from](https://github.com/leebyron/ecmascript-export-ns-from)
diff --git a/node_modules/@babel/plugin-proposal-export-namespace-from/lib/index.js b/node_modules/@babel/plugin-proposal-export-namespace-from/lib/index.js
new file mode 100644
index 00000000..18050b20
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-export-namespace-from/lib/index.js
@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _pluginSyntaxExportNamespaceFrom() {
+  const data = _interopRequireDefault(require("@babel/plugin-syntax-export-namespace-from"));
+
+  _pluginSyntaxExportNamespaceFrom = function _pluginSyntaxExportNamespaceFrom() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+  return {
+    inherits: _pluginSyntaxExportNamespaceFrom().default,
+    visitor: {
+      ExportNamedDeclaration(path) {
+        const node = path.node,
+              scope = path.scope;
+        const specifiers = node.specifiers;
+        const index = _core().types.isExportDefaultSpecifier(specifiers[0]) ? 1 : 0;
+        if (!_core().types.isExportNamespaceSpecifier(specifiers[index])) return;
+        const nodes = [];
+
+        if (index === 1) {
+          nodes.push(_core().types.exportNamedDeclaration(null, [specifiers.shift()], node.source));
+        }
+
+        const specifier = specifiers.shift();
+        const exported = specifier.exported;
+        const uid = scope.generateUidIdentifier(exported.name);
+        nodes.push(_core().types.importDeclaration([_core().types.importNamespaceSpecifier(uid)], _core().types.cloneNode(node.source)), _core().types.exportNamedDeclaration(null, [_core().types.exportSpecifier(_core().types.cloneNode(uid), exported)]));
+
+        if (node.specifiers.length >= 1) {
+          nodes.push(node);
+        }
+
+        path.replaceWithMultiple(nodes);
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-proposal-export-namespace-from/package.json b/node_modules/@babel/plugin-proposal-export-namespace-from/package.json
new file mode 100644
index 00000000..1461558e
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-export-namespace-from/package.json
@@ -0,0 +1,22 @@
+{
+  "name": "@babel/plugin-proposal-export-namespace-from",
+  "version": "7.0.0-beta.47",
+  "description": "Compile export namespace to ES2015",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-proposal-export-namespace-from",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47",
+    "@babel/plugin-syntax-export-namespace-from": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-proposal-function-sent/README.md b/node_modules/@babel/plugin-proposal-function-sent/README.md
new file mode 100644
index 00000000..9c498491
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-function-sent/README.md
@@ -0,0 +1,66 @@
+# @babel/plugin-proposal-function-sent
+
+> Compile the `function.sent` meta property, used inside generator functions, to valid ES2015 code.
+
+## Example
+
+```js
+function* generator() {
+    console.log("Sent", function.sent);
+    console.log("Yield", yield);
+}
+
+const iterator = generator();
+iterator.next(1); // Logs "Sent 1"
+iterator.next(2); // Logs "Yield 2"
+```
+
+Is compiled roughly to
+
+```js
+let generator = _skipFirstGeneratorNext(function* () {
+    const _functionSent = yield;
+    console.log("Sent", _functionSent);
+    console.log("Yield", yield);
+});
+
+const iterator = generator();
+iterator.next(1); // Logs "Sent 1"
+iterator.next(2); // Logs "Yield 1"
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-proposal-function-sent
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-proposal-function-sent"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-proposal-function-sent script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-proposal-function-sent"]
+});
+```
+
+## References
+
+* [Proposal](https://github.com/allenwb/ESideas/blob/master/Generator%20metaproperty.md)
diff --git a/node_modules/@babel/plugin-proposal-function-sent/lib/index.js b/node_modules/@babel/plugin-proposal-function-sent/lib/index.js
new file mode 100644
index 00000000..d42d5d7f
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-function-sent/lib/index.js
@@ -0,0 +1,104 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _pluginSyntaxFunctionSent() {
+  const data = _interopRequireDefault(require("@babel/plugin-syntax-function-sent"));
+
+  _pluginSyntaxFunctionSent = function _pluginSyntaxFunctionSent() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperWrapFunction() {
+  const data = _interopRequireDefault(require("@babel/helper-wrap-function"));
+
+  _helperWrapFunction = function _helperWrapFunction() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+
+  const isFunctionSent = node => _core().types.isIdentifier(node.meta, {
+    name: "function"
+  }) && _core().types.isIdentifier(node.property, {
+    name: "sent"
+  });
+
+  const hasBeenReplaced = (node, sentId) => _core().types.isAssignmentExpression(node) && _core().types.isIdentifier(node.left, {
+    name: sentId
+  });
+
+  const yieldVisitor = {
+    Function(path) {
+      path.skip();
+    },
+
+    YieldExpression(path) {
+      if (!hasBeenReplaced(path.parent, this.sentId)) {
+        path.replaceWith(_core().types.assignmentExpression("=", _core().types.identifier(this.sentId), path.node));
+      }
+    },
+
+    MetaProperty(path) {
+      if (isFunctionSent(path.node)) {
+        path.replaceWith(_core().types.identifier(this.sentId));
+      }
+    }
+
+  };
+  return {
+    inherits: _pluginSyntaxFunctionSent().default,
+    visitor: {
+      MetaProperty(path, state) {
+        if (!isFunctionSent(path.node)) return;
+        const fnPath = path.getFunctionParent();
+
+        if (!fnPath.node.generator) {
+          throw new Error("Parent generator function not found");
+        }
+
+        const sentId = path.scope.generateUid("function.sent");
+        fnPath.traverse(yieldVisitor, {
+          sentId
+        });
+        fnPath.node.body.body.unshift(_core().types.variableDeclaration("let", [_core().types.variableDeclarator(_core().types.identifier(sentId), _core().types.yieldExpression())]));
+        (0, _helperWrapFunction().default)(fnPath, state.addHelper("skipFirstGeneratorNext"));
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-proposal-function-sent/package.json b/node_modules/@babel/plugin-proposal-function-sent/package.json
new file mode 100644
index 00000000..7f0562fa
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-function-sent/package.json
@@ -0,0 +1,23 @@
+{
+  "name": "@babel/plugin-proposal-function-sent",
+  "version": "7.0.0-beta.47",
+  "description": "Compile the function.sent meta propety to valid ES2015 code",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-proposal-function-sent",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47",
+    "@babel/helper-wrap-function": "7.0.0-beta.47",
+    "@babel/plugin-syntax-function-sent": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-proposal-numeric-separator/README.md b/node_modules/@babel/plugin-proposal-numeric-separator/README.md
new file mode 100644
index 00000000..4dcde023
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-numeric-separator/README.md
@@ -0,0 +1,114 @@
+# @babel/plugin-proposal-numeric-separator
+
+> This plugin allows Babel to transform Decimal, Binary, Hex and Octal literals containing Numeric Literal Separator to their non-separated form.
+
+## Example
+
+### Decimal Literals
+
+```js
+let budget = 1_000_000_000_000;
+
+// What is the value of `budget`? It's 1 trillion!
+//
+// Let's confirm:
+console.log(budget === 10 ** 12); // true
+```
+
+### Binary Literals
+
+```js
+let nibbles = 0b1010_0001_1000_0101;
+
+// Is bit 7 on? It sure is!
+// 0b1010_0001_1000_0101
+//             ^
+//
+// We can double check:
+console.log(!!(nibbles & (1 << 7))); // true
+```
+
+### Hex Literal
+
+```js
+// Messages are sent as 24 bit values, but should be
+// treated as 3 distinct bytes:
+let message = 0xA0_B0_C0;
+
+// What's the value of the upper most byte? It's A0, or 160.
+// We can confirm that:
+let a = (message >> 16) & 0xFF;
+console.log(a.toString(16), a); // a0, 160
+
+// What's the value of the middle byte? It's B0, or 176.
+// Let's just make sure...
+let b = (message >> 8) & 0xFF;
+console.log(b.toString(16), b); // b0, 176
+
+// What's the value of the lower most byte? It's C0, or 192.
+// Again, let's prove that:
+let c = message & 0xFF;
+console.log(c.toString(16), b); // c0, 192
+```
+
+### Octal Literal
+
+*hand wave emoji*
+
+Octals are great for permissions, but also look better when represented in `0o0000` form. No real benefit with separators here.
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-proposal-numeric-separator
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-proposal-numeric-separator"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-proposal-numeric-separator script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-proposal-numeric-separator"]
+});
+```
+
+## Additional Information
+
+If you need to further compile ES2015 Decimal, Binary, Hex and Octal number representations to their pre-ES2015 numeric literal form, add the [`"@babel/plugin-transform-literals"`](http://babeljs.io/docs/plugins/transform-literals/) plugin:
+
+> `@babel/plugin-transform-literals` is already included in [@babel/preset-env](https://github.com/babel/babel/tree/master/packages/babel-preset-env) and @babel/preset-es2015.
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "presets": ["@babel/preset-env"],
+  "plugins": ["@babel/plugin-proposal-numeric-separator"]
+}
+{
+  "plugins": ["@babel/plugin-proposal-numeric-separator", "@babel/plugin-transform-literals"]
+}
+```
+
+## References
+
+* [Proposal: Numeric Separators](https://github.com/samuelgoto/proposal-numeric-separator)
diff --git a/node_modules/@babel/plugin-proposal-numeric-separator/lib/index.js b/node_modules/@babel/plugin-proposal-numeric-separator/lib/index.js
new file mode 100644
index 00000000..6755bbe8
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-numeric-separator/lib/index.js
@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _pluginSyntaxNumericSeparator() {
+  const data = _interopRequireDefault(require("@babel/plugin-syntax-numeric-separator"));
+
+  _pluginSyntaxNumericSeparator = function _pluginSyntaxNumericSeparator() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+
+  function replaceNumberArg({
+    node
+  }) {
+    if (node.callee.name !== "Number") {
+      return;
+    }
+
+    const arg = node.arguments[0];
+
+    if (!_core().types.isStringLiteral(arg)) {
+      return;
+    }
+
+    arg.value = arg.value.replace(/_/g, "");
+  }
+
+  return {
+    inherits: _pluginSyntaxNumericSeparator().default,
+    visitor: {
+      CallExpression: replaceNumberArg,
+      NewExpression: replaceNumberArg,
+
+      NumericLiteral({
+        node
+      }) {
+        const extra = node.extra;
+
+        if (extra && /_/.test(extra.raw)) {
+          extra.raw = extra.raw.replace(/_/g, "");
+        }
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-proposal-numeric-separator/package.json b/node_modules/@babel/plugin-proposal-numeric-separator/package.json
new file mode 100644
index 00000000..0e02038e
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-numeric-separator/package.json
@@ -0,0 +1,22 @@
+{
+  "name": "@babel/plugin-proposal-numeric-separator",
+  "version": "7.0.0-beta.47",
+  "description": "Remove numeric separators from Decimal, Binary, Hex and Octal literals",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-proposal-numeric-separator",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47",
+    "@babel/plugin-syntax-numeric-separator": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-proposal-object-rest-spread/README.md b/node_modules/@babel/plugin-proposal-object-rest-spread/README.md
new file mode 100644
index 00000000..9c1b785b
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-object-rest-spread/README.md
@@ -0,0 +1,105 @@
+# @babel/plugin-proposal-object-rest-spread
+
+> This plugin allows Babel to transform rest properties for object destructuring assignment and spread properties for object literals.
+
+## Example
+
+### Rest Properties
+
+```js
+let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
+console.log(x); // 1
+console.log(y); // 2
+console.log(z); // { a: 3, b: 4 }
+```
+
+### Spread Properties
+
+```js
+let n = { x, y, ...z };
+console.log(n); // { x: 1, y: 2, a: 3, b: 4 }
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-proposal-object-rest-spread
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-proposal-object-rest-spread"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-proposal-object-rest-spread script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-proposal-object-rest-spread"]
+});
+```
+
+## Options
+
+By default, this plugin will produce spec compliant code by using Babel's `objectSpread` helper.
+
+### `loose`
+
+`boolean`, defaults to `false`.
+
+Enabling this option will use Babel's `extends` helper, which is basically the same as `Object.assign` (see `useBuiltIns` below to use it directly).
+
+:warning: Please keep in mind that even if they're almost equivalent, there's an important difference between spread and `Object.assign`: **spread _defines_ new properties, while `Object.assign()` _sets_ them**, so using this mode might produce unexpected results in some cases.
+
+For detailed information please check out [Spread VS. Object.assign](http://2ality.com/2016/10/rest-spread-properties.html#spreading-objects-versus-objectassign) and [Assigning VS. defining properties](http://exploringjs.com/es6/ch_oop-besides-classes.html#sec_assigning-vs-defining-properties).
+
+
+### `useBuiltIns`
+
+`boolean`, defaults to `false`.
+
+Enabling this option will use `Object.assign` directly instead of the Babel's `extends` helper. 
+
+##### Example
+
+**.babelrc**
+
+```json
+{
+  "plugins": [
+    ["@babel/plugin-proposal-object-rest-spread", { "loose": true, "useBuiltIns": true }]
+  ]
+}
+```
+
+**In**
+
+```js
+z = { x, ...y };
+```
+
+**Out**
+
+```js
+z = Object.assign({ x }, y);
+```
+
+## References
+
+* [Proposal: Object Rest/Spread Properties for ECMAScript](https://github.com/sebmarkbage/ecmascript-rest-spread)
+* [Spec](http://sebmarkbage.github.io/ecmascript-rest-spread)
+* [Spread VS. Object.assign](http://2ality.com/2016/10/rest-spread-properties.html#spreading-objects-versus-objectassign)
+* [Assigning VS. defining properties](http://exploringjs.com/es6/ch_oop-besides-classes.html#sec_assigning-vs-defining-properties)
diff --git a/node_modules/@babel/plugin-proposal-object-rest-spread/lib/index.js b/node_modules/@babel/plugin-proposal-object-rest-spread/lib/index.js
new file mode 100644
index 00000000..4dcc6dc9
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-object-rest-spread/lib/index.js
@@ -0,0 +1,404 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _pluginSyntaxObjectRestSpread() {
+  const data = _interopRequireDefault(require("@babel/plugin-syntax-object-rest-spread"));
+
+  _pluginSyntaxObjectRestSpread = function _pluginSyntaxObjectRestSpread() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _helperPluginUtils().declare)((api, opts) => {
+  api.assertVersion(7);
+  const _opts$useBuiltIns = opts.useBuiltIns,
+        useBuiltIns = _opts$useBuiltIns === void 0 ? false : _opts$useBuiltIns,
+        _opts$loose = opts.loose,
+        loose = _opts$loose === void 0 ? false : _opts$loose;
+
+  if (typeof loose !== "boolean") {
+    throw new Error(".loose must be a boolean, or undefined");
+  }
+
+  function getExtendsHelper(file) {
+    return useBuiltIns ? _core().types.memberExpression(_core().types.identifier("Object"), _core().types.identifier("assign")) : file.addHelper("extends");
+  }
+
+  function hasRestElement(path) {
+    let foundRestElement = false;
+    visitRestElements(path, () => {
+      foundRestElement = true;
+      path.stop();
+    });
+    return foundRestElement;
+  }
+
+  function visitRestElements(path, visitor) {
+    path.traverse({
+      Expression(path) {
+        const parentType = path.parent.type;
+
+        if (parentType == "AssignmentPattern" && path.key === "right" || parentType == "ObjectProperty" && path.parent.computed && path.key === "key") {
+          path.skip();
+        }
+      },
+
+      RestElement: visitor
+    });
+  }
+
+  function hasSpread(node) {
+    for (var _iterator = node.properties, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i >= _iterator.length) break;
+        _ref = _iterator[_i++];
+      } else {
+        _i = _iterator.next();
+        if (_i.done) break;
+        _ref = _i.value;
+      }
+
+      const prop = _ref;
+
+      if (_core().types.isSpreadElement(prop)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  function extractNormalizedKeys(path) {
+    const props = path.node.properties;
+    const keys = [];
+    let allLiteral = true;
+
+    for (var _iterator2 = props, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+      var _ref2;
+
+      if (_isArray2) {
+        if (_i2 >= _iterator2.length) break;
+        _ref2 = _iterator2[_i2++];
+      } else {
+        _i2 = _iterator2.next();
+        if (_i2.done) break;
+        _ref2 = _i2.value;
+      }
+
+      const prop = _ref2;
+
+      if (_core().types.isIdentifier(prop.key) && !prop.computed) {
+        keys.push(_core().types.stringLiteral(prop.key.name));
+      } else if (_core().types.isLiteral(prop.key)) {
+        keys.push(_core().types.stringLiteral(String(prop.key.value)));
+      } else {
+        keys.push(_core().types.cloneNode(prop.key));
+        allLiteral = false;
+      }
+    }
+
+    return {
+      keys,
+      allLiteral
+    };
+  }
+
+  function replaceImpureComputedKeys(path) {
+    const impureComputedPropertyDeclarators = [];
+
+    for (var _iterator3 = path.get("properties"), _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
+      var _ref3;
+
+      if (_isArray3) {
+        if (_i3 >= _iterator3.length) break;
+        _ref3 = _iterator3[_i3++];
+      } else {
+        _i3 = _iterator3.next();
+        if (_i3.done) break;
+        _ref3 = _i3.value;
+      }
+
+      const propPath = _ref3;
+      const key = propPath.get("key");
+
+      if (propPath.node.computed && !key.isPure()) {
+        const name = path.scope.generateUidBasedOnNode(key.node);
+
+        const declarator = _core().types.variableDeclarator(_core().types.identifier(name), key.node);
+
+        impureComputedPropertyDeclarators.push(declarator);
+        key.replaceWith(_core().types.identifier(name));
+      }
+    }
+
+    return impureComputedPropertyDeclarators;
+  }
+
+  function createObjectSpread(path, file, objRef) {
+    const props = path.get("properties");
+    const last = props[props.length - 1];
+
+    _core().types.assertRestElement(last.node);
+
+    const restElement = _core().types.cloneNode(last.node);
+
+    last.remove();
+    const impureComputedPropertyDeclarators = replaceImpureComputedKeys(path);
+
+    const _extractNormalizedKey = extractNormalizedKeys(path),
+          keys = _extractNormalizedKey.keys,
+          allLiteral = _extractNormalizedKey.allLiteral;
+
+    if (keys.length === 0) {
+      return [impureComputedPropertyDeclarators, restElement.argument, _core().types.callExpression(getExtendsHelper(file), [_core().types.objectExpression([]), _core().types.cloneNode(objRef)])];
+    }
+
+    let keyExpression;
+
+    if (!allLiteral) {
+      keyExpression = _core().types.callExpression(_core().types.memberExpression(_core().types.arrayExpression(keys), _core().types.identifier("map")), [file.addHelper("toPropertyKey")]);
+    } else {
+      keyExpression = _core().types.arrayExpression(keys);
+    }
+
+    return [impureComputedPropertyDeclarators, restElement.argument, _core().types.callExpression(file.addHelper("objectWithoutProperties"), [_core().types.cloneNode(objRef), keyExpression])];
+  }
+
+  function replaceRestElement(parentPath, paramPath, i, numParams) {
+    if (paramPath.isAssignmentPattern()) {
+      replaceRestElement(parentPath, paramPath.get("left"), i, numParams);
+      return;
+    }
+
+    if (paramPath.isArrayPattern() && hasRestElement(paramPath)) {
+      const elements = paramPath.get("elements");
+
+      for (let i = 0; i < elements.length; i++) {
+        replaceRestElement(parentPath, elements[i], i, elements.length);
+      }
+    }
+
+    if (paramPath.isObjectPattern() && hasRestElement(paramPath)) {
+      const uid = parentPath.scope.generateUidIdentifier("ref");
+
+      const declar = _core().types.variableDeclaration("let", [_core().types.variableDeclarator(paramPath.node, uid)]);
+
+      parentPath.ensureBlock();
+      parentPath.get("body").unshiftContainer("body", declar);
+      paramPath.replaceWith(_core().types.cloneNode(uid));
+    }
+  }
+
+  return {
+    inherits: _pluginSyntaxObjectRestSpread().default,
+    visitor: {
+      Function(path) {
+        const params = path.get("params");
+
+        for (let i = params.length - 1; i >= 0; i--) {
+          replaceRestElement(params[i].parentPath, params[i], i, params.length);
+        }
+      },
+
+      VariableDeclarator(path, file) {
+        if (!path.get("id").isObjectPattern()) {
+          return;
+        }
+
+        let insertionPath = path;
+        const originalPath = path;
+        visitRestElements(path.get("id"), path => {
+          if (!path.parentPath.isObjectPattern()) {
+            return;
+          }
+
+          if (originalPath.node.id.properties.length > 1 && !_core().types.isIdentifier(originalPath.node.init)) {
+            const initRef = path.scope.generateUidIdentifierBasedOnNode(originalPath.node.init, "ref");
+            originalPath.insertBefore(_core().types.variableDeclarator(initRef, originalPath.node.init));
+            originalPath.replaceWith(_core().types.variableDeclarator(originalPath.node.id, _core().types.cloneNode(initRef)));
+            return;
+          }
+
+          let ref = originalPath.node.init;
+          const refPropertyPath = [];
+          let kind;
+          path.findParent(path => {
+            if (path.isObjectProperty()) {
+              refPropertyPath.unshift(path.node.key.name);
+            } else if (path.isVariableDeclarator()) {
+              kind = path.parentPath.node.kind;
+              return true;
+            }
+          });
+
+          if (refPropertyPath.length) {
+            refPropertyPath.forEach(prop => {
+              ref = _core().types.memberExpression(ref, _core().types.identifier(prop));
+            });
+          }
+
+          const objectPatternPath = path.findParent(path => path.isObjectPattern());
+
+          const _createObjectSpread = createObjectSpread(objectPatternPath, file, ref),
+                impureComputedPropertyDeclarators = _createObjectSpread[0],
+                argument = _createObjectSpread[1],
+                callExpression = _createObjectSpread[2];
+
+          _core().types.assertIdentifier(argument);
+
+          insertionPath.insertBefore(impureComputedPropertyDeclarators);
+          insertionPath.insertAfter(_core().types.variableDeclarator(argument, callExpression));
+          insertionPath = insertionPath.getSibling(insertionPath.key + 1);
+          path.scope.registerBinding(kind, insertionPath);
+
+          if (objectPatternPath.node.properties.length === 0) {
+            objectPatternPath.findParent(path => path.isObjectProperty() || path.isVariableDeclarator()).remove();
+          }
+        });
+      },
+
+      ExportNamedDeclaration(path) {
+        const declaration = path.get("declaration");
+        if (!declaration.isVariableDeclaration()) return;
+        const hasRest = declaration.get("declarations").some(path => hasRestElement(path.get("id")));
+        if (!hasRest) return;
+        const specifiers = [];
+
+        for (const name in path.getOuterBindingIdentifiers(path)) {
+          specifiers.push(_core().types.exportSpecifier(_core().types.identifier(name), _core().types.identifier(name)));
+        }
+
+        path.replaceWith(declaration.node);
+        path.insertAfter(_core().types.exportNamedDeclaration(null, specifiers));
+      },
+
+      CatchClause(path) {
+        const paramPath = path.get("param");
+        replaceRestElement(paramPath.parentPath, paramPath);
+      },
+
+      AssignmentExpression(path, file) {
+        const leftPath = path.get("left");
+
+        if (leftPath.isObjectPattern() && hasRestElement(leftPath)) {
+          const nodes = [];
+          const refName = path.scope.generateUidBasedOnNode(path.node.right, "ref");
+          nodes.push(_core().types.variableDeclaration("var", [_core().types.variableDeclarator(_core().types.identifier(refName), path.node.right)]));
+
+          const _createObjectSpread2 = createObjectSpread(leftPath, file, _core().types.identifier(refName)),
+                impureComputedPropertyDeclarators = _createObjectSpread2[0],
+                argument = _createObjectSpread2[1],
+                callExpression = _createObjectSpread2[2];
+
+          if (impureComputedPropertyDeclarators.length > 0) {
+            nodes.push(_core().types.variableDeclaration("var", impureComputedPropertyDeclarators));
+          }
+
+          const nodeWithoutSpread = _core().types.cloneNode(path.node);
+
+          nodeWithoutSpread.right = _core().types.identifier(refName);
+          nodes.push(_core().types.expressionStatement(nodeWithoutSpread));
+          nodes.push(_core().types.toStatement(_core().types.assignmentExpression("=", argument, callExpression)));
+          nodes.push(_core().types.expressionStatement(_core().types.identifier(refName)));
+          path.replaceWithMultiple(nodes);
+        }
+      },
+
+      ForXStatement(path) {
+        const node = path.node,
+              scope = path.scope;
+        const leftPath = path.get("left");
+        const left = node.left;
+
+        if (_core().types.isObjectPattern(left) && hasRestElement(leftPath)) {
+          const temp = scope.generateUidIdentifier("ref");
+          node.left = _core().types.variableDeclaration("var", [_core().types.variableDeclarator(temp)]);
+          path.ensureBlock();
+          node.body.body.unshift(_core().types.variableDeclaration("var", [_core().types.variableDeclarator(left, _core().types.cloneNode(temp))]));
+          return;
+        }
+
+        if (!_core().types.isVariableDeclaration(left)) return;
+        const pattern = left.declarations[0].id;
+        if (!_core().types.isObjectPattern(pattern)) return;
+        const key = scope.generateUidIdentifier("ref");
+        node.left = _core().types.variableDeclaration(left.kind, [_core().types.variableDeclarator(key, null)]);
+        path.ensureBlock();
+        node.body.body.unshift(_core().types.variableDeclaration(node.left.kind, [_core().types.variableDeclarator(pattern, _core().types.cloneNode(key))]));
+      },
+
+      ObjectExpression(path, file) {
+        if (!hasSpread(path.node)) return;
+        const args = [];
+        let props = [];
+
+        function push() {
+          if (!props.length) return;
+          args.push(_core().types.objectExpression(props));
+          props = [];
+        }
+
+        if (_core().types.isSpreadElement(path.node.properties[0])) {
+          args.push(_core().types.objectExpression([]));
+        }
+
+        var _arr = path.node.properties;
+
+        for (var _i4 = 0; _i4 < _arr.length; _i4++) {
+          const prop = _arr[_i4];
+
+          if (_core().types.isSpreadElement(prop)) {
+            push();
+            args.push(prop.argument);
+          } else {
+            props.push(prop);
+          }
+        }
+
+        push();
+        let helper;
+
+        if (loose) {
+          helper = getExtendsHelper(file);
+        } else {
+          helper = file.addHelper("objectSpread");
+        }
+
+        path.replaceWith(_core().types.callExpression(helper, args));
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-proposal-object-rest-spread/package.json b/node_modules/@babel/plugin-proposal-object-rest-spread/package.json
new file mode 100644
index 00000000..a9cf27e4
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-object-rest-spread/package.json
@@ -0,0 +1,22 @@
+{
+  "name": "@babel/plugin-proposal-object-rest-spread",
+  "version": "7.0.0-beta.47",
+  "description": "Compile object rest and spread to ES5",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-proposal-object-rest-spread",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47",
+    "@babel/plugin-syntax-object-rest-spread": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-proposal-optional-catch-binding/README.md b/node_modules/@babel/plugin-proposal-optional-catch-binding/README.md
new file mode 100644
index 00000000..e06eb65d
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-optional-catch-binding/README.md
@@ -0,0 +1,60 @@
+# @babel/plugin-proposal-optional-catch-binding
+
+> Optional catch binding enables the catch block to execute whether or not an argument is passed to the catch statement (CatchClause).
+
+
+## Examples
+
+```js
+try {
+  throw 0;
+} catch {
+  doSomethingWhichDoesntCareAboutTheValueThrown();
+}
+```
+
+```js
+try {
+  throw 0;
+} catch {
+  doSomethingWhichDoesntCareAboutTheValueThrown();
+} finally {
+  doSomeCleanup();
+}
+```
+
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-proposal-optional-catch-binding
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-proposal-optional-catch-binding"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-proposal-optional-catch-binding script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-proposal-optional-catch-binding"]
+});
+```
+
+## References
+- [Proposal: Optional Catch Binding for ECMAScript](https://github.com/babel/proposals/issues/7)
diff --git a/node_modules/@babel/plugin-proposal-optional-catch-binding/lib/index.js b/node_modules/@babel/plugin-proposal-optional-catch-binding/lib/index.js
new file mode 100644
index 00000000..e87c22c4
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-optional-catch-binding/lib/index.js
@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _pluginSyntaxOptionalCatchBinding() {
+  const data = _interopRequireDefault(require("@babel/plugin-syntax-optional-catch-binding"));
+
+  _pluginSyntaxOptionalCatchBinding = function _pluginSyntaxOptionalCatchBinding() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+  return {
+    inherits: _pluginSyntaxOptionalCatchBinding().default,
+    visitor: {
+      CatchClause(path) {
+        if (!path.node.param) {
+          const uid = path.scope.generateUidIdentifier("unused");
+          const paramPath = path.get("param");
+          paramPath.replaceWith(uid);
+        }
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-proposal-optional-catch-binding/package.json b/node_modules/@babel/plugin-proposal-optional-catch-binding/package.json
new file mode 100644
index 00000000..9ea865ea
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-optional-catch-binding/package.json
@@ -0,0 +1,22 @@
+{
+  "name": "@babel/plugin-proposal-optional-catch-binding",
+  "version": "7.0.0-beta.47",
+  "description": "Compile optional catch bindings",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-proposal-optional-catch-binding",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47",
+    "@babel/plugin-syntax-optional-catch-binding": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-proposal-throw-expressions/README.md b/node_modules/@babel/plugin-proposal-throw-expressions/README.md
new file mode 100644
index 00000000..5ffb4de6
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-throw-expressions/README.md
@@ -0,0 +1,47 @@
+# @babel/plugin-proposal-throw-expressions
+
+This plugin transforms Throw Expressions into an IIFE.
+
+## Example
+
+```js
+function test(param = throw new Error('required!')) {
+  const test = param === true || throw new Error('Falsey!');
+}
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-proposal-throw-expressions
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-proposal-throw-expressions"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-proposal-throw-expressions script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-proposal-throw-expressions"]
+});
+```
+
+## References
+
+* [Proposal: ECMAScript throw expressions](https://github.com/tc39/proposal-throw-expressions)
diff --git a/node_modules/@babel/plugin-proposal-throw-expressions/lib/index.js b/node_modules/@babel/plugin-proposal-throw-expressions/lib/index.js
new file mode 100644
index 00000000..35aaad94
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-throw-expressions/lib/index.js
@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _pluginSyntaxThrowExpressions() {
+  const data = _interopRequireDefault(require("@babel/plugin-syntax-throw-expressions"));
+
+  _pluginSyntaxThrowExpressions = function _pluginSyntaxThrowExpressions() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+  return {
+    inherits: _pluginSyntaxThrowExpressions().default,
+    visitor: {
+      UnaryExpression(path) {
+        const _path$node = path.node,
+              operator = _path$node.operator,
+              argument = _path$node.argument;
+        if (operator !== "throw") return;
+
+        const arrow = _core().types.functionExpression(null, [_core().types.identifier("e")], _core().types.blockStatement([_core().types.throwStatement(_core().types.identifier("e"))]));
+
+        path.replaceWith(_core().types.callExpression(arrow, [argument]));
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-proposal-throw-expressions/package.json b/node_modules/@babel/plugin-proposal-throw-expressions/package.json
new file mode 100644
index 00000000..34d5954e
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-throw-expressions/package.json
@@ -0,0 +1,22 @@
+{
+  "name": "@babel/plugin-proposal-throw-expressions",
+  "version": "7.0.0-beta.47",
+  "description": "Wraps Throw Expressions in an IIFE",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-proposal-throw-expressions",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47",
+    "@babel/plugin-syntax-throw-expressions": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-proposal-unicode-property-regex/README.md b/node_modules/@babel/plugin-proposal-unicode-property-regex/README.md
new file mode 100644
index 00000000..00a8cbd6
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-unicode-property-regex/README.md
@@ -0,0 +1,60 @@
+# @babel/plugin-proposal-unicode-property-regex
+
+Compile [Unicode property escapes](https://github.com/mathiasbynens/regexpu-core/blob/master/property-escapes.md) (`\p{…}` and `\P{…}`) in Unicode regular expressions to ES5 or ES6 that works in today’s environments.
+
+[Here’s an online demo.](https://mothereff.in/regexpu#input=var+regex+%3D+/%5Cp%7BScript_Extensions%3DGreek%7D/u%3B&unicodePropertyEscape=1)
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-proposal-unicode-property-regex
+```
+
+## Usage
+
+### Via `.babelrc` (recommended)
+
+`.babelrc`
+
+```json
+{
+  "plugins": ["@babel/plugin-proposal-unicode-property-regex"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/@babel/plugin-proposal-unicode-property-regex script.js
+```
+
+### Via Node.js API
+
+```js
+require("@babel/core").transform(code, {
+  "plugins": ["@babel/plugin-proposal-unicode-property-regex"]
+});
+```
+
+To transpile to ES6/ES2015:
+
+```js
+require("@babel/core").transform(code, {
+  "plugins": [
+    ["@babel/plugin-proposal-unicode-property-regex", { "useUnicodeFlag": false }]
+  ]
+});
+```
+
+## Options
+
+* `useUnicodeFlag` (defaults to `true`)
+
+When disabled with `false`, the transform converts Unicode regexes to
+non-Unicode regexes for wider support, removing the `u` flag. See https://github.com/mathiasbynens/regexpu-core#useunicodeflag-default-false for more information.
+
+## Author
+
+| [![twitter/mathias](https://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](https://twitter.com/mathias "Follow @mathias on Twitter") |
+|---|
+| [Mathias Bynens](https://mathiasbynens.be/) |
diff --git a/node_modules/@babel/plugin-proposal-unicode-property-regex/lib/index.js b/node_modules/@babel/plugin-proposal-unicode-property-regex/lib/index.js
new file mode 100644
index 00000000..521c7f26
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-unicode-property-regex/lib/index.js
@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _regexpuCore() {
+  const data = _interopRequireDefault(require("regexpu-core"));
+
+  _regexpuCore = function _regexpuCore() {
+    return data;
+  };
+
+  return data;
+}
+
+function regex() {
+  const data = _interopRequireWildcard(require("@babel/helper-regex"));
+
+  regex = function regex() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _helperPluginUtils().declare)((api, options) => {
+  api.assertVersion(7);
+  const _options$useUnicodeFl = options.useUnicodeFlag,
+        useUnicodeFlag = _options$useUnicodeFl === void 0 ? true : _options$useUnicodeFl;
+
+  if (typeof useUnicodeFlag !== "boolean") {
+    throw new Error(".useUnicodeFlag must be a boolean, or undefined");
+  }
+
+  return {
+    visitor: {
+      RegExpLiteral(path) {
+        const node = path.node;
+
+        if (!regex().is(node, "u")) {
+          return;
+        }
+
+        node.pattern = (0, _regexpuCore().default)(node.pattern, node.flags, {
+          unicodePropertyEscape: true,
+          useUnicodeFlag
+        });
+
+        if (!useUnicodeFlag) {
+          regex().pullFlag(node, "u");
+        }
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-proposal-unicode-property-regex/package.json b/node_modules/@babel/plugin-proposal-unicode-property-regex/package.json
new file mode 100644
index 00000000..6cb07bcd
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-unicode-property-regex/package.json
@@ -0,0 +1,33 @@
+{
+  "name": "@babel/plugin-proposal-unicode-property-regex",
+  "version": "7.0.0-beta.47",
+  "description": "Compile Unicode property escapes in Unicode regular expressions to ES5.",
+  "homepage": "https://babeljs.io/",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "engines": {
+    "node": ">=4"
+  },
+  "keywords": [
+    "babel-plugin",
+    "regex",
+    "regexp",
+    "regular expressions",
+    "unicode properties",
+    "unicode"
+  ],
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-proposal-unicode-property-regex",
+  "bugs": "https://github.com/babel/babel/issues",
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47",
+    "@babel/helper-regex": "7.0.0-beta.47",
+    "regexpu-core": "^4.1.4"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-proposal-unicode-property-regex/src/index.js b/node_modules/@babel/plugin-proposal-unicode-property-regex/src/index.js
new file mode 100644
index 00000000..e48298ed
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-unicode-property-regex/src/index.js
@@ -0,0 +1,30 @@
+import { declare } from "@babel/helper-plugin-utils";
+import rewritePattern from "regexpu-core";
+import * as regex from "@babel/helper-regex";
+
+export default declare((api, options) => {
+  api.assertVersion(7);
+
+  const { useUnicodeFlag = true } = options;
+  if (typeof useUnicodeFlag !== "boolean") {
+    throw new Error(".useUnicodeFlag must be a boolean, or undefined");
+  }
+
+  return {
+    visitor: {
+      RegExpLiteral(path) {
+        const node = path.node;
+        if (!regex.is(node, "u")) {
+          return;
+        }
+        node.pattern = rewritePattern(node.pattern, node.flags, {
+          unicodePropertyEscape: true,
+          useUnicodeFlag,
+        });
+        if (!useUnicodeFlag) {
+          regex.pullFlag(node, "u");
+        }
+      },
+    },
+  };
+});
diff --git a/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/with-unicode-flag/options.json b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/with-unicode-flag/options.json
new file mode 100644
index 00000000..22a50010
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/with-unicode-flag/options.json
@@ -0,0 +1,7 @@
+{
+  "plugins": [
+    ["proposal-unicode-property-regex", {
+      "useUnicodeFlag": true
+    }]
+  ]
+}
diff --git a/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/with-unicode-flag/script-extensions/input.js b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/with-unicode-flag/script-extensions/input.js
new file mode 100644
index 00000000..9edf9daa
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/with-unicode-flag/script-extensions/input.js
@@ -0,0 +1 @@
+var regex = /\p{Script_Extensions=Anatolian_Hieroglyphs}/u;
diff --git a/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/with-unicode-flag/script-extensions/output.js b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/with-unicode-flag/script-extensions/output.js
new file mode 100644
index 00000000..25dfc454
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/with-unicode-flag/script-extensions/output.js
@@ -0,0 +1 @@
+var regex = /[\u{14400}-\u{14646}]/u;
diff --git a/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/with-unicode-flag/simple/input.js b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/with-unicode-flag/simple/input.js
new file mode 100644
index 00000000..7770f8ea
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/with-unicode-flag/simple/input.js
@@ -0,0 +1 @@
+var regex = /\p{ASCII_Hex_Digit}/u;
diff --git a/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/with-unicode-flag/simple/output.js b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/with-unicode-flag/simple/output.js
new file mode 100644
index 00000000..cea790a2
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/with-unicode-flag/simple/output.js
@@ -0,0 +1 @@
+var regex = /[0-9A-Fa-f]/u;
diff --git a/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/with-unicode-flag/unicode-10/input.js b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/with-unicode-flag/unicode-10/input.js
new file mode 100644
index 00000000..3af0a331
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/with-unicode-flag/unicode-10/input.js
@@ -0,0 +1 @@
+var regex = /\p{Regional_Indicator}/u;
diff --git a/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/with-unicode-flag/unicode-10/output.js b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/with-unicode-flag/unicode-10/output.js
new file mode 100644
index 00000000..6e60a4f5
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/with-unicode-flag/unicode-10/output.js
@@ -0,0 +1 @@
+var regex = /[\u{1F1E6}-\u{1F1FF}]/u;
diff --git a/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/without-unicode-flag/options.json b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/without-unicode-flag/options.json
new file mode 100644
index 00000000..755ed1da
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/without-unicode-flag/options.json
@@ -0,0 +1,7 @@
+{
+  "plugins": [
+    ["proposal-unicode-property-regex", {
+      "useUnicodeFlag": false
+    }]
+  ]
+}
diff --git a/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/without-unicode-flag/script-extensions/input.js b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/without-unicode-flag/script-extensions/input.js
new file mode 100644
index 00000000..9edf9daa
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/without-unicode-flag/script-extensions/input.js
@@ -0,0 +1 @@
+var regex = /\p{Script_Extensions=Anatolian_Hieroglyphs}/u;
diff --git a/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/without-unicode-flag/script-extensions/output.js b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/without-unicode-flag/script-extensions/output.js
new file mode 100644
index 00000000..f9bb33a7
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/without-unicode-flag/script-extensions/output.js
@@ -0,0 +1 @@
+var regex = /(?:\uD811[\uDC00-\uDE46])/;
diff --git a/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/without-unicode-flag/simple/input.js b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/without-unicode-flag/simple/input.js
new file mode 100644
index 00000000..7770f8ea
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/without-unicode-flag/simple/input.js
@@ -0,0 +1 @@
+var regex = /\p{ASCII_Hex_Digit}/u;
diff --git a/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/without-unicode-flag/simple/output.js b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/without-unicode-flag/simple/output.js
new file mode 100644
index 00000000..5b17db17
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/without-unicode-flag/simple/output.js
@@ -0,0 +1 @@
+var regex = /[0-9A-Fa-f]/;
diff --git a/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/without-unicode-flag/unicode-10/input.js b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/without-unicode-flag/unicode-10/input.js
new file mode 100644
index 00000000..3af0a331
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/without-unicode-flag/unicode-10/input.js
@@ -0,0 +1 @@
+var regex = /\p{Regional_Indicator}/u;
diff --git a/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/without-unicode-flag/unicode-10/output.js b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/without-unicode-flag/unicode-10/output.js
new file mode 100644
index 00000000..8339aeef
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/fixtures/without-unicode-flag/unicode-10/output.js
@@ -0,0 +1 @@
+var regex = /(?:\uD83C[\uDDE6-\uDDFF])/;
diff --git a/node_modules/@babel/plugin-proposal-unicode-property-regex/test/index.js b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/index.js
new file mode 100644
index 00000000..8c71ab59
--- /dev/null
+++ b/node_modules/@babel/plugin-proposal-unicode-property-regex/test/index.js
@@ -0,0 +1,2 @@
+import runner from "@babel/helper-plugin-test-runner";
+runner(__dirname);
diff --git a/node_modules/@babel/plugin-syntax-async-generators/README.md b/node_modules/@babel/plugin-syntax-async-generators/README.md
new file mode 100644
index 00000000..b8f9e7cd
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-async-generators/README.md
@@ -0,0 +1,57 @@
+# @babel/plugin-syntax-async-generators
+
+> Allow parsing of async generator functions.
+
+## Example
+
+**Syntax**
+
+```javascript
+async function* agf() {
+  await 1;
+}
+```
+
+```js
+async function f() {
+  for await (let x of y) {
+    g(x);
+  }
+}
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-syntax-async-generators
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-syntax-async-generators"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-syntax-async-generators script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-syntax-async-generators"]
+});
+```
+
+## References
+
+* [Proposal: Asynchronous iteration for ECMAScript](https://github.com/tc39/proposal-async-iteration)
diff --git a/node_modules/@babel/plugin-syntax-async-generators/lib/index.js b/node_modules/@babel/plugin-syntax-async-generators/lib/index.js
new file mode 100644
index 00000000..c41e97fe
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-async-generators/lib/index.js
@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+  return {
+    manipulateOptions(opts, parserOpts) {
+      parserOpts.plugins.push("asyncGenerators");
+    }
+
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-syntax-async-generators/package.json b/node_modules/@babel/plugin-syntax-async-generators/package.json
new file mode 100644
index 00000000..98b4bf85
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-async-generators/package.json
@@ -0,0 +1,20 @@
+{
+  "name": "@babel/plugin-syntax-async-generators",
+  "version": "7.0.0-beta.47",
+  "description": "Allow parsing of async generator functions",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-syntax-async-generators",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-syntax-class-properties/README.md b/node_modules/@babel/plugin-syntax-class-properties/README.md
new file mode 100644
index 00000000..fddd0b4d
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-class-properties/README.md
@@ -0,0 +1,35 @@
+# @babel/plugin-syntax-class-properties
+
+> Allow parsing of class properties.
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-syntax-class-properties
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-syntax-class-properties"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-syntax-class-properties script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-syntax-class-properties"]
+});
+```
diff --git a/node_modules/@babel/plugin-syntax-class-properties/lib/index.js b/node_modules/@babel/plugin-syntax-class-properties/lib/index.js
new file mode 100644
index 00000000..0837f21c
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-class-properties/lib/index.js
@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+  return {
+    manipulateOptions(opts, parserOpts) {
+      parserOpts.plugins.push("classProperties", "classPrivateProperties");
+    }
+
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-syntax-class-properties/package.json b/node_modules/@babel/plugin-syntax-class-properties/package.json
new file mode 100644
index 00000000..1df7ad1e
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-class-properties/package.json
@@ -0,0 +1,20 @@
+{
+  "name": "@babel/plugin-syntax-class-properties",
+  "version": "7.0.0-beta.47",
+  "description": "Allow parsing of class properties",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-syntax-class-properties",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-syntax-decorators/README.md b/node_modules/@babel/plugin-syntax-decorators/README.md
new file mode 100644
index 00000000..a0627557
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-decorators/README.md
@@ -0,0 +1,43 @@
+# @babel/plugin-syntax-decorators
+
+> Allow parsing of decorators.
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-syntax-decorators
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-syntax-decorators"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-syntax-decorators script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-syntax-decorators"]
+});
+```
+
+## Options
+
+### `legacy`
+
+`boolean`, defaults to `false`.
+
+Use the legacy (stage 1) decorators syntax.
diff --git a/node_modules/@babel/plugin-syntax-decorators/lib/index.js b/node_modules/@babel/plugin-syntax-decorators/lib/index.js
new file mode 100644
index 00000000..7e334b36
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-decorators/lib/index.js
@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = (0, _helperPluginUtils().declare)((api, options) => {
+  api.assertVersion(7);
+  const _options$legacy = options.legacy,
+        legacy = _options$legacy === void 0 ? false : _options$legacy;
+
+  if (typeof legacy !== "boolean") {
+    throw new Error("'legacy' must be a boolean.");
+  }
+
+  return {
+    manipulateOptions(opts, parserOpts) {
+      parserOpts.plugins.push(legacy ? "decorators-legacy" : "decorators");
+    }
+
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-syntax-decorators/package.json b/node_modules/@babel/plugin-syntax-decorators/package.json
new file mode 100644
index 00000000..675190f0
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-decorators/package.json
@@ -0,0 +1,20 @@
+{
+  "name": "@babel/plugin-syntax-decorators",
+  "version": "7.0.0-beta.47",
+  "description": "Allow parsing of decorators",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-syntax-decorators",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-syntax-dynamic-import/README.md b/node_modules/@babel/plugin-syntax-dynamic-import/README.md
new file mode 100644
index 00000000..4705c75e
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-dynamic-import/README.md
@@ -0,0 +1,35 @@
+# @babel/plugin-syntax-dynamic-import
+
+> Allow parsing of `import()`.
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-syntax-dynamic-import
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-syntax-dynamic-import"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-syntax-dynamic-import script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-syntax-dynamic-import"]
+});
+```
diff --git a/node_modules/@babel/plugin-syntax-dynamic-import/lib/index.js b/node_modules/@babel/plugin-syntax-dynamic-import/lib/index.js
new file mode 100644
index 00000000..d490e3ec
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-dynamic-import/lib/index.js
@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+  return {
+    manipulateOptions(opts, parserOpts) {
+      parserOpts.plugins.push("dynamicImport");
+    }
+
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-syntax-dynamic-import/package.json b/node_modules/@babel/plugin-syntax-dynamic-import/package.json
new file mode 100644
index 00000000..6f94cd49
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-dynamic-import/package.json
@@ -0,0 +1,20 @@
+{
+  "name": "@babel/plugin-syntax-dynamic-import",
+  "version": "7.0.0-beta.47",
+  "description": "Allow parsing of import()",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-syntax-dynamic-import",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-syntax-export-namespace-from/README.md b/node_modules/@babel/plugin-syntax-export-namespace-from/README.md
new file mode 100644
index 00000000..6e358a2e
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-export-namespace-from/README.md
@@ -0,0 +1,35 @@
+# @babel/plugin-syntax-export-namespace-from
+
+> Allow parsing of `export * as namespace from`.
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-syntax-export-namespace-from
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-syntax-export-namespace-from"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-syntax-export-namespace-from script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-syntax-export-namespace-from"]
+});
+```
diff --git a/node_modules/@babel/plugin-syntax-export-namespace-from/lib/index.js b/node_modules/@babel/plugin-syntax-export-namespace-from/lib/index.js
new file mode 100644
index 00000000..d2926c5e
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-export-namespace-from/lib/index.js
@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+  return {
+    manipulateOptions(opts, parserOpts) {
+      parserOpts.plugins.push("exportNamespaceFrom");
+    }
+
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-syntax-export-namespace-from/package.json b/node_modules/@babel/plugin-syntax-export-namespace-from/package.json
new file mode 100644
index 00000000..22965470
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-export-namespace-from/package.json
@@ -0,0 +1,20 @@
+{
+  "name": "@babel/plugin-syntax-export-namespace-from",
+  "version": "7.0.0-beta.47",
+  "description": "Allow parsing of export namespace from",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-syntax-export-namespace-from",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-syntax-function-sent/README.md b/node_modules/@babel/plugin-syntax-function-sent/README.md
new file mode 100644
index 00000000..e8aa2540
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-function-sent/README.md
@@ -0,0 +1,35 @@
+# @babel/plugin-syntax-function-sent
+
+> Allow parsing of the `function.sent` meta property.
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-syntax-function-sent
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-syntax-function-sent"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-syntax-function-sent script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-syntax-function-sent"]
+});
+```
diff --git a/node_modules/@babel/plugin-syntax-function-sent/lib/index.js b/node_modules/@babel/plugin-syntax-function-sent/lib/index.js
new file mode 100644
index 00000000..cccf72de
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-function-sent/lib/index.js
@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+  return {
+    manipulateOptions(opts, parserOpts) {
+      parserOpts.plugins.push("functionSent");
+    }
+
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-syntax-function-sent/package.json b/node_modules/@babel/plugin-syntax-function-sent/package.json
new file mode 100644
index 00000000..627c4696
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-function-sent/package.json
@@ -0,0 +1,20 @@
+{
+  "name": "@babel/plugin-syntax-function-sent",
+  "version": "7.0.0-beta.47",
+  "description": "Allow parsing of the function.sent meta property",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-syntax-function-sent",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-syntax-import-meta/README.md b/node_modules/@babel/plugin-syntax-import-meta/README.md
new file mode 100644
index 00000000..20c5fc47
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-import-meta/README.md
@@ -0,0 +1,35 @@
+# @babel/plugin-syntax-import-meta
+
+> Allow parsing of `import.meta`.
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-syntax-import-meta
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-syntax-import-meta"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-syntax-import-meta script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-syntax-import-meta"]
+});
+```
diff --git a/node_modules/@babel/plugin-syntax-import-meta/lib/index.js b/node_modules/@babel/plugin-syntax-import-meta/lib/index.js
new file mode 100644
index 00000000..417a90a4
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-import-meta/lib/index.js
@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+  return {
+    manipulateOptions(opts, parserOpts) {
+      parserOpts.plugins.push("importMeta");
+    }
+
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-syntax-import-meta/package.json b/node_modules/@babel/plugin-syntax-import-meta/package.json
new file mode 100644
index 00000000..91cb536d
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-import-meta/package.json
@@ -0,0 +1,20 @@
+{
+  "name": "@babel/plugin-syntax-import-meta",
+  "version": "7.0.0-beta.47",
+  "description": "Allow parsing of import.meta",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-syntax-import-meta",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-syntax-jsx/README.md b/node_modules/@babel/plugin-syntax-jsx/README.md
new file mode 100644
index 00000000..41096c52
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-jsx/README.md
@@ -0,0 +1,35 @@
+# @babel/plugin-syntax-jsx
+
+> Allow parsing of JSX
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-syntax-jsx
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-syntax-jsx"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-syntax-jsx script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-syntax-jsx"]
+});
+```
diff --git a/node_modules/@babel/plugin-syntax-jsx/lib/index.js b/node_modules/@babel/plugin-syntax-jsx/lib/index.js
new file mode 100644
index 00000000..c667cae7
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-jsx/lib/index.js
@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+  return {
+    manipulateOptions(opts, parserOpts) {
+      parserOpts.plugins.push("jsx");
+    }
+
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-syntax-jsx/package.json b/node_modules/@babel/plugin-syntax-jsx/package.json
new file mode 100644
index 00000000..e559172c
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-jsx/package.json
@@ -0,0 +1,20 @@
+{
+  "name": "@babel/plugin-syntax-jsx",
+  "version": "7.0.0-beta.47",
+  "description": "Allow parsing of jsx",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-syntax-jsx",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-syntax-numeric-separator/README.md b/node_modules/@babel/plugin-syntax-numeric-separator/README.md
new file mode 100644
index 00000000..3976234f
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-numeric-separator/README.md
@@ -0,0 +1,36 @@
+# @babel/plugin-syntax-numeric-separator
+
+> Allow parsing of Numeric Literals (Decimal, Binary, Hex and Octal) that contain a _NumericLiteralSeparator_.
+
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-syntax-numeric-separator
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-syntax-numeric-separator"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-syntax-numeric-separator script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-syntax-numeric-separator"]
+});
+```
diff --git a/node_modules/@babel/plugin-syntax-numeric-separator/lib/index.js b/node_modules/@babel/plugin-syntax-numeric-separator/lib/index.js
new file mode 100644
index 00000000..54ec6313
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-numeric-separator/lib/index.js
@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+  return {
+    manipulateOptions(opts, parserOpts) {
+      parserOpts.plugins.push("numericSeparator");
+    }
+
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-syntax-numeric-separator/package.json b/node_modules/@babel/plugin-syntax-numeric-separator/package.json
new file mode 100644
index 00000000..e5ba3525
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-numeric-separator/package.json
@@ -0,0 +1,20 @@
+{
+  "name": "@babel/plugin-syntax-numeric-separator",
+  "version": "7.0.0-beta.47",
+  "description": "Allow parsing of Decimal, Binary, Hex and Octal literals that contain a Numeric Literal Separator",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-syntax-numeric-separator",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-syntax-object-rest-spread/README.md b/node_modules/@babel/plugin-syntax-object-rest-spread/README.md
new file mode 100644
index 00000000..1633833f
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-object-rest-spread/README.md
@@ -0,0 +1,35 @@
+# @babel/plugin-syntax-object-rest-spread
+
+> Allow parsing of object rest/spread.
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-syntax-object-rest-spread
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-syntax-object-rest-spread"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-syntax-object-rest-spread script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-syntax-object-rest-spread"]
+});
+```
diff --git a/node_modules/@babel/plugin-syntax-object-rest-spread/lib/index.js b/node_modules/@babel/plugin-syntax-object-rest-spread/lib/index.js
new file mode 100644
index 00000000..25d5b94a
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-object-rest-spread/lib/index.js
@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+  return {
+    manipulateOptions(opts, parserOpts) {
+      parserOpts.plugins.push("objectRestSpread");
+    }
+
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-syntax-object-rest-spread/package.json b/node_modules/@babel/plugin-syntax-object-rest-spread/package.json
new file mode 100644
index 00000000..c83b98a6
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-object-rest-spread/package.json
@@ -0,0 +1,20 @@
+{
+  "name": "@babel/plugin-syntax-object-rest-spread",
+  "version": "7.0.0-beta.47",
+  "description": "Allow parsing of object rest/spread",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-syntax-object-rest-spread",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-syntax-optional-catch-binding/README.md b/node_modules/@babel/plugin-syntax-optional-catch-binding/README.md
new file mode 100644
index 00000000..3d4fd8f3
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-optional-catch-binding/README.md
@@ -0,0 +1,52 @@
+# @babel/plugin-syntax-optional-catch-binding
+
+> This plugin allows Babel to parse optional catch bindings.
+
+## Example
+
+**Syntax**
+
+```javascript
+try {
+  throw 0;
+} catch {
+  doSomethingWhichDoesntCareAboutTheValueThrown();
+  console.log("Yay, code executes!");
+}
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-syntax-optional-catch-binding
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-syntax-optional-catch-binding"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-syntax-optional-catch-binding script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-syntax-optional-catch-binding"]
+});
+```
+
+## References
+
+* [Proposal: Optional Catch Binding for ECMAScript](https://github.com/babel/proposals/issues/7)
diff --git a/node_modules/@babel/plugin-syntax-optional-catch-binding/lib/index.js b/node_modules/@babel/plugin-syntax-optional-catch-binding/lib/index.js
new file mode 100644
index 00000000..1c0bd7e0
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-optional-catch-binding/lib/index.js
@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+  return {
+    manipulateOptions(opts, parserOpts) {
+      parserOpts.plugins.push("optionalCatchBinding");
+    }
+
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-syntax-optional-catch-binding/package.json b/node_modules/@babel/plugin-syntax-optional-catch-binding/package.json
new file mode 100644
index 00000000..3ff186fd
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-optional-catch-binding/package.json
@@ -0,0 +1,20 @@
+{
+  "name": "@babel/plugin-syntax-optional-catch-binding",
+  "version": "7.0.0-beta.47",
+  "description": "Allow parsing of optional catch bindings",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-syntax-optional-catch-binding",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-syntax-throw-expressions/README.md b/node_modules/@babel/plugin-syntax-throw-expressions/README.md
new file mode 100644
index 00000000..9aa7f878
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-throw-expressions/README.md
@@ -0,0 +1,42 @@
+# @babel/plugin-syntax-throw-expressions
+
+Allow parsing of Throw Expressions:
+
+```js
+function test(param = throw new Error('required!')) {
+  const test = param === true || throw new Error('Falsey!');
+}
+```
+
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-syntax-throw-expressions
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-syntax-throw-expressions"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-syntax-throw-expressions script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-syntax-throw-expressions"]
+});
+```
diff --git a/node_modules/@babel/plugin-syntax-throw-expressions/lib/index.js b/node_modules/@babel/plugin-syntax-throw-expressions/lib/index.js
new file mode 100644
index 00000000..1daff7a6
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-throw-expressions/lib/index.js
@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+  return {
+    manipulateOptions(opts, parserOpts) {
+      parserOpts.plugins.push("throwExpressions");
+    }
+
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-syntax-throw-expressions/package.json b/node_modules/@babel/plugin-syntax-throw-expressions/package.json
new file mode 100644
index 00000000..e5ba5ada
--- /dev/null
+++ b/node_modules/@babel/plugin-syntax-throw-expressions/package.json
@@ -0,0 +1,20 @@
+{
+  "name": "@babel/plugin-syntax-throw-expressions",
+  "version": "7.0.0-beta.47",
+  "description": "Allow parsing of Throw Expressions",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-syntax-throw-expressions",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-arrow-functions/README.md b/node_modules/@babel/plugin-transform-arrow-functions/README.md
new file mode 100644
index 00000000..3cccc15a
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-arrow-functions/README.md
@@ -0,0 +1,149 @@
+# @babel/plugin-transform-arrow-functions
+
+> Compile ES2015 arrow functions to ES5
+
+## Example
+
+**In**
+
+```javascript
+var a = () => {};
+var a = (b) => b;
+
+const double = [1,2,3].map((num) => num * 2);
+console.log(double); // [2,4,6]
+
+var bob = {
+  _name: "Bob",
+  _friends: ["Sally", "Tom"],
+  printFriends() {
+    this._friends.forEach(f =>
+      console.log(this._name + " knows " + f));
+  }
+};
+console.log(bob.printFriends());
+```
+
+**Out**
+
+```javascript
+var a = function () {};
+var a = function (b) {
+  return b;
+};
+
+const double = [1, 2, 3].map(function (num) {
+  return num * 2;
+});
+console.log(double); // [2,4,6]
+
+var bob = {
+  _name: "Bob",
+  _friends: ["Sally", "Tom"],
+  printFriends() {
+    var _this = this;
+
+    this._friends.forEach(function (f) {
+      return console.log(_this._name + " knows " + f);
+    });
+  }
+};
+console.log(bob.printFriends());
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-arrow-functions
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+Without options:
+
+```json
+{
+  "plugins": ["@babel/plugin-transform-arrow-functions"]
+}
+```
+
+With options:
+
+```json
+{
+  "plugins": [
+    ["@babel/plugin-transform-arrow-functions", { "spec": true }]
+  ]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-arrow-functions script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-arrow-functions"]
+});
+```
+
+## Options
+
+### `spec`
+
+`boolean`, defaults to `false`.
+
+<p><details>
+  <summary><b>Example</b></summary>
+
+  Using spec mode with the above example produces:
+
+  ```js
+  var _this = this;
+
+  var a = function a() {
+    babelHelpers.newArrowCheck(this, _this);
+  }.bind(this);
+  var a = function a(b) {
+    babelHelpers.newArrowCheck(this, _this);
+    return b;
+  }.bind(this);
+
+  const double = [1, 2, 3].map(function (num) {
+    babelHelpers.newArrowCheck(this, _this);
+    return num * 2;
+  }.bind(this));
+  console.log(double); // [2,4,6]
+
+  var bob = {
+    _name: "Bob",
+    _friends: ["Sally", "Tom"],
+    printFriends() {
+      var _this2 = this;
+
+      this._friends.forEach(function (f) {
+        babelHelpers.newArrowCheck(this, _this2);
+        return console.log(this._name + " knows " + f);
+      }.bind(this));
+    }
+  };
+  console.log(bob.printFriends());
+  ```
+</details></p>
+
+This option enables the following:
+
+ - Wrap the generated function in `.bind(this)` and keeps uses of `this` inside
+   the function as-is, instead of using a renamed `this`.
+
+ - Add a runtime check to ensure the functions are not instantiated.
+
+ - Add names to arrow functions.
diff --git a/node_modules/@babel/plugin-transform-arrow-functions/lib/index.js b/node_modules/@babel/plugin-transform-arrow-functions/lib/index.js
new file mode 100644
index 00000000..54cbcb1d
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-arrow-functions/lib/index.js
@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = (0, _helperPluginUtils().declare)((api, options) => {
+  api.assertVersion(7);
+  const spec = options.spec;
+  return {
+    visitor: {
+      ArrowFunctionExpression(path) {
+        if (!path.isArrowFunctionExpression()) return;
+        path.arrowFunctionToExpression({
+          allowInsertArrow: false,
+          specCompliant: !!spec
+        });
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-arrow-functions/package.json b/node_modules/@babel/plugin-transform-arrow-functions/package.json
new file mode 100644
index 00000000..19b9aa6b
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-arrow-functions/package.json
@@ -0,0 +1,22 @@
+{
+  "name": "@babel/plugin-transform-arrow-functions",
+  "version": "7.0.0-beta.47",
+  "description": "Compile ES2015 arrow functions to ES5",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-arrow-functions",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47",
+    "@babel/traverse": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-async-to-generator/README.md b/node_modules/@babel/plugin-transform-async-to-generator/README.md
new file mode 100644
index 00000000..8065bc8e
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-async-to-generator/README.md
@@ -0,0 +1,89 @@
+# @babel/plugin-transform-async-to-generator
+
+> Turn async functions into ES2015 generators
+
+> In Babel 7, `transform-async-to-module-method` was merged into this plugin
+
+## Example
+
+**In**
+
+```javascript
+async function foo() {
+  await bar();
+}
+```
+
+**Out**
+
+```javascript
+var _asyncToGenerator = function (fn) {
+  ...
+};
+var foo = _asyncToGenerator(function* () {
+  yield bar();
+});
+```
+
+**Out with options**
+
+> Turn async functions into a Bluebird coroutine
+
+```javascript
+var Bluebird = require("bluebird");
+
+var foo = Bluebird.coroutine(function* () {
+  yield bar();
+});
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-async-to-generator
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+Without options:
+
+```json
+{
+  "plugins": ["@babel/plugin-transform-async-to-generator"]
+}
+```
+
+With options:
+
+```json
+{
+  "plugins": [
+    ["@babel/plugin-transform-async-to-generator", {
+      "module": "bluebird",
+      "method": "coroutine"
+    }]
+  ]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-async-to-generator script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-async-to-generator"]
+});
+```
+
+## References
+
+* [Proposal: Async Functions for ECMAScript](https://github.com/tc39/ecmascript-asyncawait)
diff --git a/node_modules/@babel/plugin-transform-async-to-generator/lib/index.js b/node_modules/@babel/plugin-transform-async-to-generator/lib/index.js
new file mode 100644
index 00000000..5716306d
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-async-to-generator/lib/index.js
@@ -0,0 +1,90 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperRemapAsyncToGenerator() {
+  const data = _interopRequireDefault(require("@babel/helper-remap-async-to-generator"));
+
+  _helperRemapAsyncToGenerator = function _helperRemapAsyncToGenerator() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperModuleImports() {
+  const data = require("@babel/helper-module-imports");
+
+  _helperModuleImports = function _helperModuleImports() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _helperPluginUtils().declare)((api, options) => {
+  api.assertVersion(7);
+  const method = options.method,
+        module = options.module;
+
+  if (method && module) {
+    return {
+      visitor: {
+        Function(path, state) {
+          if (!path.node.async || path.node.generator) return;
+          let wrapAsync = state.methodWrapper;
+
+          if (wrapAsync) {
+            wrapAsync = _core().types.cloneNode(wrapAsync);
+          } else {
+            wrapAsync = state.methodWrapper = (0, _helperModuleImports().addNamed)(path, method, module);
+          }
+
+          (0, _helperRemapAsyncToGenerator().default)(path, {
+            wrapAsync
+          });
+        }
+
+      }
+    };
+  }
+
+  return {
+    visitor: {
+      Function(path, state) {
+        if (!path.node.async || path.node.generator) return;
+        (0, _helperRemapAsyncToGenerator().default)(path, {
+          wrapAsync: state.addHelper("asyncToGenerator")
+        });
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-async-to-generator/package.json b/node_modules/@babel/plugin-transform-async-to-generator/package.json
new file mode 100644
index 00000000..2e8a8896
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-async-to-generator/package.json
@@ -0,0 +1,23 @@
+{
+  "name": "@babel/plugin-transform-async-to-generator",
+  "version": "7.0.0-beta.47",
+  "description": "Turn async functions into ES2015 generators",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-async-to-generator",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-module-imports": "7.0.0-beta.47",
+    "@babel/helper-plugin-utils": "7.0.0-beta.47",
+    "@babel/helper-remap-async-to-generator": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-block-scoped-functions/README.md b/node_modules/@babel/plugin-transform-block-scoped-functions/README.md
new file mode 100644
index 00000000..95985cf6
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-block-scoped-functions/README.md
@@ -0,0 +1,60 @@
+# @babel/plugin-transform-block-scoped-functions
+
+> Babel plugin to ensure function declarations at the block level are block scoped.
+
+## Examples
+
+**In**
+
+```javascript
+{
+  function name (n) {
+    return n;
+  }
+}
+
+name("Steve");
+```
+
+**Out**
+
+```javascript
+{
+  let name = function (n) {
+    return n;
+  };
+}
+name("Steve");
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-block-scoped-functions
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-transform-block-scoped-functions"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-block-scoped-functions script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-block-scoped-functions"]
+});
+```
diff --git a/node_modules/@babel/plugin-transform-block-scoped-functions/lib/index.js b/node_modules/@babel/plugin-transform-block-scoped-functions/lib/index.js
new file mode 100644
index 00000000..970590bb
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-block-scoped-functions/lib/index.js
@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+
+  function statementList(key, path) {
+    const paths = path.get(key);
+
+    for (var _iterator = paths, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i >= _iterator.length) break;
+        _ref = _iterator[_i++];
+      } else {
+        _i = _iterator.next();
+        if (_i.done) break;
+        _ref = _i.value;
+      }
+
+      const path = _ref;
+      const func = path.node;
+      if (!path.isFunctionDeclaration()) continue;
+
+      const declar = _core().types.variableDeclaration("let", [_core().types.variableDeclarator(func.id, _core().types.toExpression(func))]);
+
+      declar._blockHoist = 2;
+      func.id = null;
+      path.replaceWith(declar);
+    }
+  }
+
+  return {
+    visitor: {
+      BlockStatement(path) {
+        const node = path.node,
+              parent = path.parent;
+
+        if (_core().types.isFunction(parent, {
+          body: node
+        }) || _core().types.isExportDeclaration(parent)) {
+          return;
+        }
+
+        statementList("body", path);
+      },
+
+      SwitchCase(path) {
+        statementList("consequent", path);
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-block-scoped-functions/package.json b/node_modules/@babel/plugin-transform-block-scoped-functions/package.json
new file mode 100644
index 00000000..6e310e79
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-block-scoped-functions/package.json
@@ -0,0 +1,21 @@
+{
+  "name": "@babel/plugin-transform-block-scoped-functions",
+  "version": "7.0.0-beta.47",
+  "description": "Babel plugin to ensure function declarations at the block level are block scoped",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-block-scoped-functions",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-block-scoping/README.md b/node_modules/@babel/plugin-transform-block-scoping/README.md
new file mode 100644
index 00000000..7c174e50
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-block-scoping/README.md
@@ -0,0 +1,103 @@
+# @babel/plugin-transform-block-scoping
+
+> Compile ES2015 block scoping (const and let) to ES5
+
+## Examples
+
+**In**
+
+```javascript
+{
+  let a = 3
+}
+
+let a = 3
+```
+
+**Out**
+
+```javascript
+{
+  var _a = 3;
+}
+
+var a = 3;
+```
+
+## Constant checks
+
+This plugin also validates all `const` variables.
+Reassignment of constants is a runtime error and it will insert the necessary error code for those.
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-block-scoping
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+Without options:
+
+```json
+{
+  "plugins": ["@babel/plugin-transform-block-scoping"]
+}
+```
+
+With options:
+
+```json
+{
+  "plugins": [
+    ["@babel/plugin-transform-block-scoping", {
+      "throwIfClosureRequired": true
+    }]
+  ]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-block-scoping script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-block-scoping"]
+});
+```
+
+## Options
+
+### `throwIfClosureRequired`
+`boolean`, defaults to `false`.
+
+In cases such as the following it's impossible to rewrite let/const without adding an additional function and closure while transforming:
+
+```javascript
+for (let i = 0; i < 5; i++) {
+  setTimeout(() => console.log(i), 1);
+}
+```
+
+In extremely performance-sensitive code, this can be undesirable. If `"throwIfClosureRequired": true` is set, Babel throws when transforming these patterns instead of automatically adding an additional function.
+
+### `tdz`
+`boolean`, defaults to `false`.
+
+By default this plugin will ignore the *temporal dead zone (TDZ)* for block-scoped variables. The following code will **not throw an error when transpiled with Babel, which is not spec compliant**:
+
+```javascript
+i
+let i;
+```
+
+If you need these errors you can tell Babel to try and find them by setting `"tdz": true` for this plugin. However, the current implementation might not get all edge cases right and its best to just avoid code like this in the first place.
diff --git a/node_modules/@babel/plugin-transform-block-scoping/lib/index.js b/node_modules/@babel/plugin-transform-block-scoping/lib/index.js
new file mode 100644
index 00000000..e70fe5a0
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-block-scoping/lib/index.js
@@ -0,0 +1,747 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+var _tdz = require("./tdz");
+
+function _values() {
+  const data = _interopRequireDefault(require("lodash/values"));
+
+  _values = function _values() {
+    return data;
+  };
+
+  return data;
+}
+
+function _extend() {
+  const data = _interopRequireDefault(require("lodash/extend"));
+
+  _extend = function _extend() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const DONE = new WeakSet();
+
+var _default = (0, _helperPluginUtils().declare)((api, opts) => {
+  api.assertVersion(7);
+  const _opts$throwIfClosureR = opts.throwIfClosureRequired,
+        throwIfClosureRequired = _opts$throwIfClosureR === void 0 ? false : _opts$throwIfClosureR,
+        _opts$tdz = opts.tdz,
+        tdzEnabled = _opts$tdz === void 0 ? false : _opts$tdz;
+
+  if (typeof throwIfClosureRequired !== "boolean") {
+    throw new Error(`.throwIfClosureRequired must be a boolean, or undefined`);
+  }
+
+  if (typeof tdzEnabled !== "boolean") {
+    throw new Error(`.throwIfClosureRequired must be a boolean, or undefined`);
+  }
+
+  return {
+    visitor: {
+      VariableDeclaration(path) {
+        const node = path.node,
+              parent = path.parent,
+              scope = path.scope;
+        if (!isBlockScoped(node)) return;
+        convertBlockScopedToVar(path, null, parent, scope, true);
+
+        if (node._tdzThis) {
+          const nodes = [node];
+
+          for (let i = 0; i < node.declarations.length; i++) {
+            const decl = node.declarations[i];
+
+            if (decl.init) {
+              const assign = _core().types.assignmentExpression("=", decl.id, decl.init);
+
+              assign._ignoreBlockScopingTDZ = true;
+              nodes.push(_core().types.expressionStatement(assign));
+            }
+
+            decl.init = this.addHelper("temporalUndefined");
+          }
+
+          node._blockHoist = 2;
+
+          if (path.isCompletionRecord()) {
+            nodes.push(_core().types.expressionStatement(scope.buildUndefinedNode()));
+          }
+
+          path.replaceWithMultiple(nodes);
+        }
+      },
+
+      Loop(path, state) {
+        const parent = path.parent,
+              scope = path.scope;
+        path.ensureBlock();
+        const blockScoping = new BlockScoping(path, path.get("body"), parent, scope, throwIfClosureRequired, tdzEnabled, state);
+        const replace = blockScoping.run();
+        if (replace) path.replaceWith(replace);
+      },
+
+      CatchClause(path, state) {
+        const parent = path.parent,
+              scope = path.scope;
+        const blockScoping = new BlockScoping(null, path.get("body"), parent, scope, throwIfClosureRequired, tdzEnabled, state);
+        blockScoping.run();
+      },
+
+      "BlockStatement|SwitchStatement|Program"(path, state) {
+        if (!ignoreBlock(path)) {
+          const blockScoping = new BlockScoping(null, path, path.parent, path.scope, throwIfClosureRequired, tdzEnabled, state);
+          blockScoping.run();
+        }
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
+
+function ignoreBlock(path) {
+  return _core().types.isLoop(path.parent) || _core().types.isCatchClause(path.parent);
+}
+
+const buildRetCheck = (0, _core().template)(`
+  if (typeof RETURN === "object") return RETURN.v;
+`);
+
+function isBlockScoped(node) {
+  if (!_core().types.isVariableDeclaration(node)) return false;
+  if (node[_core().types.BLOCK_SCOPED_SYMBOL]) return true;
+  if (node.kind !== "let" && node.kind !== "const") return false;
+  return true;
+}
+
+function isInLoop(path) {
+  const loopOrFunctionParent = path.find(path => path.isLoop() || path.isFunction());
+  return loopOrFunctionParent && loopOrFunctionParent.isLoop();
+}
+
+function convertBlockScopedToVar(path, node, parent, scope, moveBindingsToParent = false) {
+  if (!node) {
+    node = path.node;
+  }
+
+  if (isInLoop(path) && !_core().types.isFor(parent)) {
+    for (let i = 0; i < node.declarations.length; i++) {
+      const declar = node.declarations[i];
+      declar.init = declar.init || scope.buildUndefinedNode();
+    }
+  }
+
+  node[_core().types.BLOCK_SCOPED_SYMBOL] = true;
+  node.kind = "var";
+
+  if (moveBindingsToParent) {
+    const parentScope = scope.getFunctionParent() || scope.getProgramParent();
+    const ids = path.getBindingIdentifiers();
+
+    for (const name in ids) {
+      const binding = scope.getOwnBinding(name);
+      if (binding) binding.kind = "var";
+      scope.moveBindingTo(name, parentScope);
+    }
+  }
+}
+
+function isVar(node) {
+  return _core().types.isVariableDeclaration(node, {
+    kind: "var"
+  }) && !isBlockScoped(node);
+}
+
+const letReferenceBlockVisitor = _core().traverse.visitors.merge([{
+  Loop: {
+    enter(path, state) {
+      state.loopDepth++;
+    },
+
+    exit(path, state) {
+      state.loopDepth--;
+    }
+
+  },
+
+  Function(path, state) {
+    if (state.loopDepth > 0) {
+      path.traverse(letReferenceFunctionVisitor, state);
+    }
+
+    return path.skip();
+  }
+
+}, _tdz.visitor]);
+
+const letReferenceFunctionVisitor = _core().traverse.visitors.merge([{
+  ReferencedIdentifier(path, state) {
+    const ref = state.letReferences[path.node.name];
+    if (!ref) return;
+    const localBinding = path.scope.getBindingIdentifier(path.node.name);
+    if (localBinding && localBinding !== ref) return;
+    state.closurify = true;
+  }
+
+}, _tdz.visitor]);
+
+const hoistVarDeclarationsVisitor = {
+  enter(path, self) {
+    const node = path.node,
+          parent = path.parent;
+
+    if (path.isForStatement()) {
+      if (isVar(node.init, node)) {
+        const nodes = self.pushDeclar(node.init);
+
+        if (nodes.length === 1) {
+          node.init = nodes[0];
+        } else {
+          node.init = _core().types.sequenceExpression(nodes);
+        }
+      }
+    } else if (path.isFor()) {
+      if (isVar(node.left, node)) {
+        self.pushDeclar(node.left);
+        node.left = node.left.declarations[0].id;
+      }
+    } else if (isVar(node, parent)) {
+      path.replaceWithMultiple(self.pushDeclar(node).map(expr => _core().types.expressionStatement(expr)));
+    } else if (path.isFunction()) {
+      return path.skip();
+    }
+  }
+
+};
+const loopLabelVisitor = {
+  LabeledStatement({
+    node
+  }, state) {
+    state.innerLabels.push(node.label.name);
+  }
+
+};
+const continuationVisitor = {
+  enter(path, state) {
+    if (path.isAssignmentExpression() || path.isUpdateExpression()) {
+      const bindings = path.getBindingIdentifiers();
+
+      for (const name in bindings) {
+        if (state.outsideReferences[name] !== path.scope.getBindingIdentifier(name)) {
+          continue;
+        }
+
+        state.reassignments[name] = true;
+      }
+    } else if (path.isReturnStatement()) {
+      state.returnStatements.push(path);
+    }
+  }
+
+};
+
+function loopNodeTo(node) {
+  if (_core().types.isBreakStatement(node)) {
+    return "break";
+  } else if (_core().types.isContinueStatement(node)) {
+    return "continue";
+  }
+}
+
+const loopVisitor = {
+  Loop(path, state) {
+    const oldIgnoreLabeless = state.ignoreLabeless;
+    state.ignoreLabeless = true;
+    path.traverse(loopVisitor, state);
+    state.ignoreLabeless = oldIgnoreLabeless;
+    path.skip();
+  },
+
+  Function(path) {
+    path.skip();
+  },
+
+  SwitchCase(path, state) {
+    const oldInSwitchCase = state.inSwitchCase;
+    state.inSwitchCase = true;
+    path.traverse(loopVisitor, state);
+    state.inSwitchCase = oldInSwitchCase;
+    path.skip();
+  },
+
+  "BreakStatement|ContinueStatement|ReturnStatement"(path, state) {
+    const node = path.node,
+          parent = path.parent,
+          scope = path.scope;
+    if (node[this.LOOP_IGNORE]) return;
+    let replace;
+    let loopText = loopNodeTo(node);
+
+    if (loopText) {
+      if (node.label) {
+        if (state.innerLabels.indexOf(node.label.name) >= 0) {
+          return;
+        }
+
+        loopText = `${loopText}|${node.label.name}`;
+      } else {
+        if (state.ignoreLabeless) return;
+        if (_core().types.isBreakStatement(node) && _core().types.isSwitchCase(parent)) return;
+      }
+
+      state.hasBreakContinue = true;
+      state.map[loopText] = node;
+      replace = _core().types.stringLiteral(loopText);
+    }
+
+    if (path.isReturnStatement()) {
+      state.hasReturn = true;
+      replace = _core().types.objectExpression([_core().types.objectProperty(_core().types.identifier("v"), node.argument || scope.buildUndefinedNode())]);
+    }
+
+    if (replace) {
+      replace = _core().types.returnStatement(replace);
+      replace[this.LOOP_IGNORE] = true;
+      path.skip();
+      path.replaceWith(_core().types.inherits(replace, node));
+    }
+  }
+
+};
+
+class BlockScoping {
+  constructor(loopPath, blockPath, parent, scope, throwIfClosureRequired, tdzEnabled, state) {
+    this.parent = parent;
+    this.scope = scope;
+    this.state = state;
+    this.throwIfClosureRequired = throwIfClosureRequired;
+    this.tdzEnabled = tdzEnabled;
+    this.blockPath = blockPath;
+    this.block = blockPath.node;
+    this.outsideLetReferences = Object.create(null);
+    this.hasLetReferences = false;
+    this.letReferences = Object.create(null);
+    this.body = [];
+
+    if (loopPath) {
+      this.loopParent = loopPath.parent;
+      this.loopLabel = _core().types.isLabeledStatement(this.loopParent) && this.loopParent.label;
+      this.loopPath = loopPath;
+      this.loop = loopPath.node;
+    }
+  }
+
+  run() {
+    const block = this.block;
+    if (DONE.has(block)) return;
+    DONE.add(block);
+    const needsClosure = this.getLetReferences();
+    this.checkConstants();
+
+    if (_core().types.isFunction(this.parent) || _core().types.isProgram(this.block)) {
+      this.updateScopeInfo();
+      return;
+    }
+
+    if (!this.hasLetReferences) return;
+
+    if (needsClosure) {
+      this.wrapClosure();
+    } else {
+      this.remap();
+    }
+
+    this.updateScopeInfo(needsClosure);
+
+    if (this.loopLabel && !_core().types.isLabeledStatement(this.loopParent)) {
+      return _core().types.labeledStatement(this.loopLabel, this.loop);
+    }
+  }
+
+  checkConstants() {
+    const scope = this.scope;
+    const state = this.state;
+
+    for (const name in scope.bindings) {
+      const binding = scope.bindings[name];
+      if (binding.kind !== "const") continue;
+      var _arr = binding.constantViolations;
+
+      for (var _i = 0; _i < _arr.length; _i++) {
+        const violation = _arr[_i];
+        const readOnlyError = state.addHelper("readOnlyError");
+
+        const throwNode = _core().types.callExpression(readOnlyError, [_core().types.stringLiteral(name)]);
+
+        if (violation.isAssignmentExpression()) {
+          violation.get("right").replaceWith(_core().types.sequenceExpression([throwNode, violation.get("right").node]));
+        } else if (violation.isUpdateExpression()) {
+          violation.replaceWith(_core().types.sequenceExpression([throwNode, violation.node]));
+        } else if (violation.isForXStatement()) {
+          violation.ensureBlock();
+          violation.node.body.body.unshift(_core().types.expressionStatement(throwNode));
+        }
+      }
+    }
+  }
+
+  updateScopeInfo(wrappedInClosure) {
+    const scope = this.scope;
+    const parentScope = scope.getFunctionParent() || scope.getProgramParent();
+    const letRefs = this.letReferences;
+
+    for (const key in letRefs) {
+      const ref = letRefs[key];
+      const binding = scope.getBinding(ref.name);
+      if (!binding) continue;
+
+      if (binding.kind === "let" || binding.kind === "const") {
+        binding.kind = "var";
+
+        if (wrappedInClosure) {
+          scope.removeBinding(ref.name);
+        } else {
+          scope.moveBindingTo(ref.name, parentScope);
+        }
+      }
+    }
+  }
+
+  remap() {
+    const letRefs = this.letReferences;
+    const scope = this.scope;
+
+    for (const key in letRefs) {
+      const ref = letRefs[key];
+
+      if (scope.parentHasBinding(key) || scope.hasGlobal(key)) {
+        if (scope.hasOwnBinding(key)) {
+          scope.rename(ref.name);
+        }
+
+        if (this.blockPath.scope.hasOwnBinding(key)) {
+          this.blockPath.scope.rename(ref.name);
+        }
+      }
+    }
+  }
+
+  wrapClosure() {
+    if (this.throwIfClosureRequired) {
+      throw this.blockPath.buildCodeFrameError("Compiling let/const in this block would add a closure " + "(throwIfClosureRequired).");
+    }
+
+    const block = this.block;
+    const outsideRefs = this.outsideLetReferences;
+
+    if (this.loop) {
+      for (const name in outsideRefs) {
+        const id = outsideRefs[name];
+
+        if (this.scope.hasGlobal(id.name) || this.scope.parentHasBinding(id.name)) {
+          delete outsideRefs[id.name];
+          delete this.letReferences[id.name];
+          this.scope.rename(id.name);
+          this.letReferences[id.name] = id;
+          outsideRefs[id.name] = id;
+        }
+      }
+    }
+
+    this.has = this.checkLoop();
+    this.hoistVarDeclarations();
+    const args = (0, _values().default)(outsideRefs).map(id => _core().types.cloneNode(id));
+    const params = args.map(id => _core().types.cloneNode(id));
+    const isSwitch = this.blockPath.isSwitchStatement();
+
+    const fn = _core().types.functionExpression(null, params, _core().types.blockStatement(isSwitch ? [block] : block.body));
+
+    this.addContinuations(fn);
+
+    let call = _core().types.callExpression(_core().types.nullLiteral(), args);
+
+    let basePath = ".callee";
+
+    const hasYield = _core().traverse.hasType(fn.body, "YieldExpression", _core().types.FUNCTION_TYPES);
+
+    if (hasYield) {
+      fn.generator = true;
+      call = _core().types.yieldExpression(call, true);
+      basePath = ".argument" + basePath;
+    }
+
+    const hasAsync = _core().traverse.hasType(fn.body, "AwaitExpression", _core().types.FUNCTION_TYPES);
+
+    if (hasAsync) {
+      fn.async = true;
+      call = _core().types.awaitExpression(call);
+      basePath = ".argument" + basePath;
+    }
+
+    let placeholderPath;
+    let index;
+
+    if (this.has.hasReturn || this.has.hasBreakContinue) {
+      const ret = this.scope.generateUid("ret");
+      this.body.push(_core().types.variableDeclaration("var", [_core().types.variableDeclarator(_core().types.identifier(ret), call)]));
+      placeholderPath = "declarations.0.init" + basePath;
+      index = this.body.length - 1;
+      this.buildHas(ret);
+    } else {
+      this.body.push(_core().types.expressionStatement(call));
+      placeholderPath = "expression" + basePath;
+      index = this.body.length - 1;
+    }
+
+    let callPath;
+
+    if (isSwitch) {
+      const _this$blockPath = this.blockPath,
+            parentPath = _this$blockPath.parentPath,
+            listKey = _this$blockPath.listKey,
+            key = _this$blockPath.key;
+      this.blockPath.replaceWithMultiple(this.body);
+      callPath = parentPath.get(listKey)[key + index];
+    } else {
+      block.body = this.body;
+      callPath = this.blockPath.get("body")[index];
+    }
+
+    const placeholder = callPath.get(placeholderPath);
+    let fnPath;
+
+    if (this.loop) {
+      const loopId = this.scope.generateUid("loop");
+      const p = this.loopPath.insertBefore(_core().types.variableDeclaration("var", [_core().types.variableDeclarator(_core().types.identifier(loopId), fn)]));
+      placeholder.replaceWith(_core().types.identifier(loopId));
+      fnPath = p[0].get("declarations.0.init");
+    } else {
+      placeholder.replaceWith(fn);
+      fnPath = placeholder;
+    }
+
+    fnPath.unwrapFunctionEnvironment();
+  }
+
+  addContinuations(fn) {
+    const state = {
+      reassignments: {},
+      returnStatements: [],
+      outsideReferences: this.outsideLetReferences
+    };
+    this.scope.traverse(fn, continuationVisitor, state);
+
+    for (let i = 0; i < fn.params.length; i++) {
+      const param = fn.params[i];
+      if (!state.reassignments[param.name]) continue;
+      const paramName = param.name;
+      const newParamName = this.scope.generateUid(param.name);
+      fn.params[i] = _core().types.identifier(newParamName);
+      this.scope.rename(paramName, newParamName, fn);
+      state.returnStatements.forEach(returnStatement => {
+        returnStatement.insertBefore(_core().types.expressionStatement(_core().types.assignmentExpression("=", _core().types.identifier(paramName), _core().types.identifier(newParamName))));
+      });
+      fn.body.body.push(_core().types.expressionStatement(_core().types.assignmentExpression("=", _core().types.identifier(paramName), _core().types.identifier(newParamName))));
+    }
+  }
+
+  getLetReferences() {
+    const block = this.block;
+    let declarators = [];
+
+    if (this.loop) {
+      const init = this.loop.left || this.loop.init;
+
+      if (isBlockScoped(init)) {
+        declarators.push(init);
+        (0, _extend().default)(this.outsideLetReferences, _core().types.getBindingIdentifiers(init));
+      }
+    }
+
+    const addDeclarationsFromChild = (path, node) => {
+      node = node || path.node;
+
+      if (_core().types.isClassDeclaration(node) || _core().types.isFunctionDeclaration(node) || isBlockScoped(node)) {
+        if (isBlockScoped(node)) {
+          convertBlockScopedToVar(path, node, block, this.scope);
+        }
+
+        declarators = declarators.concat(node.declarations || node);
+      }
+
+      if (_core().types.isLabeledStatement(node)) {
+        addDeclarationsFromChild(path.get("body"), node.body);
+      }
+    };
+
+    if (block.body) {
+      const declarPaths = this.blockPath.get("body");
+
+      for (let i = 0; i < block.body.length; i++) {
+        addDeclarationsFromChild(declarPaths[i]);
+      }
+    }
+
+    if (block.cases) {
+      const declarPaths = this.blockPath.get("cases");
+
+      for (let i = 0; i < block.cases.length; i++) {
+        const consequents = block.cases[i].consequent;
+
+        for (let j = 0; j < consequents.length; j++) {
+          const declar = consequents[j];
+          addDeclarationsFromChild(declarPaths[i], declar);
+        }
+      }
+    }
+
+    for (let i = 0; i < declarators.length; i++) {
+      const declar = declarators[i];
+
+      const keys = _core().types.getBindingIdentifiers(declar, false, true);
+
+      (0, _extend().default)(this.letReferences, keys);
+      this.hasLetReferences = true;
+    }
+
+    if (!this.hasLetReferences) return;
+    const state = {
+      letReferences: this.letReferences,
+      closurify: false,
+      loopDepth: 0,
+      tdzEnabled: this.tdzEnabled,
+      addHelper: name => this.addHelper(name)
+    };
+
+    if (isInLoop(this.blockPath)) {
+      state.loopDepth++;
+    }
+
+    this.blockPath.traverse(letReferenceBlockVisitor, state);
+    return state.closurify;
+  }
+
+  checkLoop() {
+    const state = {
+      hasBreakContinue: false,
+      ignoreLabeless: false,
+      inSwitchCase: false,
+      innerLabels: [],
+      hasReturn: false,
+      isLoop: !!this.loop,
+      map: {},
+      LOOP_IGNORE: Symbol()
+    };
+    this.blockPath.traverse(loopLabelVisitor, state);
+    this.blockPath.traverse(loopVisitor, state);
+    return state;
+  }
+
+  hoistVarDeclarations() {
+    this.blockPath.traverse(hoistVarDeclarationsVisitor, this);
+  }
+
+  pushDeclar(node) {
+    const declars = [];
+
+    const names = _core().types.getBindingIdentifiers(node);
+
+    for (const name in names) {
+      declars.push(_core().types.variableDeclarator(names[name]));
+    }
+
+    this.body.push(_core().types.variableDeclaration(node.kind, declars));
+    const replace = [];
+
+    for (let i = 0; i < node.declarations.length; i++) {
+      const declar = node.declarations[i];
+      if (!declar.init) continue;
+
+      const expr = _core().types.assignmentExpression("=", _core().types.cloneNode(declar.id), _core().types.cloneNode(declar.init));
+
+      replace.push(_core().types.inherits(expr, declar));
+    }
+
+    return replace;
+  }
+
+  buildHas(ret) {
+    const body = this.body;
+    let retCheck;
+    const has = this.has;
+    const cases = [];
+
+    if (has.hasReturn) {
+      retCheck = buildRetCheck({
+        RETURN: _core().types.identifier(ret)
+      });
+    }
+
+    if (has.hasBreakContinue) {
+      for (const key in has.map) {
+        cases.push(_core().types.switchCase(_core().types.stringLiteral(key), [has.map[key]]));
+      }
+
+      if (has.hasReturn) {
+        cases.push(_core().types.switchCase(null, [retCheck]));
+      }
+
+      if (cases.length === 1) {
+        const single = cases[0];
+        body.push(_core().types.ifStatement(_core().types.binaryExpression("===", _core().types.identifier(ret), single.test), single.consequent[0]));
+      } else {
+        if (this.loop) {
+          for (let i = 0; i < cases.length; i++) {
+            const caseConsequent = cases[i].consequent[0];
+
+            if (_core().types.isBreakStatement(caseConsequent) && !caseConsequent.label) {
+              if (!this.loopLabel) {
+                this.loopLabel = this.scope.generateUidIdentifier("loop");
+              }
+
+              caseConsequent.label = _core().types.cloneNode(this.loopLabel);
+            }
+          }
+        }
+
+        body.push(_core().types.switchStatement(_core().types.identifier(ret), cases));
+      }
+    } else {
+      if (has.hasReturn) {
+        body.push(retCheck);
+      }
+    }
+  }
+
+}
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-block-scoping/lib/tdz.js b/node_modules/@babel/plugin-transform-block-scoping/lib/tdz.js
new file mode 100644
index 00000000..df5b4d41
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-block-scoping/lib/tdz.js
@@ -0,0 +1,96 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.visitor = void 0;
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+function getTDZStatus(refPath, bindingPath) {
+  const executionStatus = bindingPath._guessExecutionStatusRelativeTo(refPath);
+
+  if (executionStatus === "before") {
+    return "inside";
+  } else if (executionStatus === "after") {
+    return "outside";
+  } else {
+    return "maybe";
+  }
+}
+
+function buildTDZAssert(node, state) {
+  return _core().types.callExpression(state.addHelper("temporalRef"), [node, _core().types.stringLiteral(node.name)]);
+}
+
+function isReference(node, scope, state) {
+  const declared = state.letReferences[node.name];
+  if (!declared) return false;
+  return scope.getBindingIdentifier(node.name) === declared;
+}
+
+const visitor = {
+  ReferencedIdentifier(path, state) {
+    if (!state.tdzEnabled) return;
+    const node = path.node,
+          parent = path.parent,
+          scope = path.scope;
+    if (path.parentPath.isFor({
+      left: node
+    })) return;
+    if (!isReference(node, scope, state)) return;
+    const bindingPath = scope.getBinding(node.name).path;
+    if (bindingPath.isFunctionDeclaration()) return;
+    const status = getTDZStatus(path, bindingPath);
+    if (status === "inside") return;
+
+    if (status === "maybe") {
+      const assert = buildTDZAssert(node, state);
+      bindingPath.parent._tdzThis = true;
+      path.skip();
+
+      if (path.parentPath.isUpdateExpression()) {
+        if (parent._ignoreBlockScopingTDZ) return;
+        path.parentPath.replaceWith(_core().types.sequenceExpression([assert, parent]));
+      } else {
+        path.replaceWith(assert);
+      }
+    } else if (status === "outside") {
+      path.replaceWith(_core().types.throwStatement(_core().types.inherits(_core().types.newExpression(_core().types.identifier("ReferenceError"), [_core().types.stringLiteral(`${node.name} is not defined - temporal dead zone`)]), node)));
+    }
+  },
+
+  AssignmentExpression: {
+    exit(path, state) {
+      if (!state.tdzEnabled) return;
+      const node = path.node;
+      if (node._ignoreBlockScopingTDZ) return;
+      const nodes = [];
+      const ids = path.getBindingIdentifiers();
+
+      for (const name in ids) {
+        const id = ids[name];
+
+        if (isReference(id, path.scope, state)) {
+          nodes.push(buildTDZAssert(id, state));
+        }
+      }
+
+      if (nodes.length) {
+        node._ignoreBlockScopingTDZ = true;
+        nodes.push(node);
+        path.replaceWithMultiple(nodes.map(_core().types.expressionStatement));
+      }
+    }
+
+  }
+};
+exports.visitor = visitor;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-block-scoping/package.json b/node_modules/@babel/plugin-transform-block-scoping/package.json
new file mode 100644
index 00000000..c23da85b
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-block-scoping/package.json
@@ -0,0 +1,22 @@
+{
+  "name": "@babel/plugin-transform-block-scoping",
+  "version": "7.0.0-beta.47",
+  "description": "Compile ES2015 block scoping (const and let) to ES5",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-block-scoping",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47",
+    "lodash": "^4.17.5"
+  },
+  "keywords": [
+    "babel-plugin"
+  ],
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-classes/README.md b/node_modules/@babel/plugin-transform-classes/README.md
new file mode 100644
index 00000000..b0f51307
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-classes/README.md
@@ -0,0 +1,127 @@
+# @babel/plugin-transform-classes
+
+> Compile ES2015 classes to ES5
+
+## Caveats
+
+When extending a native class (e.g., `class extends Array {}`), the super class
+needs to be wrapped. This is needed to workaround two problems:
+- Babel transpiles classes using `SuperClass.apply(/* ... */)`, but native
+  classes aren't callable and thus throw in this case.
+- Some built-in functions (like `Array`) always return a new object. Instead of
+  returning it, Babel should treat it as the new `this`.
+
+The wrapper works on IE11 and every other browser with `Object.setPrototypeOf` or `__proto__` as fallback.
+There is **NO IE <= 10 support**. If you need IE <= 10 it's recommended that you don't extend natives.
+
+## Examples
+
+**In**
+
+```javascript
+class Test {
+  constructor(name) {
+    this.name = name;
+  }
+
+  logger () {
+    console.log("Hello", this.name);
+  }
+}
+```
+
+**Out**
+
+```javascript
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Test = function () {
+  function Test(name) {
+    _classCallCheck(this, Test);
+
+    this.name = name;
+  }
+
+  Test.prototype.logger = function logger() {
+    console.log("Hello", this.name);
+  };
+
+  return Test;
+}();
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-classes
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```js
+// without options
+{
+  "plugins": ["@babel/plugin-transform-classes"]
+}
+
+// with options
+{
+  "plugins": [
+    ["@babel/plugin-transform-classes", {
+      "loose": true
+    }]
+  ]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-classes script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-classes"]
+});
+```
+
+## Options
+
+### `loose`
+
+`boolean`, defaults to `false`.
+
+#### Method enumerability
+
+Please note that in loose mode class methods **are** enumerable. This is not in line
+with the spec and you may run into issues.
+
+#### Method assignment
+
+Under loose mode, methods are defined on the class prototype with simple assignments
+instead of being defined. This can result in the following not working:
+
+```javascript
+class Foo {
+  set bar() {
+    throw new Error("foo!");
+  }
+}
+
+class Bar extends Foo {
+  bar() {
+    // will throw an error when this method is defined
+  }
+}
+```
+
+When `Bar.prototype.foo` is defined it triggers the setter on `Foo`. This is a
+case that is very unlikely to appear in production code however it's something
+to keep in mind.
diff --git a/node_modules/@babel/plugin-transform-classes/lib/index.js b/node_modules/@babel/plugin-transform-classes/lib/index.js
new file mode 100644
index 00000000..180c0551
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-classes/lib/index.js
@@ -0,0 +1,119 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperAnnotateAsPure() {
+  const data = _interopRequireDefault(require("@babel/helper-annotate-as-pure"));
+
+  _helperAnnotateAsPure = function _helperAnnotateAsPure() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperFunctionName() {
+  const data = _interopRequireDefault(require("@babel/helper-function-name"));
+
+  _helperFunctionName = function _helperFunctionName() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperSplitExportDeclaration() {
+  const data = _interopRequireDefault(require("@babel/helper-split-export-declaration"));
+
+  _helperSplitExportDeclaration = function _helperSplitExportDeclaration() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+function _globals() {
+  const data = _interopRequireDefault(require("globals"));
+
+  _globals = function _globals() {
+    return data;
+  };
+
+  return data;
+}
+
+var _transformClass = _interopRequireDefault(require("./transformClass"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const getBuiltinClasses = category => Object.keys(_globals().default[category]).filter(name => /^[A-Z]/.test(name));
+
+const builtinClasses = new Set([...getBuiltinClasses("builtin"), ...getBuiltinClasses("browser")]);
+
+var _default = (0, _helperPluginUtils().declare)((api, options) => {
+  api.assertVersion(7);
+  const loose = options.loose;
+  const VISITED = Symbol();
+  return {
+    visitor: {
+      ExportDefaultDeclaration(path) {
+        if (!path.get("declaration").isClassDeclaration()) return;
+        (0, _helperSplitExportDeclaration().default)(path);
+      },
+
+      ClassDeclaration(path) {
+        const node = path.node;
+        const ref = node.id || path.scope.generateUidIdentifier("class");
+        path.replaceWith(_core().types.variableDeclaration("let", [_core().types.variableDeclarator(ref, _core().types.toExpression(node))]));
+      },
+
+      ClassExpression(path, state) {
+        const node = path.node;
+        if (node[VISITED]) return;
+        const inferred = (0, _helperFunctionName().default)(path);
+
+        if (inferred && inferred !== node) {
+          path.replaceWith(inferred);
+          return;
+        }
+
+        node[VISITED] = true;
+        path.replaceWith((0, _transformClass.default)(path, state.file, builtinClasses, loose));
+
+        if (path.isCallExpression()) {
+          (0, _helperAnnotateAsPure().default)(path);
+
+          if (path.get("callee").isArrowFunctionExpression()) {
+            path.get("callee").arrowFunctionToExpression();
+          }
+        }
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-classes/lib/lib/memoise-decorators.js b/node_modules/@babel/plugin-transform-classes/lib/lib/memoise-decorators.js
new file mode 100644
index 00000000..bcf79b2f
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-classes/lib/lib/memoise-decorators.js
@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+function _default(decorators, scope) {
+  for (var _iterator = decorators, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref;
+
+    if (_isArray) {
+      if (_i >= _iterator.length) break;
+      _ref = _iterator[_i++];
+    } else {
+      _i = _iterator.next();
+      if (_i.done) break;
+      _ref = _i.value;
+    }
+
+    const decorator = _ref;
+    const expression = decorator.expression;
+    if (!_core().types.isMemberExpression(expression)) continue;
+    const temp = scope.maybeGenerateMemoised(expression.object);
+    let ref;
+    const nodes = [];
+
+    if (temp) {
+      ref = temp;
+      nodes.push(_core().types.assignmentExpression("=", temp, expression.object));
+    } else {
+      ref = expression.object;
+    }
+
+    nodes.push(_core().types.callExpression(_core().types.memberExpression(_core().types.memberExpression(ref, expression.property, expression.computed), _core().types.identifier("bind")), [ref]));
+
+    if (nodes.length === 1) {
+      decorator.expression = nodes[0];
+    } else {
+      decorator.expression = _core().types.sequenceExpression(nodes);
+    }
+  }
+
+  return decorators;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-classes/lib/transformClass.js b/node_modules/@babel/plugin-transform-classes/lib/transformClass.js
new file mode 100644
index 00000000..fc5c31a5
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-classes/lib/transformClass.js
@@ -0,0 +1,698 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = transformClass;
+
+function _helperFunctionName() {
+  const data = _interopRequireDefault(require("@babel/helper-function-name"));
+
+  _helperFunctionName = function _helperFunctionName() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperReplaceSupers() {
+  const data = _interopRequireWildcard(require("@babel/helper-replace-supers"));
+
+  _helperReplaceSupers = function _helperReplaceSupers() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperOptimiseCallExpression() {
+  const data = _interopRequireDefault(require("@babel/helper-optimise-call-expression"));
+
+  _helperOptimiseCallExpression = function _helperOptimiseCallExpression() {
+    return data;
+  };
+
+  return data;
+}
+
+function defineMap() {
+  const data = _interopRequireWildcard(require("@babel/helper-define-map"));
+
+  defineMap = function defineMap() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function buildConstructor(classRef, constructorBody, node) {
+  const func = _core().types.functionDeclaration(_core().types.cloneNode(classRef), [], constructorBody);
+
+  _core().types.inherits(func, node);
+
+  return func;
+}
+
+const verifyConstructorVisitor = _core().traverse.visitors.merge([_helperReplaceSupers().environmentVisitor, {
+  Super(path, state) {
+    if (state.isDerived) return;
+    const node = path.node,
+          parentPath = path.parentPath;
+
+    if (parentPath.isCallExpression({
+      callee: node
+    })) {
+      throw path.buildCodeFrameError("super() is only allowed in a derived constructor");
+    }
+  },
+
+  ThisExpression(path, state) {
+    if (!state.isDerived) return;
+    const node = path.node,
+          parentPath = path.parentPath;
+
+    if (parentPath.isMemberExpression({
+      object: node
+    })) {
+      return;
+    }
+
+    const assertion = _core().types.callExpression(state.file.addHelper("assertThisInitialized"), [node]);
+
+    path.replaceWith(assertion);
+    path.skip();
+  }
+
+}]);
+
+function transformClass(path, file, builtinClasses, isLoose) {
+  const classState = {
+    parent: undefined,
+    scope: undefined,
+    node: undefined,
+    path: undefined,
+    file: undefined,
+    classId: undefined,
+    classRef: undefined,
+    superName: undefined,
+    superReturns: [],
+    isDerived: false,
+    extendsNative: false,
+    construct: undefined,
+    constructorBody: undefined,
+    userConstructor: undefined,
+    userConstructorPath: undefined,
+    hasConstructor: false,
+    instancePropBody: [],
+    instancePropRefs: {},
+    staticPropBody: [],
+    body: [],
+    bareSupers: new Set(),
+    superThises: [],
+    pushedConstructor: false,
+    pushedInherits: false,
+    protoAlias: null,
+    isLoose: false,
+    hasInstanceDescriptors: false,
+    hasStaticDescriptors: false,
+    instanceMutatorMap: {},
+    staticMutatorMap: {}
+  };
+
+  const setState = newState => {
+    Object.assign(classState, newState);
+  };
+
+  const findThisesVisitor = _core().traverse.visitors.merge([_helperReplaceSupers().environmentVisitor, {
+    ThisExpression(path) {
+      classState.superThises.push(path);
+    }
+
+  }]);
+
+  function pushToMap(node, enumerable, kind = "value", scope) {
+    let mutatorMap;
+
+    if (node.static) {
+      setState({
+        hasStaticDescriptors: true
+      });
+      mutatorMap = classState.staticMutatorMap;
+    } else {
+      setState({
+        hasInstanceDescriptors: true
+      });
+      mutatorMap = classState.instanceMutatorMap;
+    }
+
+    const map = defineMap().push(mutatorMap, node, kind, classState.file, scope);
+
+    if (enumerable) {
+      map.enumerable = _core().types.booleanLiteral(true);
+    }
+
+    return map;
+  }
+
+  function maybeCreateConstructor() {
+    let hasConstructor = false;
+    const paths = classState.path.get("body.body");
+
+    for (var _iterator = paths, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i >= _iterator.length) break;
+        _ref = _iterator[_i++];
+      } else {
+        _i = _iterator.next();
+        if (_i.done) break;
+        _ref = _i.value;
+      }
+
+      const path = _ref;
+      hasConstructor = path.equals("kind", "constructor");
+      if (hasConstructor) break;
+    }
+
+    if (hasConstructor) return;
+    let params, body;
+
+    if (classState.isDerived) {
+      const constructor = _core().template.expression.ast`
+        (function () {
+          super(...arguments);
+        })
+      `;
+      params = constructor.params;
+      body = constructor.body;
+    } else {
+      params = [];
+      body = _core().types.blockStatement([]);
+    }
+
+    classState.path.get("body").unshiftContainer("body", _core().types.classMethod("constructor", _core().types.identifier("constructor"), params, body));
+  }
+
+  function buildBody() {
+    maybeCreateConstructor();
+    pushBody();
+    verifyConstructor();
+
+    if (classState.userConstructor) {
+      const constructorBody = classState.constructorBody,
+            userConstructor = classState.userConstructor,
+            construct = classState.construct;
+      constructorBody.body = constructorBody.body.concat(userConstructor.body.body);
+
+      _core().types.inherits(construct, userConstructor);
+
+      _core().types.inherits(constructorBody, userConstructor.body);
+    }
+
+    pushDescriptors();
+    pushInheritsToBody();
+  }
+
+  function pushBody() {
+    const classBodyPaths = classState.path.get("body.body");
+
+    for (var _iterator2 = classBodyPaths, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+      var _ref2;
+
+      if (_isArray2) {
+        if (_i2 >= _iterator2.length) break;
+        _ref2 = _iterator2[_i2++];
+      } else {
+        _i2 = _iterator2.next();
+        if (_i2.done) break;
+        _ref2 = _i2.value;
+      }
+
+      const path = _ref2;
+      const node = path.node;
+
+      if (path.isClassProperty()) {
+        throw path.buildCodeFrameError("Missing class properties transform.");
+      }
+
+      if (node.decorators) {
+        throw path.buildCodeFrameError("Method has decorators, put the decorator plugin before the classes one.");
+      }
+
+      if (_core().types.isClassMethod(node)) {
+        const isConstructor = node.kind === "constructor";
+
+        if (isConstructor) {
+          path.traverse(verifyConstructorVisitor, {
+            isDerived: classState.isDerived,
+            file: classState.file
+          });
+        }
+
+        const replaceSupers = new (_helperReplaceSupers().default)({
+          methodPath: path,
+          objectRef: classState.classRef,
+          superRef: classState.superName,
+          isLoose: classState.isLoose,
+          file: classState.file
+        });
+        replaceSupers.replace();
+        const state = {
+          returns: [],
+          bareSupers: new Set()
+        };
+        path.traverse(_core().traverse.visitors.merge([_helperReplaceSupers().environmentVisitor, {
+          ReturnStatement(path, state) {
+            if (!path.getFunctionParent().isArrowFunctionExpression()) {
+              state.returns.push(path);
+            }
+          },
+
+          Super(path, state) {
+            const node = path.node,
+                  parentPath = path.parentPath;
+
+            if (parentPath.isCallExpression({
+              callee: node
+            })) {
+              state.bareSupers.add(parentPath);
+            }
+          }
+
+        }]), state);
+
+        if (isConstructor) {
+          pushConstructor(state, node, path);
+        } else {
+          pushMethod(node, path);
+        }
+      }
+    }
+  }
+
+  function clearDescriptors() {
+    setState({
+      hasInstanceDescriptors: false,
+      hasStaticDescriptors: false,
+      instanceMutatorMap: {},
+      staticMutatorMap: {}
+    });
+  }
+
+  function pushDescriptors() {
+    const body = classState.body;
+    let instanceProps;
+    let staticProps;
+
+    if (classState.hasInstanceDescriptors) {
+      instanceProps = defineMap().toClassObject(classState.instanceMutatorMap);
+    }
+
+    if (classState.hasStaticDescriptors) {
+      staticProps = defineMap().toClassObject(classState.staticMutatorMap);
+    }
+
+    if (instanceProps || staticProps) {
+      if (instanceProps) {
+        instanceProps = defineMap().toComputedObjectFromClass(instanceProps);
+      }
+
+      if (staticProps) {
+        staticProps = defineMap().toComputedObjectFromClass(staticProps);
+      }
+
+      let args = [_core().types.cloneNode(classState.classRef), _core().types.nullLiteral(), _core().types.nullLiteral()];
+      if (instanceProps) args[1] = instanceProps;
+      if (staticProps) args[2] = staticProps;
+      let lastNonNullIndex = 0;
+
+      for (let i = 0; i < args.length; i++) {
+        if (!_core().types.isNullLiteral(args[i])) lastNonNullIndex = i;
+      }
+
+      args = args.slice(0, lastNonNullIndex + 1);
+      body.push(_core().types.expressionStatement(_core().types.callExpression(classState.file.addHelper("createClass"), args)));
+    }
+
+    clearDescriptors();
+  }
+
+  function wrapSuperCall(bareSuper, superRef, thisRef, body) {
+    let bareSuperNode = bareSuper.node;
+    let call;
+
+    if (classState.isLoose) {
+      bareSuperNode.arguments.unshift(_core().types.thisExpression());
+
+      if (bareSuperNode.arguments.length === 2 && _core().types.isSpreadElement(bareSuperNode.arguments[1]) && _core().types.isIdentifier(bareSuperNode.arguments[1].argument, {
+        name: "arguments"
+      })) {
+        bareSuperNode.arguments[1] = bareSuperNode.arguments[1].argument;
+        bareSuperNode.callee = _core().types.memberExpression(_core().types.cloneNode(superRef), _core().types.identifier("apply"));
+      } else {
+        bareSuperNode.callee = _core().types.memberExpression(_core().types.cloneNode(superRef), _core().types.identifier("call"));
+      }
+
+      call = _core().types.logicalExpression("||", bareSuperNode, _core().types.thisExpression());
+    } else {
+      bareSuperNode = (0, _helperOptimiseCallExpression().default)(_core().types.callExpression(classState.file.addHelper("getPrototypeOf"), [_core().types.cloneNode(classState.classRef)]), _core().types.thisExpression(), bareSuperNode.arguments);
+      call = _core().types.callExpression(classState.file.addHelper("possibleConstructorReturn"), [_core().types.thisExpression(), bareSuperNode]);
+    }
+
+    if (bareSuper.parentPath.isExpressionStatement() && bareSuper.parentPath.container === body.node.body && body.node.body.length - 1 === bareSuper.parentPath.key) {
+      if (classState.superThises.length) {
+        call = _core().types.assignmentExpression("=", thisRef(), call);
+      }
+
+      bareSuper.parentPath.replaceWith(_core().types.returnStatement(call));
+    } else {
+      bareSuper.replaceWith(_core().types.assignmentExpression("=", thisRef(), call));
+    }
+  }
+
+  function verifyConstructor() {
+    if (!classState.isDerived) return;
+    const path = classState.userConstructorPath;
+    const body = path.get("body");
+    path.traverse(findThisesVisitor);
+    let guaranteedSuperBeforeFinish = !!classState.bareSupers.size;
+
+    let _thisRef = function thisRef() {
+      const ref = path.scope.generateDeclaredUidIdentifier("this");
+
+      _thisRef = () => _core().types.cloneNode(ref);
+
+      return ref;
+    };
+
+    for (var _iterator3 = classState.bareSupers, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
+      var _ref3;
+
+      if (_isArray3) {
+        if (_i3 >= _iterator3.length) break;
+        _ref3 = _iterator3[_i3++];
+      } else {
+        _i3 = _iterator3.next();
+        if (_i3.done) break;
+        _ref3 = _i3.value;
+      }
+
+      const bareSuper = _ref3;
+      wrapSuperCall(bareSuper, classState.superName, _thisRef, body);
+
+      if (guaranteedSuperBeforeFinish) {
+        bareSuper.find(function (parentPath) {
+          if (parentPath === path) {
+            return true;
+          }
+
+          if (parentPath.isLoop() || parentPath.isConditional() || parentPath.isArrowFunctionExpression()) {
+            guaranteedSuperBeforeFinish = false;
+            return true;
+          }
+        });
+      }
+    }
+
+    for (var _iterator4 = classState.superThises, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
+      var _ref4;
+
+      if (_isArray4) {
+        if (_i4 >= _iterator4.length) break;
+        _ref4 = _iterator4[_i4++];
+      } else {
+        _i4 = _iterator4.next();
+        if (_i4.done) break;
+        _ref4 = _i4.value;
+      }
+
+      const thisPath = _ref4;
+      const node = thisPath.node,
+            parentPath = thisPath.parentPath;
+
+      if (parentPath.isMemberExpression({
+        object: node
+      })) {
+        thisPath.replaceWith(_thisRef());
+        continue;
+      }
+
+      thisPath.replaceWith(_core().types.callExpression(classState.file.addHelper("assertThisInitialized"), [_thisRef()]));
+    }
+
+    let wrapReturn;
+
+    if (classState.isLoose) {
+      wrapReturn = returnArg => {
+        const thisExpr = _core().types.callExpression(classState.file.addHelper("assertThisInitialized"), [_thisRef()]);
+
+        return returnArg ? _core().types.logicalExpression("||", returnArg, thisExpr) : thisExpr;
+      };
+    } else {
+      wrapReturn = returnArg => _core().types.callExpression(classState.file.addHelper("possibleConstructorReturn"), [_thisRef()].concat(returnArg || []));
+    }
+
+    const bodyPaths = body.get("body");
+
+    if (!bodyPaths.length || !bodyPaths.pop().isReturnStatement()) {
+      body.pushContainer("body", _core().types.returnStatement(guaranteedSuperBeforeFinish ? _thisRef() : wrapReturn()));
+    }
+
+    for (var _iterator5 = classState.superReturns, _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) {
+      var _ref5;
+
+      if (_isArray5) {
+        if (_i5 >= _iterator5.length) break;
+        _ref5 = _iterator5[_i5++];
+      } else {
+        _i5 = _iterator5.next();
+        if (_i5.done) break;
+        _ref5 = _i5.value;
+      }
+
+      const returnPath = _ref5;
+      returnPath.get("argument").replaceWith(wrapReturn(returnPath.node.argument));
+    }
+  }
+
+  function pushMethod(node, path) {
+    const scope = path ? path.scope : classState.scope;
+
+    if (node.kind === "method") {
+      if (processMethod(node, scope)) return;
+    }
+
+    pushToMap(node, false, null, scope);
+  }
+
+  function processMethod(node, scope) {
+    if (classState.isLoose && !node.decorators) {
+      let classRef = classState.classRef;
+
+      if (!node.static) {
+        insertProtoAliasOnce();
+        classRef = classState.protoAlias;
+      }
+
+      const methodName = _core().types.memberExpression(_core().types.cloneNode(classRef), node.key, node.computed || _core().types.isLiteral(node.key));
+
+      let func = _core().types.functionExpression(null, node.params, node.body, node.generator, node.async);
+
+      func.returnType = node.returnType;
+
+      const key = _core().types.toComputedKey(node, node.key);
+
+      if (_core().types.isStringLiteral(key)) {
+        func = (0, _helperFunctionName().default)({
+          node: func,
+          id: key,
+          scope
+        });
+      }
+
+      const expr = _core().types.expressionStatement(_core().types.assignmentExpression("=", methodName, func));
+
+      _core().types.inheritsComments(expr, node);
+
+      classState.body.push(expr);
+      return true;
+    }
+
+    return false;
+  }
+
+  function insertProtoAliasOnce() {
+    if (classState.protoAlias === null) {
+      setState({
+        protoAlias: classState.scope.generateUidIdentifier("proto")
+      });
+
+      const classProto = _core().types.memberExpression(classState.classRef, _core().types.identifier("prototype"));
+
+      const protoDeclaration = _core().types.variableDeclaration("var", [_core().types.variableDeclarator(classState.protoAlias, classProto)]);
+
+      classState.body.push(protoDeclaration);
+    }
+  }
+
+  function pushConstructor(replaceSupers, method, path) {
+    if (path.scope.hasOwnBinding(classState.classRef.name)) {
+      path.scope.rename(classState.classRef.name);
+    }
+
+    setState({
+      userConstructorPath: path,
+      userConstructor: method,
+      hasConstructor: true,
+      bareSupers: replaceSupers.bareSupers,
+      superReturns: replaceSupers.returns
+    });
+    const construct = classState.construct;
+
+    _core().types.inheritsComments(construct, method);
+
+    construct.params = method.params;
+
+    _core().types.inherits(construct.body, method.body);
+
+    construct.body.directives = method.body.directives;
+    pushConstructorToBody();
+  }
+
+  function pushConstructorToBody() {
+    if (classState.pushedConstructor) return;
+    classState.pushedConstructor = true;
+
+    if (classState.hasInstanceDescriptors || classState.hasStaticDescriptors) {
+      pushDescriptors();
+    }
+
+    classState.body.push(classState.construct);
+  }
+
+  function pushInheritsToBody() {
+    if (!classState.isDerived || classState.pushedInherits) return;
+    setState({
+      pushedInherits: true
+    });
+    classState.body.push(_core().types.expressionStatement(_core().types.callExpression(classState.file.addHelper(classState.isLoose ? "inheritsLoose" : "inherits"), [_core().types.cloneNode(classState.classRef), _core().types.cloneNode(classState.superName)])));
+  }
+
+  function setupClosureParamsArgs() {
+    const superName = classState.superName;
+    const closureParams = [];
+    const closureArgs = [];
+
+    if (classState.isDerived) {
+      const arg = classState.extendsNative ? _core().types.callExpression(classState.file.addHelper("wrapNativeSuper"), [_core().types.cloneNode(superName)]) : _core().types.cloneNode(superName);
+      const param = classState.scope.generateUidIdentifierBasedOnNode(superName);
+      closureParams.push(param);
+      closureArgs.push(arg);
+      setState({
+        superName: _core().types.cloneNode(param)
+      });
+    }
+
+    return {
+      closureParams,
+      closureArgs
+    };
+  }
+
+  function classTransformer(path, file, builtinClasses, isLoose) {
+    setState({
+      parent: path.parent,
+      scope: path.scope,
+      node: path.node,
+      path,
+      file,
+      isLoose
+    });
+    setState({
+      classId: classState.node.id,
+      classRef: classState.node.id ? _core().types.identifier(classState.node.id.name) : classState.scope.generateUidIdentifier("class"),
+      superName: classState.node.superClass,
+      isDerived: !!classState.node.superClass,
+      constructorBody: _core().types.blockStatement([])
+    });
+    setState({
+      extendsNative: classState.isDerived && builtinClasses.has(classState.superName.name) && !classState.scope.hasBinding(classState.superName.name, true)
+    });
+    const classRef = classState.classRef,
+          node = classState.node,
+          constructorBody = classState.constructorBody;
+    setState({
+      construct: buildConstructor(classRef, constructorBody, node)
+    });
+    let body = classState.body;
+
+    const _setupClosureParamsAr = setupClosureParamsArgs(),
+          closureParams = _setupClosureParamsAr.closureParams,
+          closureArgs = _setupClosureParamsAr.closureArgs;
+
+    buildBody();
+
+    if (!classState.isLoose) {
+      constructorBody.body.unshift(_core().types.expressionStatement(_core().types.callExpression(classState.file.addHelper("classCallCheck"), [_core().types.thisExpression(), _core().types.cloneNode(classState.classRef)])));
+    }
+
+    body = body.concat(classState.staticPropBody.map(fn => fn(_core().types.cloneNode(classState.classRef))));
+    const isStrict = path.isInStrictMode();
+    let constructorOnly = classState.classId && body.length === 1;
+
+    if (constructorOnly && !isStrict) {
+      for (var _iterator6 = classState.construct.params, _isArray6 = Array.isArray(_iterator6), _i6 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) {
+        var _ref6;
+
+        if (_isArray6) {
+          if (_i6 >= _iterator6.length) break;
+          _ref6 = _iterator6[_i6++];
+        } else {
+          _i6 = _iterator6.next();
+          if (_i6.done) break;
+          _ref6 = _i6.value;
+        }
+
+        const param = _ref6;
+
+        if (!_core().types.isIdentifier(param)) {
+          constructorOnly = false;
+          break;
+        }
+      }
+    }
+
+    const directives = constructorOnly ? body[0].body.directives : [];
+
+    if (!isStrict) {
+      directives.push(_core().types.directive(_core().types.directiveLiteral("use strict")));
+    }
+
+    if (constructorOnly) {
+      return _core().types.toExpression(body[0]);
+    }
+
+    body.push(_core().types.returnStatement(_core().types.cloneNode(classState.classRef)));
+
+    const container = _core().types.arrowFunctionExpression(closureParams, _core().types.blockStatement(body, directives));
+
+    return _core().types.callExpression(container, closureArgs);
+  }
+
+  return classTransformer(path, file, builtinClasses, isLoose);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-classes/package.json b/node_modules/@babel/plugin-transform-classes/package.json
new file mode 100644
index 00000000..2d459c51
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-classes/package.json
@@ -0,0 +1,28 @@
+{
+  "name": "@babel/plugin-transform-classes",
+  "version": "7.0.0-beta.47",
+  "description": "Compile ES2015 classes to ES5",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-classes",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/helper-annotate-as-pure": "7.0.0-beta.47",
+    "@babel/helper-define-map": "7.0.0-beta.47",
+    "@babel/helper-function-name": "7.0.0-beta.47",
+    "@babel/helper-optimise-call-expression": "7.0.0-beta.47",
+    "@babel/helper-plugin-utils": "7.0.0-beta.47",
+    "@babel/helper-replace-supers": "7.0.0-beta.47",
+    "@babel/helper-split-export-declaration": "7.0.0-beta.47",
+    "globals": "^11.1.0"
+  },
+  "keywords": [
+    "babel-plugin"
+  ],
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-computed-properties/README.md b/node_modules/@babel/plugin-transform-computed-properties/README.md
new file mode 100644
index 00000000..0a420ba0
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-computed-properties/README.md
@@ -0,0 +1,130 @@
+# @babel/plugin-transform-computed-properties
+
+> Compile ES2015 computed properties to ES5
+
+## Example
+
+**In**
+
+```js
+var obj = {
+  ["x" + foo]: "heh",
+  ["y" + bar]: "noo",
+  foo: "foo",
+  bar: "bar"
+};
+```
+
+**Out**
+
+```js
+var _obj;
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+var obj = (
+  _obj = {},
+  _defineProperty(_obj, "x" + foo, "heh"),
+  _defineProperty(_obj, "y" + bar, "noo"),
+  _defineProperty(_obj, "foo", "foo"),
+  _defineProperty(_obj, "bar", "bar"),
+  _obj
+);
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-computed-properties
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+Without options:
+
+```json
+{
+  "plugins": ["@babel/plugin-transform-computed-properties"]
+}
+```
+
+With options:
+
+```json
+{
+  "plugins": [
+    ["@babel/plugin-transform-computed-properties", {
+      "loose": true
+    }]
+  ]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-computed-properties script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-computed-properties"]
+});
+```
+
+## Options
+
+### `loose`
+
+`boolean`, defaults to `false`
+
+Just like method assignment in classes, in loose mode, computed property names
+use simple assignments instead of being defined. This is unlikely to be an issue
+in production code.
+
+#### Example
+
+***In***
+
+```js
+var obj = {
+  ["x" + foo]: "heh",
+  ["y" + bar]: "noo",
+  foo: "foo",
+  bar: "bar"
+};
+```
+
+***Out***
+
+```js
+var _obj;
+
+var obj = (
+  _obj = {},
+  _obj["x" + foo] = "heh",
+  _obj["y" + bar] = "noo",
+  _obj.foo = "foo",
+  _obj.bar = "bar",
+  _obj
+);
+```
diff --git a/node_modules/@babel/plugin-transform-computed-properties/lib/index.js b/node_modules/@babel/plugin-transform-computed-properties/lib/index.js
new file mode 100644
index 00000000..6ae48311
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-computed-properties/lib/index.js
@@ -0,0 +1,225 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = (0, _helperPluginUtils().declare)((api, options) => {
+  api.assertVersion(7);
+  const loose = options.loose;
+  const pushComputedProps = loose ? pushComputedPropsLoose : pushComputedPropsSpec;
+  const buildMutatorMapAssign = (0, _core().template)(`
+    MUTATOR_MAP_REF[KEY] = MUTATOR_MAP_REF[KEY] || {};
+    MUTATOR_MAP_REF[KEY].KIND = VALUE;
+  `);
+
+  function getValue(prop) {
+    if (_core().types.isObjectProperty(prop)) {
+      return prop.value;
+    } else if (_core().types.isObjectMethod(prop)) {
+      return _core().types.functionExpression(null, prop.params, prop.body, prop.generator, prop.async);
+    }
+  }
+
+  function pushAssign(objId, prop, body) {
+    if (prop.kind === "get" && prop.kind === "set") {
+      pushMutatorDefine(objId, prop, body);
+    } else {
+      body.push(_core().types.expressionStatement(_core().types.assignmentExpression("=", _core().types.memberExpression(_core().types.cloneNode(objId), prop.key, prop.computed || _core().types.isLiteral(prop.key)), getValue(prop))));
+    }
+  }
+
+  function pushMutatorDefine({
+    body,
+    getMutatorId,
+    scope
+  }, prop) {
+    let key = !prop.computed && _core().types.isIdentifier(prop.key) ? _core().types.stringLiteral(prop.key.name) : prop.key;
+    const maybeMemoise = scope.maybeGenerateMemoised(key);
+
+    if (maybeMemoise) {
+      body.push(_core().types.expressionStatement(_core().types.assignmentExpression("=", maybeMemoise, key)));
+      key = maybeMemoise;
+    }
+
+    body.push(...buildMutatorMapAssign({
+      MUTATOR_MAP_REF: getMutatorId(),
+      KEY: _core().types.cloneNode(key),
+      VALUE: getValue(prop),
+      KIND: _core().types.identifier(prop.kind)
+    }));
+  }
+
+  function pushComputedPropsLoose(info) {
+    for (var _iterator = info.computedProps, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i >= _iterator.length) break;
+        _ref = _iterator[_i++];
+      } else {
+        _i = _iterator.next();
+        if (_i.done) break;
+        _ref = _i.value;
+      }
+
+      const prop = _ref;
+
+      if (prop.kind === "get" || prop.kind === "set") {
+        pushMutatorDefine(info, prop);
+      } else {
+        pushAssign(_core().types.cloneNode(info.objId), prop, info.body);
+      }
+    }
+  }
+
+  function pushComputedPropsSpec(info) {
+    const objId = info.objId,
+          body = info.body,
+          computedProps = info.computedProps,
+          state = info.state;
+
+    for (var _iterator2 = computedProps, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+      var _ref2;
+
+      if (_isArray2) {
+        if (_i2 >= _iterator2.length) break;
+        _ref2 = _iterator2[_i2++];
+      } else {
+        _i2 = _iterator2.next();
+        if (_i2.done) break;
+        _ref2 = _i2.value;
+      }
+
+      const prop = _ref2;
+
+      const key = _core().types.toComputedKey(prop);
+
+      if (prop.kind === "get" || prop.kind === "set") {
+        pushMutatorDefine(info, prop);
+      } else if (_core().types.isStringLiteral(key, {
+        value: "__proto__"
+      })) {
+        pushAssign(objId, prop, body);
+      } else {
+        if (computedProps.length === 1) {
+          return _core().types.callExpression(state.addHelper("defineProperty"), [info.initPropExpression, key, getValue(prop)]);
+        } else {
+          body.push(_core().types.expressionStatement(_core().types.callExpression(state.addHelper("defineProperty"), [_core().types.cloneNode(objId), key, getValue(prop)])));
+        }
+      }
+    }
+  }
+
+  return {
+    visitor: {
+      ObjectExpression: {
+        exit(path, state) {
+          const node = path.node,
+                parent = path.parent,
+                scope = path.scope;
+          let hasComputed = false;
+          var _arr = node.properties;
+
+          for (var _i3 = 0; _i3 < _arr.length; _i3++) {
+            const prop = _arr[_i3];
+            hasComputed = prop.computed === true;
+            if (hasComputed) break;
+          }
+
+          if (!hasComputed) return;
+          const initProps = [];
+          const computedProps = [];
+          let foundComputed = false;
+
+          for (var _iterator3 = node.properties, _isArray3 = Array.isArray(_iterator3), _i4 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
+            var _ref3;
+
+            if (_isArray3) {
+              if (_i4 >= _iterator3.length) break;
+              _ref3 = _iterator3[_i4++];
+            } else {
+              _i4 = _iterator3.next();
+              if (_i4.done) break;
+              _ref3 = _i4.value;
+            }
+
+            const prop = _ref3;
+
+            if (prop.computed) {
+              foundComputed = true;
+            }
+
+            if (foundComputed) {
+              computedProps.push(prop);
+            } else {
+              initProps.push(prop);
+            }
+          }
+
+          const objId = scope.generateUidIdentifierBasedOnNode(parent);
+
+          const initPropExpression = _core().types.objectExpression(initProps);
+
+          const body = [];
+          body.push(_core().types.variableDeclaration("var", [_core().types.variableDeclarator(objId, initPropExpression)]));
+          let mutatorRef;
+
+          const getMutatorId = function getMutatorId() {
+            if (!mutatorRef) {
+              mutatorRef = scope.generateUidIdentifier("mutatorMap");
+              body.push(_core().types.variableDeclaration("var", [_core().types.variableDeclarator(mutatorRef, _core().types.objectExpression([]))]));
+            }
+
+            return _core().types.cloneNode(mutatorRef);
+          };
+
+          const single = pushComputedProps({
+            scope,
+            objId,
+            body,
+            computedProps,
+            initPropExpression,
+            getMutatorId,
+            state
+          });
+
+          if (mutatorRef) {
+            body.push(_core().types.expressionStatement(_core().types.callExpression(state.addHelper("defineEnumerableProperties"), [_core().types.cloneNode(objId), _core().types.cloneNode(mutatorRef)])));
+          }
+
+          if (single) {
+            path.replaceWith(single);
+          } else {
+            body.push(_core().types.expressionStatement(_core().types.cloneNode(objId)));
+            path.replaceWithMultiple(body);
+          }
+        }
+
+      }
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-computed-properties/package.json b/node_modules/@babel/plugin-transform-computed-properties/package.json
new file mode 100644
index 00000000..b33b08d8
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-computed-properties/package.json
@@ -0,0 +1,21 @@
+{
+  "name": "@babel/plugin-transform-computed-properties",
+  "version": "7.0.0-beta.47",
+  "description": "Compile ES2015 computed properties to ES5",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-computed-properties",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-destructuring/README.md b/node_modules/@babel/plugin-transform-destructuring/README.md
new file mode 100644
index 00000000..d31e0e20
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-destructuring/README.md
@@ -0,0 +1,104 @@
+# @babel/plugin-transform-destructuring
+
+> Compile ES2015 destructuring to ES5
+
+## Examples
+
+**In**
+
+```javascript
+let {x, y} = obj;
+
+let [a, b, ...rest] = arr;
+```
+
+**Out**
+
+```javascript
+function _toArray(arr) { ... }
+
+let _obj = obj,
+    x = _obj.x,
+    y = _obj.y;
+
+let _arr = arr,
+    _arr2 = _toArray(_arr),
+    a = _arr2[0],
+    b = _arr2[1],
+    rest = _arr2.slice(2);
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-destructuring
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-transform-destructuring"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-destructuring script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-destructuring"]
+});
+```
+
+## Options
+
+### `loose`
+
+`boolean`, defaults to `false`.
+
+Enabling this option will assume that what you want to destructure is an array and won't use `Array.from` on other iterables.
+
+### `useBuiltIns`
+
+`boolean`, defaults to `false`.
+
+Enabling this option will use `Object.assign` directly instead of the Babel's `extends` helper. 
+
+##### Example
+
+**.babelrc**
+
+```json
+{
+  "plugins": [
+    ["@babel/plugin-transform-destructuring", { "useBuiltIns": true }]
+  ]
+}
+```
+
+**In**
+
+```js
+var { ...x } = z;
+```
+
+**Out**
+
+```js
+var _z = z,
+    x = Object.assign({}, _z);
+```
+
+## References
+
+* [MDN: Destructuring assignment](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment)
diff --git a/node_modules/@babel/plugin-transform-destructuring/lib/index.js b/node_modules/@babel/plugin-transform-destructuring/lib/index.js
new file mode 100644
index 00000000..11075331
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-destructuring/lib/index.js
@@ -0,0 +1,514 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = (0, _helperPluginUtils().declare)((api, options) => {
+  api.assertVersion(7);
+  const _options$loose = options.loose,
+        loose = _options$loose === void 0 ? false : _options$loose,
+        _options$useBuiltIns = options.useBuiltIns,
+        useBuiltIns = _options$useBuiltIns === void 0 ? false : _options$useBuiltIns;
+
+  if (typeof loose !== "boolean") {
+    throw new Error(`.loose must be a boolean or undefined`);
+  }
+
+  const arrayOnlySpread = loose;
+
+  function getExtendsHelper(file) {
+    return useBuiltIns ? _core().types.memberExpression(_core().types.identifier("Object"), _core().types.identifier("assign")) : file.addHelper("extends");
+  }
+
+  function variableDeclarationHasPattern(node) {
+    var _arr = node.declarations;
+
+    for (var _i = 0; _i < _arr.length; _i++) {
+      const declar = _arr[_i];
+
+      if (_core().types.isPattern(declar.id)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  function hasRest(pattern) {
+    var _arr2 = pattern.elements;
+
+    for (var _i2 = 0; _i2 < _arr2.length; _i2++) {
+      const elem = _arr2[_i2];
+
+      if (_core().types.isRestElement(elem)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  const arrayUnpackVisitor = {
+    ReferencedIdentifier(path, state) {
+      if (state.bindings[path.node.name]) {
+        state.deopt = true;
+        path.stop();
+      }
+    }
+
+  };
+
+  class DestructuringTransformer {
+    constructor(opts) {
+      this.blockHoist = opts.blockHoist;
+      this.operator = opts.operator;
+      this.arrays = {};
+      this.nodes = opts.nodes || [];
+      this.scope = opts.scope;
+      this.kind = opts.kind;
+      this.arrayOnlySpread = opts.arrayOnlySpread;
+      this.addHelper = opts.addHelper;
+    }
+
+    buildVariableAssignment(id, init) {
+      let op = this.operator;
+      if (_core().types.isMemberExpression(id)) op = "=";
+      let node;
+
+      if (op) {
+        node = _core().types.expressionStatement(_core().types.assignmentExpression(op, id, _core().types.cloneNode(init)));
+      } else {
+        node = _core().types.variableDeclaration(this.kind, [_core().types.variableDeclarator(id, _core().types.cloneNode(init))]);
+      }
+
+      node._blockHoist = this.blockHoist;
+      return node;
+    }
+
+    buildVariableDeclaration(id, init) {
+      const declar = _core().types.variableDeclaration("var", [_core().types.variableDeclarator(_core().types.cloneNode(id), _core().types.cloneNode(init))]);
+
+      declar._blockHoist = this.blockHoist;
+      return declar;
+    }
+
+    push(id, _init) {
+      const init = _core().types.cloneNode(_init);
+
+      if (_core().types.isObjectPattern(id)) {
+        this.pushObjectPattern(id, init);
+      } else if (_core().types.isArrayPattern(id)) {
+        this.pushArrayPattern(id, init);
+      } else if (_core().types.isAssignmentPattern(id)) {
+        this.pushAssignmentPattern(id, init);
+      } else {
+        this.nodes.push(this.buildVariableAssignment(id, init));
+      }
+    }
+
+    toArray(node, count) {
+      if (this.arrayOnlySpread || _core().types.isIdentifier(node) && this.arrays[node.name]) {
+        return node;
+      } else {
+        return this.scope.toArray(node, count);
+      }
+    }
+
+    pushAssignmentPattern({
+      left,
+      right
+    }, valueRef) {
+      const tempId = this.scope.generateUidIdentifierBasedOnNode(valueRef);
+      this.nodes.push(this.buildVariableDeclaration(tempId, valueRef));
+
+      const tempConditional = _core().types.conditionalExpression(_core().types.binaryExpression("===", _core().types.cloneNode(tempId), this.scope.buildUndefinedNode()), right, _core().types.cloneNode(tempId));
+
+      if (_core().types.isPattern(left)) {
+        let patternId;
+        let node;
+
+        if (this.kind === "const") {
+          patternId = this.scope.generateUidIdentifier(tempId.name);
+          node = this.buildVariableDeclaration(patternId, tempConditional);
+        } else {
+          patternId = tempId;
+          node = _core().types.expressionStatement(_core().types.assignmentExpression("=", _core().types.cloneNode(tempId), tempConditional));
+        }
+
+        this.nodes.push(node);
+        this.push(left, patternId);
+      } else {
+        this.nodes.push(this.buildVariableAssignment(left, tempConditional));
+      }
+    }
+
+    pushObjectRest(pattern, objRef, spreadProp, spreadPropIndex) {
+      let keys = [];
+
+      for (let i = 0; i < pattern.properties.length; i++) {
+        const prop = pattern.properties[i];
+        if (i >= spreadPropIndex) break;
+        if (_core().types.isRestElement(prop)) continue;
+        let key = prop.key;
+
+        if (_core().types.isIdentifier(key) && !prop.computed) {
+          key = _core().types.stringLiteral(prop.key.name);
+        }
+
+        keys.push(_core().types.cloneNode(key));
+      }
+
+      let value;
+
+      if (keys.length === 0) {
+        value = _core().types.callExpression(getExtendsHelper(this), [_core().types.objectExpression([]), _core().types.cloneNode(objRef)]);
+      } else {
+        keys = _core().types.arrayExpression(keys);
+        value = _core().types.callExpression(this.addHelper("objectWithoutProperties"), [_core().types.cloneNode(objRef), keys]);
+      }
+
+      this.nodes.push(this.buildVariableAssignment(spreadProp.argument, value));
+    }
+
+    pushObjectProperty(prop, propRef) {
+      if (_core().types.isLiteral(prop.key)) prop.computed = true;
+      const pattern = prop.value;
+
+      const objRef = _core().types.memberExpression(_core().types.cloneNode(propRef), prop.key, prop.computed);
+
+      if (_core().types.isPattern(pattern)) {
+        this.push(pattern, objRef);
+      } else {
+        this.nodes.push(this.buildVariableAssignment(pattern, objRef));
+      }
+    }
+
+    pushObjectPattern(pattern, objRef) {
+      if (!pattern.properties.length) {
+        this.nodes.push(_core().types.expressionStatement(_core().types.callExpression(this.addHelper("objectDestructuringEmpty"), [objRef])));
+      }
+
+      if (pattern.properties.length > 1 && !this.scope.isStatic(objRef)) {
+        const temp = this.scope.generateUidIdentifierBasedOnNode(objRef);
+        this.nodes.push(this.buildVariableDeclaration(temp, objRef));
+        objRef = temp;
+      }
+
+      for (let i = 0; i < pattern.properties.length; i++) {
+        const prop = pattern.properties[i];
+
+        if (_core().types.isRestElement(prop)) {
+          this.pushObjectRest(pattern, objRef, prop, i);
+        } else {
+          this.pushObjectProperty(prop, objRef);
+        }
+      }
+    }
+
+    canUnpackArrayPattern(pattern, arr) {
+      if (!_core().types.isArrayExpression(arr)) return false;
+      if (pattern.elements.length > arr.elements.length) return;
+
+      if (pattern.elements.length < arr.elements.length && !hasRest(pattern)) {
+        return false;
+      }
+
+      var _arr3 = pattern.elements;
+
+      for (var _i3 = 0; _i3 < _arr3.length; _i3++) {
+        const elem = _arr3[_i3];
+        if (!elem) return false;
+        if (_core().types.isMemberExpression(elem)) return false;
+      }
+
+      var _arr4 = arr.elements;
+
+      for (var _i4 = 0; _i4 < _arr4.length; _i4++) {
+        const elem = _arr4[_i4];
+        if (_core().types.isSpreadElement(elem)) return false;
+        if (_core().types.isCallExpression(elem)) return false;
+        if (_core().types.isMemberExpression(elem)) return false;
+      }
+
+      const bindings = _core().types.getBindingIdentifiers(pattern);
+
+      const state = {
+        deopt: false,
+        bindings
+      };
+      this.scope.traverse(arr, arrayUnpackVisitor, state);
+      return !state.deopt;
+    }
+
+    pushUnpackedArrayPattern(pattern, arr) {
+      for (let i = 0; i < pattern.elements.length; i++) {
+        const elem = pattern.elements[i];
+
+        if (_core().types.isRestElement(elem)) {
+          this.push(elem.argument, _core().types.arrayExpression(arr.elements.slice(i)));
+        } else {
+          this.push(elem, arr.elements[i]);
+        }
+      }
+    }
+
+    pushArrayPattern(pattern, arrayRef) {
+      if (!pattern.elements) return;
+
+      if (this.canUnpackArrayPattern(pattern, arrayRef)) {
+        return this.pushUnpackedArrayPattern(pattern, arrayRef);
+      }
+
+      const count = !hasRest(pattern) && pattern.elements.length;
+      const toArray = this.toArray(arrayRef, count);
+
+      if (_core().types.isIdentifier(toArray)) {
+        arrayRef = toArray;
+      } else {
+        arrayRef = this.scope.generateUidIdentifierBasedOnNode(arrayRef);
+        this.arrays[arrayRef.name] = true;
+        this.nodes.push(this.buildVariableDeclaration(arrayRef, toArray));
+      }
+
+      for (let i = 0; i < pattern.elements.length; i++) {
+        let elem = pattern.elements[i];
+        if (!elem) continue;
+        let elemRef;
+
+        if (_core().types.isRestElement(elem)) {
+          elemRef = this.toArray(arrayRef);
+          elemRef = _core().types.callExpression(_core().types.memberExpression(elemRef, _core().types.identifier("slice")), [_core().types.numericLiteral(i)]);
+          elem = elem.argument;
+        } else {
+          elemRef = _core().types.memberExpression(arrayRef, _core().types.numericLiteral(i), true);
+        }
+
+        this.push(elem, elemRef);
+      }
+    }
+
+    init(pattern, ref) {
+      if (!_core().types.isArrayExpression(ref) && !_core().types.isMemberExpression(ref)) {
+        const memo = this.scope.maybeGenerateMemoised(ref, true);
+
+        if (memo) {
+          this.nodes.push(this.buildVariableDeclaration(memo, _core().types.cloneNode(ref)));
+          ref = memo;
+        }
+      }
+
+      this.push(pattern, ref);
+      return this.nodes;
+    }
+
+  }
+
+  return {
+    visitor: {
+      ExportNamedDeclaration(path) {
+        const declaration = path.get("declaration");
+        if (!declaration.isVariableDeclaration()) return;
+        if (!variableDeclarationHasPattern(declaration.node)) return;
+        const specifiers = [];
+
+        for (const name in path.getOuterBindingIdentifiers(path)) {
+          specifiers.push(_core().types.exportSpecifier(_core().types.identifier(name), _core().types.identifier(name)));
+        }
+
+        path.replaceWith(declaration.node);
+        path.insertAfter(_core().types.exportNamedDeclaration(null, specifiers));
+      },
+
+      ForXStatement(path) {
+        const node = path.node,
+              scope = path.scope;
+        const left = node.left;
+
+        if (_core().types.isPattern(left)) {
+          const temp = scope.generateUidIdentifier("ref");
+          node.left = _core().types.variableDeclaration("var", [_core().types.variableDeclarator(temp)]);
+          path.ensureBlock();
+          node.body.body.unshift(_core().types.variableDeclaration("var", [_core().types.variableDeclarator(left, temp)]));
+          return;
+        }
+
+        if (!_core().types.isVariableDeclaration(left)) return;
+        const pattern = left.declarations[0].id;
+        if (!_core().types.isPattern(pattern)) return;
+        const key = scope.generateUidIdentifier("ref");
+        node.left = _core().types.variableDeclaration(left.kind, [_core().types.variableDeclarator(key, null)]);
+        const nodes = [];
+        const destructuring = new DestructuringTransformer({
+          kind: left.kind,
+          scope: scope,
+          nodes: nodes,
+          arrayOnlySpread,
+          addHelper: name => this.addHelper(name)
+        });
+        destructuring.init(pattern, key);
+        path.ensureBlock();
+        const block = node.body;
+        block.body = nodes.concat(block.body);
+      },
+
+      CatchClause({
+        node,
+        scope
+      }) {
+        const pattern = node.param;
+        if (!_core().types.isPattern(pattern)) return;
+        const ref = scope.generateUidIdentifier("ref");
+        node.param = ref;
+        const nodes = [];
+        const destructuring = new DestructuringTransformer({
+          kind: "let",
+          scope: scope,
+          nodes: nodes,
+          arrayOnlySpread,
+          addHelper: name => this.addHelper(name)
+        });
+        destructuring.init(pattern, ref);
+        node.body.body = nodes.concat(node.body.body);
+      },
+
+      AssignmentExpression(path) {
+        const node = path.node,
+              scope = path.scope;
+        if (!_core().types.isPattern(node.left)) return;
+        const nodes = [];
+        const destructuring = new DestructuringTransformer({
+          operator: node.operator,
+          scope: scope,
+          nodes: nodes,
+          arrayOnlySpread,
+          addHelper: name => this.addHelper(name)
+        });
+        let ref;
+
+        if (path.isCompletionRecord() || !path.parentPath.isExpressionStatement()) {
+          ref = scope.generateUidIdentifierBasedOnNode(node.right, "ref");
+          nodes.push(_core().types.variableDeclaration("var", [_core().types.variableDeclarator(ref, node.right)]));
+
+          if (_core().types.isArrayExpression(node.right)) {
+            destructuring.arrays[ref.name] = true;
+          }
+        }
+
+        destructuring.init(node.left, ref || node.right);
+
+        if (ref) {
+          nodes.push(_core().types.expressionStatement(_core().types.cloneNode(ref)));
+        }
+
+        path.replaceWithMultiple(nodes);
+      },
+
+      VariableDeclaration(path) {
+        const node = path.node,
+              scope = path.scope,
+              parent = path.parent;
+        if (_core().types.isForXStatement(parent)) return;
+        if (!parent || !path.container) return;
+        if (!variableDeclarationHasPattern(node)) return;
+        const nodeKind = node.kind;
+        const nodes = [];
+        let declar;
+
+        for (let i = 0; i < node.declarations.length; i++) {
+          declar = node.declarations[i];
+          const patternId = declar.init;
+          const pattern = declar.id;
+          const destructuring = new DestructuringTransformer({
+            blockHoist: node._blockHoist,
+            nodes: nodes,
+            scope: scope,
+            kind: node.kind,
+            arrayOnlySpread,
+            addHelper: name => this.addHelper(name)
+          });
+
+          if (_core().types.isPattern(pattern)) {
+            destructuring.init(pattern, patternId);
+
+            if (+i !== node.declarations.length - 1) {
+              _core().types.inherits(nodes[nodes.length - 1], declar);
+            }
+          } else {
+            nodes.push(_core().types.inherits(destructuring.buildVariableAssignment(declar.id, _core().types.cloneNode(declar.init)), declar));
+          }
+        }
+
+        let tail = null;
+        const nodesOut = [];
+
+        for (var _i5 = 0; _i5 < nodes.length; _i5++) {
+          const node = nodes[_i5];
+
+          if (tail !== null && _core().types.isVariableDeclaration(node)) {
+            tail.declarations.push(...node.declarations);
+          } else {
+            node.kind = nodeKind;
+            nodesOut.push(node);
+            tail = _core().types.isVariableDeclaration(node) ? node : null;
+          }
+        }
+
+        for (var _i6 = 0; _i6 < nodesOut.length; _i6++) {
+          const nodeOut = nodesOut[_i6];
+          if (!nodeOut.declarations) continue;
+
+          for (var _iterator = nodeOut.declarations, _isArray = Array.isArray(_iterator), _i7 = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+            var _ref;
+
+            if (_isArray) {
+              if (_i7 >= _iterator.length) break;
+              _ref = _iterator[_i7++];
+            } else {
+              _i7 = _iterator.next();
+              if (_i7.done) break;
+              _ref = _i7.value;
+            }
+
+            const declaration = _ref;
+            const name = declaration.id.name;
+
+            if (scope.bindings[name]) {
+              scope.bindings[name].kind = nodeOut.kind;
+            }
+          }
+        }
+
+        if (nodesOut.length === 1) {
+          path.replaceWith(nodesOut[0]);
+        } else {
+          path.replaceWithMultiple(nodesOut);
+        }
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-destructuring/package.json b/node_modules/@babel/plugin-transform-destructuring/package.json
new file mode 100644
index 00000000..340ddaf8
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-destructuring/package.json
@@ -0,0 +1,21 @@
+{
+  "name": "@babel/plugin-transform-destructuring",
+  "version": "7.0.0-beta.47",
+  "description": "Compile ES2015 destructuring to ES5",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-destructuring",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-dotall-regex/README.md b/node_modules/@babel/plugin-transform-dotall-regex/README.md
new file mode 100644
index 00000000..d180193c
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-dotall-regex/README.md
@@ -0,0 +1,69 @@
+# @babel/plugin-transform-dotall-regex
+
+> Compile regular expressions using [the `s` (`dotAll`) flag](https://github.com/tc39/proposal-regexp-dotall-flag) to ES5 that works in today’s environments.
+
+## Example
+
+**In**
+
+```js
+/./s
+```
+
+**Out**
+
+```js
+/[\0-\uFFFF]/
+```
+
+**In**
+
+```js
+/./su
+```
+
+**Out**
+
+```js
+/[\0-\u{10FFFF}]/u
+```
+
+[Here’s an online demo.](https://mothereff.in/regexpu#input=const+regex+%3D+/foo.bar/s%3B%0Aconsole.log%28%0A++regex.test%28%27foo%5Cnbar%27%29%0A%29%3B%0A//+%E2%86%92+true&dotAllFlag=1)
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-dotall-regex
+```
+
+## Usage
+
+### Via `.babelrc` (recommended)
+
+`.babelrc`
+
+```json
+{
+  "plugins": ["@babel/plugin-transform-dotall-regex"]
+}
+```
+
+### Via CLI
+
+```sh
+$ babel --plugins @babel/plugin-transform-dotall-regex script.js
+```
+
+### Via Node.js API
+
+```js
+require('@babel/core').transform(code, {
+  'plugins': ['@babel/plugin-transform-dotall-regex']
+});
+```
+
+## Author
+
+| [![twitter/mathias](https://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](https://twitter.com/mathias "Follow @mathias on Twitter") |
+|---|
+| [Mathias Bynens](https://mathiasbynens.be/) |
diff --git a/node_modules/@babel/plugin-transform-dotall-regex/lib/index.js b/node_modules/@babel/plugin-transform-dotall-regex/lib/index.js
new file mode 100644
index 00000000..707d77ec
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-dotall-regex/lib/index.js
@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _regexpuCore() {
+  const data = _interopRequireDefault(require("regexpu-core"));
+
+  _regexpuCore = function _regexpuCore() {
+    return data;
+  };
+
+  return data;
+}
+
+function regex() {
+  const data = _interopRequireWildcard(require("@babel/helper-regex"));
+
+  regex = function regex() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+  return {
+    visitor: {
+      RegExpLiteral(path) {
+        const node = path.node;
+
+        if (!regex().is(node, "s")) {
+          return;
+        }
+
+        node.pattern = (0, _regexpuCore().default)(node.pattern, node.flags, {
+          dotAllFlag: true,
+          useUnicodeFlag: regex().is(node, "u")
+        });
+        regex().pullFlag(node, "s");
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-dotall-regex/package.json b/node_modules/@babel/plugin-transform-dotall-regex/package.json
new file mode 100644
index 00000000..f8dced35
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-dotall-regex/package.json
@@ -0,0 +1,35 @@
+{
+  "name": "@babel/plugin-transform-dotall-regex",
+  "version": "7.0.0-beta.47",
+  "description": "Compile regular expressions using the `s` (`dotAll`) flag to ES5.",
+  "homepage": "https://babeljs.io/",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "engines": {
+    "node": ">=4"
+  },
+  "keywords": [
+    "babel-plugin",
+    "regex",
+    "regexp",
+    "regular expressions",
+    "dotall"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-dotall-regex.git"
+  },
+  "bugs": "https://github.com/babel/babel/issues",
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47",
+    "@babel/helper-regex": "7.0.0-beta.47",
+    "regexpu-core": "^4.1.3"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-dotall-regex/src/index.js b/node_modules/@babel/plugin-transform-dotall-regex/src/index.js
new file mode 100644
index 00000000..e1303cd9
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-dotall-regex/src/index.js
@@ -0,0 +1,23 @@
+import { declare } from "@babel/helper-plugin-utils";
+import rewritePattern from "regexpu-core";
+import * as regex from "@babel/helper-regex";
+
+export default declare(api => {
+  api.assertVersion(7);
+
+  return {
+    visitor: {
+      RegExpLiteral(path) {
+        const node = path.node;
+        if (!regex.is(node, "s")) {
+          return;
+        }
+        node.pattern = rewritePattern(node.pattern, node.flags, {
+          dotAllFlag: true,
+          useUnicodeFlag: regex.is(node, "u"),
+        });
+        regex.pullFlag(node, "s");
+      },
+    },
+  };
+});
diff --git a/node_modules/@babel/plugin-transform-dotall-regex/test/fixtures/dotall-regex/options.json b/node_modules/@babel/plugin-transform-dotall-regex/test/fixtures/dotall-regex/options.json
new file mode 100644
index 00000000..971351e1
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-dotall-regex/test/fixtures/dotall-regex/options.json
@@ -0,0 +1,3 @@
+{
+  "plugins": ["transform-dotall-regex"]
+}
diff --git a/node_modules/@babel/plugin-transform-dotall-regex/test/fixtures/dotall-regex/simple/input.js b/node_modules/@babel/plugin-transform-dotall-regex/test/fixtures/dotall-regex/simple/input.js
new file mode 100644
index 00000000..bf124396
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-dotall-regex/test/fixtures/dotall-regex/simple/input.js
@@ -0,0 +1,2 @@
+var a = /./;
+var b = /./s;
diff --git a/node_modules/@babel/plugin-transform-dotall-regex/test/fixtures/dotall-regex/simple/output.js b/node_modules/@babel/plugin-transform-dotall-regex/test/fixtures/dotall-regex/simple/output.js
new file mode 100644
index 00000000..dec34325
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-dotall-regex/test/fixtures/dotall-regex/simple/output.js
@@ -0,0 +1,2 @@
+var a = /./;
+var b = /[\0-\uFFFF]/;
diff --git a/node_modules/@babel/plugin-transform-dotall-regex/test/fixtures/dotall-regex/with-unicode-flag/input.js b/node_modules/@babel/plugin-transform-dotall-regex/test/fixtures/dotall-regex/with-unicode-flag/input.js
new file mode 100644
index 00000000..9ca7da3e
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-dotall-regex/test/fixtures/dotall-regex/with-unicode-flag/input.js
@@ -0,0 +1,2 @@
+var a = /./u;
+var b = /./su;
diff --git a/node_modules/@babel/plugin-transform-dotall-regex/test/fixtures/dotall-regex/with-unicode-flag/output.js b/node_modules/@babel/plugin-transform-dotall-regex/test/fixtures/dotall-regex/with-unicode-flag/output.js
new file mode 100644
index 00000000..bb1b222a
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-dotall-regex/test/fixtures/dotall-regex/with-unicode-flag/output.js
@@ -0,0 +1,2 @@
+var a = /./u;
+var b = /[\0-\u{10FFFF}]/u;
diff --git a/node_modules/@babel/plugin-transform-dotall-regex/test/index.js b/node_modules/@babel/plugin-transform-dotall-regex/test/index.js
new file mode 100644
index 00000000..8c71ab59
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-dotall-regex/test/index.js
@@ -0,0 +1,2 @@
+import runner from "@babel/helper-plugin-test-runner";
+runner(__dirname);
diff --git a/node_modules/@babel/plugin-transform-duplicate-keys/README.md b/node_modules/@babel/plugin-transform-duplicate-keys/README.md
new file mode 100644
index 00000000..a64bac73
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-duplicate-keys/README.md
@@ -0,0 +1,61 @@
+# @babel/plugin-transform-duplicate-keys
+
+> Compile objects with duplicate keys to valid strict ES5.
+
+This plugin actually converts duplicate keys in objects to be computed properties, which then must be handled by the [@babel/plugin-transform-computed-properties](http://babeljs.io/docs/plugins/transform-computed-properties) plugin. The final result won't contain any object literals with duplicate keys.
+
+## Example
+
+**In**
+
+```javascript
+var x = { a: 5, a: 6 };
+var y = {
+  get a() {},
+  set a(x) {},
+  a: 3
+};
+```
+
+**Out**
+
+```javascript
+var x = { a: 5, ["a"]: 6 };
+var y = {
+  get a() {},
+  set a(x) {},
+  ["a"]: 3
+};
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-duplicate-keys
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-transform-duplicate-keys"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-duplicate-keys script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-duplicate-keys"]
+});
+```
diff --git a/node_modules/@babel/plugin-transform-duplicate-keys/lib/index.js b/node_modules/@babel/plugin-transform-duplicate-keys/lib/index.js
new file mode 100644
index 00000000..a897df52
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-duplicate-keys/lib/index.js
@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+function getName(key) {
+  if (_core().types.isIdentifier(key)) {
+    return key.name;
+  }
+
+  return key.value.toString();
+}
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+  return {
+    visitor: {
+      ObjectExpression(path) {
+        const node = path.node;
+        const plainProps = node.properties.filter(prop => !_core().types.isSpreadElement(prop) && !prop.computed);
+        const alreadySeenData = Object.create(null);
+        const alreadySeenGetters = Object.create(null);
+        const alreadySeenSetters = Object.create(null);
+
+        for (var _iterator = plainProps, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+          var _ref;
+
+          if (_isArray) {
+            if (_i >= _iterator.length) break;
+            _ref = _iterator[_i++];
+          } else {
+            _i = _iterator.next();
+            if (_i.done) break;
+            _ref = _i.value;
+          }
+
+          const prop = _ref;
+          const name = getName(prop.key);
+          let isDuplicate = false;
+
+          switch (prop.kind) {
+            case "get":
+              if (alreadySeenData[name] || alreadySeenGetters[name]) {
+                isDuplicate = true;
+              }
+
+              alreadySeenGetters[name] = true;
+              break;
+
+            case "set":
+              if (alreadySeenData[name] || alreadySeenSetters[name]) {
+                isDuplicate = true;
+              }
+
+              alreadySeenSetters[name] = true;
+              break;
+
+            default:
+              if (alreadySeenData[name] || alreadySeenGetters[name] || alreadySeenSetters[name]) {
+                isDuplicate = true;
+              }
+
+              alreadySeenData[name] = true;
+          }
+
+          if (isDuplicate) {
+            prop.computed = true;
+            prop.key = _core().types.stringLiteral(name);
+          }
+        }
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-duplicate-keys/package.json b/node_modules/@babel/plugin-transform-duplicate-keys/package.json
new file mode 100644
index 00000000..1695961c
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-duplicate-keys/package.json
@@ -0,0 +1,21 @@
+{
+  "name": "@babel/plugin-transform-duplicate-keys",
+  "version": "7.0.0-beta.47",
+  "description": "Compile objects with duplicate keys to valid strict ES5",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-duplicate-keys",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-exponentiation-operator/README.md b/node_modules/@babel/plugin-transform-exponentiation-operator/README.md
new file mode 100644
index 00000000..92d1d3ca
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-exponentiation-operator/README.md
@@ -0,0 +1,58 @@
+# @babel/plugin-transform-exponentiation-operator
+
+> Compile exponentiation operator to ES5
+
+## Example
+
+**In**
+
+```javascript
+let x = 10 ** 2;
+
+x **= 3;
+```
+
+**Out**
+
+```javascript
+let x = Math.pow(10, 2);
+
+x = Math.pow(x, 3);
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-exponentiation-operator
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-transform-exponentiation-operator"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-exponentiation-operator script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-exponentiation-operator"]
+});
+```
+
+## References
+
+* [Proposal: Exponentiation Operator](https://github.com/rwaldron/exponentiation-operator)
+* [Spec: Exponential Operator](https://rwaldron.github.io/exponentiation-operator/)
diff --git a/node_modules/@babel/plugin-transform-exponentiation-operator/lib/index.js b/node_modules/@babel/plugin-transform-exponentiation-operator/lib/index.js
new file mode 100644
index 00000000..f899eeb9
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-exponentiation-operator/lib/index.js
@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperBuilderBinaryAssignmentOperatorVisitor() {
+  const data = _interopRequireDefault(require("@babel/helper-builder-binary-assignment-operator-visitor"));
+
+  _helperBuilderBinaryAssignmentOperatorVisitor = function _helperBuilderBinaryAssignmentOperatorVisitor() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+  return {
+    visitor: (0, _helperBuilderBinaryAssignmentOperatorVisitor().default)({
+      operator: "**",
+
+      build(left, right) {
+        return _core().types.callExpression(_core().types.memberExpression(_core().types.identifier("Math"), _core().types.identifier("pow")), [left, right]);
+      }
+
+    })
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-exponentiation-operator/package.json b/node_modules/@babel/plugin-transform-exponentiation-operator/package.json
new file mode 100644
index 00000000..c7eb943b
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-exponentiation-operator/package.json
@@ -0,0 +1,22 @@
+{
+  "name": "@babel/plugin-transform-exponentiation-operator",
+  "version": "7.0.0-beta.47",
+  "description": "Compile exponentiation operator to ES5",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-exponentiation-operator",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-builder-binary-assignment-operator-visitor": "7.0.0-beta.47",
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-for-of/README.md b/node_modules/@babel/plugin-transform-for-of/README.md
new file mode 100644
index 00000000..4a8c5263
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-for-of/README.md
@@ -0,0 +1,154 @@
+# @babel/plugin-transform-for-of
+
+> Compile ES2015 for...of to ES5
+
+## Example
+
+**In**
+
+```js
+for (var i of foo) {}
+```
+
+**Out**
+
+```js
+var _iteratorNormalCompletion = true;
+var _didIteratorError = false;
+var _iteratorError = undefined;
+
+try {
+  for (var _iterator = foo[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+    var i = _step.value;
+  }
+} catch (err) {
+  _didIteratorError = true;
+  _iteratorError = err;
+} finally {
+  try {
+    if (!_iteratorNormalCompletion && _iterator.return != null) {
+      _iterator.return();
+    }
+  } finally {
+    if (_didIteratorError) {
+      throw _iteratorError;
+    }
+  }
+}
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-for-of
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+Without options:
+
+```js
+{
+  "plugins": ["@babel/plugin-transform-for-of"]
+}
+```
+
+With options:
+
+```js
+{
+  "plugins": [
+    ["@babel/plugin-transform-for-of", {
+      "loose": true, // defaults to false
+      "assumeArray": true // defaults to false
+    }]
+  ]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-for-of script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-for-of"]
+});
+```
+
+## Options
+
+### `loose`
+
+`boolean`, defaults to `false`
+
+In loose mode, arrays are put in a fast path, thus heavily increasing performance.
+All other iterables will continue to work fine.
+
+#### Example
+
+**In**
+
+```js
+for (var i of foo) {}
+```
+
+**Out**
+
+```js
+for (var _iterator = foo, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+  var _ref;
+
+  if (_isArray) {
+    if (_i >= _iterator.length) break;
+    _ref = _iterator[_i++];
+  } else {
+    _i = _iterator.next();
+    if (_i.done) break;
+    _ref = _i.value;
+  }
+
+  var i = _ref;
+}
+```
+
+#### Abrupt completions
+
+In loose mode an iterator's `return` method will not be called on abrupt completions caused by thrown errors.
+
+Please see [google/traceur-compiler#1773](https://github.com/google/traceur-compiler/issues/1773) and
+[babel/babel#838](https://github.com/babel/babel/issues/838) for more information.
+
+### `assumeArray`
+`boolean`, defaults to `false`
+
+This will apply the optimization shown below to all for-of loops by assuming that _all_ loops are arrays.
+
+Can be useful when you just want a for-of loop to represent a basic for loop over an array.
+
+### Optimization
+
+If a basic array is used, Babel will compile the for-of loop down to a regular for loop.
+
+**In**
+
+```js
+for (let a of [1,2,3]) {}
+```
+
+**Out**
+
+```js
+var _arr = [1, 2, 3];
+for (var _i = 0; _i < _arr.length; _i++) {
+  var a = _arr[_i];
+}
+```
diff --git a/node_modules/@babel/plugin-transform-for-of/lib/index.js b/node_modules/@babel/plugin-transform-for-of/lib/index.js
new file mode 100644
index 00000000..cd3a4610
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-for-of/lib/index.js
@@ -0,0 +1,301 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = (0, _helperPluginUtils().declare)((api, options) => {
+  api.assertVersion(7);
+  const loose = options.loose,
+        assumeArray = options.assumeArray;
+
+  if (loose === true && assumeArray === true) {
+    throw new Error(`The loose and assumeArray options cannot be used together in @babel/plugin-transform-for-of`);
+  }
+
+  if (assumeArray) {
+    return {
+      visitor: {
+        ForOfStatement(path) {
+          const scope = path.scope;
+          const _path$node = path.node,
+                left = _path$node.left,
+                right = _path$node.right,
+                body = _path$node.body;
+          const i = scope.generateUidIdentifier("i");
+          let array = scope.maybeGenerateMemoised(right, true);
+          const inits = [_core().types.variableDeclarator(i, _core().types.numericLiteral(0))];
+
+          if (array) {
+            inits.push(_core().types.variableDeclarator(array, right));
+          } else {
+            array = right;
+          }
+
+          const item = _core().types.memberExpression(_core().types.cloneNode(array), _core().types.cloneNode(i), true);
+
+          let assignment;
+
+          if (_core().types.isVariableDeclaration(left)) {
+            assignment = left;
+            assignment.declarations[0].init = item;
+          } else {
+            assignment = _core().types.expressionStatement(_core().types.assignmentExpression("=", left, item));
+          }
+
+          const block = _core().types.toBlock(body);
+
+          block.body.unshift(assignment);
+          path.replaceWith(_core().types.forStatement(_core().types.variableDeclaration("let", inits), _core().types.binaryExpression("<", _core().types.cloneNode(i), _core().types.memberExpression(_core().types.cloneNode(array), _core().types.identifier("length"))), _core().types.updateExpression("++", _core().types.cloneNode(i)), block));
+        }
+
+      }
+    };
+  }
+
+  const pushComputedProps = loose ? pushComputedPropsLoose : pushComputedPropsSpec;
+  const buildForOfArray = (0, _core().template)(`
+    for (var KEY = 0; KEY < ARR.length; KEY++) BODY;
+  `);
+  const buildForOfLoose = (0, _core().template)(`
+    for (var LOOP_OBJECT = OBJECT,
+             IS_ARRAY = Array.isArray(LOOP_OBJECT),
+             INDEX = 0,
+             LOOP_OBJECT = IS_ARRAY ? LOOP_OBJECT : LOOP_OBJECT[Symbol.iterator]();;) {
+      INTERMEDIATE;
+      if (IS_ARRAY) {
+        if (INDEX >= LOOP_OBJECT.length) break;
+        ID = LOOP_OBJECT[INDEX++];
+      } else {
+        INDEX = LOOP_OBJECT.next();
+        if (INDEX.done) break;
+        ID = INDEX.value;
+      }
+    }
+  `);
+  const buildForOf = (0, _core().template)(`
+    var ITERATOR_COMPLETION = true;
+    var ITERATOR_HAD_ERROR_KEY = false;
+    var ITERATOR_ERROR_KEY = undefined;
+    try {
+      for (
+        var ITERATOR_KEY = OBJECT[Symbol.iterator](), STEP_KEY;
+        !(ITERATOR_COMPLETION = (STEP_KEY = ITERATOR_KEY.next()).done);
+        ITERATOR_COMPLETION = true
+      ) {}
+    } catch (err) {
+      ITERATOR_HAD_ERROR_KEY = true;
+      ITERATOR_ERROR_KEY = err;
+    } finally {
+      try {
+        if (!ITERATOR_COMPLETION && ITERATOR_KEY.return != null) {
+          ITERATOR_KEY.return();
+        }
+      } finally {
+        if (ITERATOR_HAD_ERROR_KEY) {
+          throw ITERATOR_ERROR_KEY;
+        }
+      }
+    }
+  `);
+
+  function _ForOfStatementArray(path) {
+    const node = path.node,
+          scope = path.scope;
+    const nodes = [];
+    let right = node.right;
+
+    if (!_core().types.isIdentifier(right) || !scope.hasBinding(right.name)) {
+      const uid = scope.generateUid("arr");
+      nodes.push(_core().types.variableDeclaration("var", [_core().types.variableDeclarator(_core().types.identifier(uid), right)]));
+      right = _core().types.identifier(uid);
+    }
+
+    const iterationKey = scope.generateUidIdentifier("i");
+    let loop = buildForOfArray({
+      BODY: node.body,
+      KEY: iterationKey,
+      ARR: right
+    });
+
+    _core().types.inherits(loop, node);
+
+    _core().types.ensureBlock(loop);
+
+    const iterationValue = _core().types.memberExpression(_core().types.cloneNode(right), _core().types.cloneNode(iterationKey), true);
+
+    const left = node.left;
+
+    if (_core().types.isVariableDeclaration(left)) {
+      left.declarations[0].init = iterationValue;
+      loop.body.body.unshift(left);
+    } else {
+      loop.body.body.unshift(_core().types.expressionStatement(_core().types.assignmentExpression("=", left, iterationValue)));
+    }
+
+    if (path.parentPath.isLabeledStatement()) {
+      loop = _core().types.labeledStatement(path.parentPath.node.label, loop);
+    }
+
+    nodes.push(loop);
+    return nodes;
+  }
+
+  function replaceWithArray(path) {
+    if (path.parentPath.isLabeledStatement()) {
+      path.parentPath.replaceWithMultiple(_ForOfStatementArray(path));
+    } else {
+      path.replaceWithMultiple(_ForOfStatementArray(path));
+    }
+  }
+
+  return {
+    visitor: {
+      ForOfStatement(path, state) {
+        const right = path.get("right");
+
+        if (right.isArrayExpression() || right.isGenericType("Array") || _core().types.isArrayTypeAnnotation(right.getTypeAnnotation())) {
+          replaceWithArray(path);
+          return;
+        }
+
+        const node = path.node;
+        const build = pushComputedProps(path, state);
+        const declar = build.declar;
+        const loop = build.loop;
+        const block = loop.body;
+        path.ensureBlock();
+
+        if (declar) {
+          block.body.push(declar);
+        }
+
+        block.body = block.body.concat(node.body.body);
+
+        _core().types.inherits(loop, node);
+
+        _core().types.inherits(loop.body, node.body);
+
+        if (build.replaceParent) {
+          path.parentPath.replaceWithMultiple(build.node);
+          path.remove();
+        } else {
+          path.replaceWithMultiple(build.node);
+        }
+      }
+
+    }
+  };
+
+  function pushComputedPropsLoose(path, file) {
+    const node = path.node,
+          scope = path.scope,
+          parent = path.parent;
+    const left = node.left;
+    let declar, id, intermediate;
+
+    if (_core().types.isIdentifier(left) || _core().types.isPattern(left) || _core().types.isMemberExpression(left)) {
+      id = left;
+      intermediate = null;
+    } else if (_core().types.isVariableDeclaration(left)) {
+      id = scope.generateUidIdentifier("ref");
+      declar = _core().types.variableDeclaration(left.kind, [_core().types.variableDeclarator(left.declarations[0].id, _core().types.identifier(id.name))]);
+      intermediate = _core().types.variableDeclaration("var", [_core().types.variableDeclarator(_core().types.identifier(id.name))]);
+    } else {
+      throw file.buildCodeFrameError(left, `Unknown node type ${left.type} in ForStatement`);
+    }
+
+    const iteratorKey = scope.generateUidIdentifier("iterator");
+    const isArrayKey = scope.generateUidIdentifier("isArray");
+    const loop = buildForOfLoose({
+      LOOP_OBJECT: iteratorKey,
+      IS_ARRAY: isArrayKey,
+      OBJECT: node.right,
+      INDEX: scope.generateUidIdentifier("i"),
+      ID: id,
+      INTERMEDIATE: intermediate
+    });
+
+    const isLabeledParent = _core().types.isLabeledStatement(parent);
+
+    let labeled;
+
+    if (isLabeledParent) {
+      labeled = _core().types.labeledStatement(parent.label, loop);
+    }
+
+    return {
+      replaceParent: isLabeledParent,
+      declar: declar,
+      node: labeled || loop,
+      loop: loop
+    };
+  }
+
+  function pushComputedPropsSpec(path, file) {
+    const node = path.node,
+          scope = path.scope,
+          parent = path.parent;
+    const left = node.left;
+    let declar;
+    const stepKey = scope.generateUid("step");
+
+    const stepValue = _core().types.memberExpression(_core().types.identifier(stepKey), _core().types.identifier("value"));
+
+    if (_core().types.isIdentifier(left) || _core().types.isPattern(left) || _core().types.isMemberExpression(left)) {
+      declar = _core().types.expressionStatement(_core().types.assignmentExpression("=", left, stepValue));
+    } else if (_core().types.isVariableDeclaration(left)) {
+      declar = _core().types.variableDeclaration(left.kind, [_core().types.variableDeclarator(left.declarations[0].id, stepValue)]);
+    } else {
+      throw file.buildCodeFrameError(left, `Unknown node type ${left.type} in ForStatement`);
+    }
+
+    const template = buildForOf({
+      ITERATOR_HAD_ERROR_KEY: scope.generateUidIdentifier("didIteratorError"),
+      ITERATOR_COMPLETION: scope.generateUidIdentifier("iteratorNormalCompletion"),
+      ITERATOR_ERROR_KEY: scope.generateUidIdentifier("iteratorError"),
+      ITERATOR_KEY: scope.generateUidIdentifier("iterator"),
+      STEP_KEY: _core().types.identifier(stepKey),
+      OBJECT: node.right
+    });
+
+    const isLabeledParent = _core().types.isLabeledStatement(parent);
+
+    const tryBody = template[3].block.body;
+    const loop = tryBody[0];
+
+    if (isLabeledParent) {
+      tryBody[0] = _core().types.labeledStatement(parent.label, loop);
+    }
+
+    return {
+      replaceParent: isLabeledParent,
+      declar: declar,
+      loop: loop,
+      node: template
+    };
+  }
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-for-of/package.json b/node_modules/@babel/plugin-transform-for-of/package.json
new file mode 100644
index 00000000..d078c9a0
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-for-of/package.json
@@ -0,0 +1,21 @@
+{
+  "name": "@babel/plugin-transform-for-of",
+  "version": "7.0.0-beta.47",
+  "description": "Compile ES2015 for...of to ES5",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-for-of",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-function-name/README.md b/node_modules/@babel/plugin-transform-function-name/README.md
new file mode 100644
index 00000000..71c63f72
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-function-name/README.md
@@ -0,0 +1,51 @@
+# @babel/plugin-transform-function-name
+
+> Apply ES2015 function.name semantics to all functions
+
+## Examples
+
+**In**
+
+```javascript
+let number = (x) => x
+```
+
+**Out**
+
+```javascript
+var number = function number(x) {
+  return x;
+};
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-function-name
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-transform-function-name"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-function-name script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-function-name"]
+});
+```
diff --git a/node_modules/@babel/plugin-transform-function-name/lib/index.js b/node_modules/@babel/plugin-transform-function-name/lib/index.js
new file mode 100644
index 00000000..b632d24d
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-function-name/lib/index.js
@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperFunctionName() {
+  const data = _interopRequireDefault(require("@babel/helper-function-name"));
+
+  _helperFunctionName = function _helperFunctionName() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+  return {
+    visitor: {
+      FunctionExpression: {
+        exit(path) {
+          if (path.key !== "value" && !path.parentPath.isObjectProperty()) {
+            const replacement = (0, _helperFunctionName().default)(path);
+            if (replacement) path.replaceWith(replacement);
+          }
+        }
+
+      },
+
+      ObjectProperty(path) {
+        const value = path.get("value");
+
+        if (value.isFunction()) {
+          const newNode = (0, _helperFunctionName().default)(value);
+          if (newNode) value.replaceWith(newNode);
+        }
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-function-name/package.json b/node_modules/@babel/plugin-transform-function-name/package.json
new file mode 100644
index 00000000..baa3524d
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-function-name/package.json
@@ -0,0 +1,22 @@
+{
+  "name": "@babel/plugin-transform-function-name",
+  "version": "7.0.0-beta.47",
+  "description": "Apply ES2015 function.name semantics to all functions",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-function-name",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-function-name": "7.0.0-beta.47",
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-literals/README.md b/node_modules/@babel/plugin-transform-literals/README.md
new file mode 100644
index 00000000..adc5c3ab
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-literals/README.md
@@ -0,0 +1,53 @@
+# @babel/plugin-transform-literals
+
+> Compile ES2015 unicode string and number literals to ES5
+
+## Example
+
+**In**
+
+```js
+var b = 0b11; // binary integer literal
+var o = 0o7; // octal integer literal
+const u = 'Hello\u{000A}\u{0009}!'; // unicode string literals, newline and tab
+```
+
+**Out**
+
+```js
+var b = 3; // binary integer literal
+var o = 7; // octal integer literal
+const u = 'Hello\n\t!'; // unicode string literals, newline and tab
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-literals
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-transform-literals"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-literals script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-literals"]
+});
+```
diff --git a/node_modules/@babel/plugin-transform-literals/lib/index.js b/node_modules/@babel/plugin-transform-literals/lib/index.js
new file mode 100644
index 00000000..5f42daa3
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-literals/lib/index.js
@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+  return {
+    visitor: {
+      NumericLiteral({
+        node
+      }) {
+        if (node.extra && /^0[ob]/i.test(node.extra.raw)) {
+          node.extra = undefined;
+        }
+      },
+
+      StringLiteral({
+        node
+      }) {
+        if (node.extra && /\\[u]/gi.test(node.extra.raw)) {
+          node.extra = undefined;
+        }
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-literals/package.json b/node_modules/@babel/plugin-transform-literals/package.json
new file mode 100644
index 00000000..79ade854
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-literals/package.json
@@ -0,0 +1,21 @@
+{
+  "name": "@babel/plugin-transform-literals",
+  "version": "7.0.0-beta.47",
+  "description": "Compile ES2015 unicode string and number literals to ES5",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-literals",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-modules-amd/README.md b/node_modules/@babel/plugin-transform-modules-amd/README.md
new file mode 100644
index 00000000..eecd35da
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-modules-amd/README.md
@@ -0,0 +1,61 @@
+# @babel/plugin-transform-modules-amd
+
+> This plugin transforms ES2015 modules to [Asynchronous Module Definition (AMD)](https://github.com/amdjs/amdjs-api).
+
+## Example
+
+**In**
+
+```javascript
+export default 42;
+```
+
+**Out**
+
+```javascript
+define(["exports"], function (exports) {
+  "use strict";
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+
+  exports.default = 42;
+});
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-modules-amd
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-transform-modules-amd"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-modules-amd script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-modules-amd"]
+});
+```
+
+### Options
+
+See options for `@babel/plugin-transform-modules-commonjs`.
diff --git a/node_modules/@babel/plugin-transform-modules-amd/lib/index.js b/node_modules/@babel/plugin-transform-modules-amd/lib/index.js
new file mode 100644
index 00000000..1f1a61b0
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-modules-amd/lib/index.js
@@ -0,0 +1,130 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperModuleTransforms() {
+  const data = require("@babel/helper-module-transforms");
+
+  _helperModuleTransforms = function _helperModuleTransforms() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+const buildWrapper = (0, _core().template)(`
+  define(MODULE_NAME, AMD_ARGUMENTS, function(IMPORT_NAMES) {
+  })
+`);
+
+var _default = (0, _helperPluginUtils().declare)((api, options) => {
+  api.assertVersion(7);
+  const loose = options.loose,
+        allowTopLevelThis = options.allowTopLevelThis,
+        strict = options.strict,
+        strictMode = options.strictMode,
+        noInterop = options.noInterop;
+  return {
+    visitor: {
+      Program: {
+        exit(path) {
+          if (!(0, _helperModuleTransforms().isModule)(path)) return;
+          let moduleName = this.getModuleName();
+          if (moduleName) moduleName = _core().types.stringLiteral(moduleName);
+
+          const _rewriteModuleStateme = (0, _helperModuleTransforms().rewriteModuleStatementsAndPrepareHeader)(path, {
+            loose,
+            strict,
+            strictMode,
+            allowTopLevelThis,
+            noInterop
+          }),
+                meta = _rewriteModuleStateme.meta,
+                headers = _rewriteModuleStateme.headers;
+
+          const amdArgs = [];
+          const importNames = [];
+
+          if ((0, _helperModuleTransforms().hasExports)(meta)) {
+            amdArgs.push(_core().types.stringLiteral("exports"));
+            importNames.push(_core().types.identifier(meta.exportName));
+          }
+
+          for (var _iterator = meta.source, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+            var _ref;
+
+            if (_isArray) {
+              if (_i >= _iterator.length) break;
+              _ref = _iterator[_i++];
+            } else {
+              _i = _iterator.next();
+              if (_i.done) break;
+              _ref = _i.value;
+            }
+
+            const _ref2 = _ref,
+                  source = _ref2[0],
+                  metadata = _ref2[1];
+            amdArgs.push(_core().types.stringLiteral(source));
+            importNames.push(_core().types.identifier(metadata.name));
+
+            if (!(0, _helperModuleTransforms().isSideEffectImport)(metadata)) {
+              const interop = (0, _helperModuleTransforms().wrapInterop)(path, _core().types.identifier(metadata.name), metadata.interop);
+
+              if (interop) {
+                const header = _core().types.expressionStatement(_core().types.assignmentExpression("=", _core().types.identifier(metadata.name), interop));
+
+                header.loc = metadata.loc;
+                headers.push(header);
+              }
+            }
+
+            headers.push(...(0, _helperModuleTransforms().buildNamespaceInitStatements)(meta, metadata, loose));
+          }
+
+          (0, _helperModuleTransforms().ensureStatementsHoisted)(headers);
+          path.unshiftContainer("body", headers);
+          const _path$node = path.node,
+                body = _path$node.body,
+                directives = _path$node.directives;
+          path.node.directives = [];
+          path.node.body = [];
+          const amdWrapper = path.pushContainer("body", [buildWrapper({
+            MODULE_NAME: moduleName,
+            AMD_ARGUMENTS: _core().types.arrayExpression(amdArgs),
+            IMPORT_NAMES: importNames
+          })])[0];
+          const amdFactory = amdWrapper.get("expression.arguments").filter(arg => arg.isFunctionExpression())[0].get("body");
+          amdFactory.pushContainer("directives", directives);
+          amdFactory.pushContainer("body", body);
+        }
+
+      }
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-modules-amd/package.json b/node_modules/@babel/plugin-transform-modules-amd/package.json
new file mode 100644
index 00000000..97a6bd92
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-modules-amd/package.json
@@ -0,0 +1,22 @@
+{
+  "name": "@babel/plugin-transform-modules-amd",
+  "version": "7.0.0-beta.47",
+  "description": "This plugin transforms ES2015 modules to AMD",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-modules-amd",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/helper-module-transforms": "7.0.0-beta.47",
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "keywords": [
+    "babel-plugin"
+  ],
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-modules-commonjs/README.md b/node_modules/@babel/plugin-transform-modules-commonjs/README.md
new file mode 100644
index 00000000..96c1a2b8
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-modules-commonjs/README.md
@@ -0,0 +1,163 @@
+# @babel/plugin-transform-modules-commonjs
+
+> This plugin transforms ES2015 modules to [CommonJS](http://wiki.commonjs.org/wiki/Modules/1.1).
+
+## Example
+
+**In**
+
+```javascript
+export default 42;
+```
+
+**Out**
+
+```javascript
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = 42;
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-modules-commonjs
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```js
+// without options
+{
+  "plugins": ["@babel/plugin-transform-modules-commonjs"]
+}
+
+// with options
+{
+  "plugins": [
+    ["@babel/plugin-transform-modules-commonjs", {
+      "allowTopLevelThis": true
+    }]
+  ]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-modules-commonjs script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-modules-commonjs"]
+});
+```
+
+## Options
+
+### `loose`
+
+`boolean`, defaults to `false`.
+
+By default, when using exports with babel a non-enumerable `__esModule` property
+is exported.
+
+```javascript
+var foo = exports.foo = 5;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+```
+
+In environments that don't support this you can enable loose mode on `@babel/plugin-transform-modules-commonjs`
+and instead of using `Object.defineProperty` an assignment will be used instead.
+
+```javascript
+var foo = exports.foo = 5;
+exports.__esModule = true;
+```
+
+### `strict`
+
+`boolean`, defaults to `false`
+
+By default, when using exports with babel a non-enumerable `__esModule` property
+is exported. In some cases this property is used to determine if the import _is_ the
+default export or if it _contains_ the default export.
+
+```javascript
+var foo = exports.foo = 5;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+```
+
+In order to prevent the `__esModule` property from being exported, you can set
+the `strict` option to `true`.
+
+### `noInterop`
+
+`boolean`, defaults to `false`
+
+By default, when using exports with babel a non-enumerable `__esModule` property
+is exported. This property is then used to determine if the import _is_ the default
+export or if it _contains_ the default export.
+
+```javascript
+"use strict";
+
+var _foo = _interopRequireDefault(require("foo"));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+```
+
+In cases where the auto-unwrapping of `default` is not needed, you can set the
+`noInterop` option to `true` to avoid the usage of the `interopRequireDefault`
+helper (shown in inline form above).
+
+### `lazy`
+
+`boolean`, `Array<string>`, or `(string) => boolean`, defaults to `false`
+
+Changes Babel's compiled `import` statements to be lazily evaluated when their
+imported bindings are used for the first time.
+
+This can improve initial load time of your module because evaluating
+dependencies up front is sometimes entirely un-necessary. This is especially
+the case when implementing a library module.
+
+The value of `lazy` has a few possible effects:
+
+* `false` - No lazy initialization of any imported module.
+* `true` - Do not lazy-initialize local `./foo` imports, but lazy-init `foo` dependencies.
+
+  Local paths are much more likely to have circular dependencies, which may break if loaded lazily,
+  so they are not lazy by default, whereas dependencies between independent modules are rarely cyclical.
+
+* `Array<string>` - Lazy-initialize all imports with source matching one of the given strings.
+* `(string) => boolean` - Pass a callback that will be called to decide if a given source string should be lazy-loaded.
+
+The two cases where imports can never be lazy are:
+
+* `import "foo";`
+
+  Side-effect imports are automatically non-lazy since their very existence means
+  that there is no binding to later kick off initialization.
+
+* `export * from "foo"`
+
+  Re-exporting all names requires up-front execution because otherwise there is no
+  way to know what names need to be exported.
diff --git a/node_modules/@babel/plugin-transform-modules-commonjs/lib/index.js b/node_modules/@babel/plugin-transform-modules-commonjs/lib/index.js
new file mode 100644
index 00000000..2d0d2258
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-modules-commonjs/lib/index.js
@@ -0,0 +1,222 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperModuleTransforms() {
+  const data = require("@babel/helper-module-transforms");
+
+  _helperModuleTransforms = function _helperModuleTransforms() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperSimpleAccess() {
+  const data = _interopRequireDefault(require("@babel/helper-simple-access"));
+
+  _helperSimpleAccess = function _helperSimpleAccess() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _helperPluginUtils().declare)((api, options) => {
+  api.assertVersion(7);
+  const loose = options.loose,
+        _options$strictNamesp = options.strictNamespace,
+        strictNamespace = _options$strictNamesp === void 0 ? false : _options$strictNamesp,
+        _options$mjsStrictNam = options.mjsStrictNamespace,
+        mjsStrictNamespace = _options$mjsStrictNam === void 0 ? true : _options$mjsStrictNam,
+        allowTopLevelThis = options.allowTopLevelThis,
+        strict = options.strict,
+        strictMode = options.strictMode,
+        noInterop = options.noInterop,
+        _options$lazy = options.lazy,
+        lazy = _options$lazy === void 0 ? false : _options$lazy,
+        _options$allowCommonJ = options.allowCommonJSExports,
+        allowCommonJSExports = _options$allowCommonJ === void 0 ? true : _options$allowCommonJ;
+
+  if (typeof lazy !== "boolean" && typeof lazy !== "function" && (!Array.isArray(lazy) || !lazy.every(item => typeof item === "string"))) {
+    throw new Error(`.lazy must be a boolean, array of strings, or a function`);
+  }
+
+  if (typeof strictNamespace !== "boolean") {
+    throw new Error(`.strictNamespace must be a boolean, or undefined`);
+  }
+
+  if (typeof mjsStrictNamespace !== "boolean") {
+    throw new Error(`.mjsStrictNamespace must be a boolean, or undefined`);
+  }
+
+  const getAssertion = localName => _core().template.expression.ast`
+    (function(){
+      throw new Error(
+        "The CommonJS '" + "${localName}" + "' variable is not available in ES6 modules." +
+        "Consider setting setting sourceType:script or sourceType:unambiguous in your " +
+        "Babel config for this file.");
+    })()
+  `;
+
+  const moduleExportsVisitor = {
+    ReferencedIdentifier(path) {
+      const localName = path.node.name;
+      if (localName !== "module" && localName !== "exports") return;
+      const localBinding = path.scope.getBinding(localName);
+      const rootBinding = this.scope.getBinding(localName);
+
+      if (rootBinding !== localBinding || path.parentPath.isObjectProperty({
+        value: path.node
+      }) && path.parentPath.parentPath.isObjectPattern() || path.parentPath.isAssignmentExpression({
+        left: path.node
+      }) || path.isAssignmentExpression({
+        left: path.node
+      })) {
+        return;
+      }
+
+      path.replaceWith(getAssertion(localName));
+    },
+
+    AssignmentExpression(path) {
+      const left = path.get("left");
+
+      if (left.isIdentifier()) {
+        const localName = path.node.name;
+        if (localName !== "module" && localName !== "exports") return;
+        const localBinding = path.scope.getBinding(localName);
+        const rootBinding = this.scope.getBinding(localName);
+        if (rootBinding !== localBinding) return;
+        const right = path.get("right");
+        right.replaceWith(_core().types.sequenceExpression([right.node, getAssertion(localName)]));
+      } else if (left.isPattern()) {
+        const ids = left.getOuterBindingIdentifiers();
+        const localName = Object.keys(ids).filter(localName => {
+          if (localName !== "module" && localName !== "exports") return false;
+          return this.scope.getBinding(localName) === path.scope.getBinding(localName);
+        })[0];
+
+        if (localName) {
+          const right = path.get("right");
+          right.replaceWith(_core().types.sequenceExpression([right.node, getAssertion(localName)]));
+        }
+      }
+    }
+
+  };
+  return {
+    visitor: {
+      Program: {
+        exit(path, state) {
+          if (!(0, _helperModuleTransforms().isModule)(path)) return;
+          path.scope.rename("exports");
+          path.scope.rename("module");
+          path.scope.rename("require");
+          path.scope.rename("__filename");
+          path.scope.rename("__dirname");
+
+          if (!allowCommonJSExports) {
+            (0, _helperSimpleAccess().default)(path, new Set(["module", "exports"]));
+            path.traverse(moduleExportsVisitor, {
+              scope: path.scope
+            });
+          }
+
+          let moduleName = this.getModuleName();
+          if (moduleName) moduleName = _core().types.stringLiteral(moduleName);
+
+          const _rewriteModuleStateme = (0, _helperModuleTransforms().rewriteModuleStatementsAndPrepareHeader)(path, {
+            exportName: "exports",
+            loose,
+            strict,
+            strictMode,
+            allowTopLevelThis,
+            noInterop,
+            lazy,
+            esNamespaceOnly: typeof state.filename === "string" && /\.mjs$/.test(state.filename) ? mjsStrictNamespace : strictNamespace
+          }),
+                meta = _rewriteModuleStateme.meta,
+                headers = _rewriteModuleStateme.headers;
+
+          for (var _iterator = meta.source, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+            var _ref;
+
+            if (_isArray) {
+              if (_i >= _iterator.length) break;
+              _ref = _iterator[_i++];
+            } else {
+              _i = _iterator.next();
+              if (_i.done) break;
+              _ref = _i.value;
+            }
+
+            const _ref2 = _ref,
+                  source = _ref2[0],
+                  metadata = _ref2[1];
+
+            const loadExpr = _core().types.callExpression(_core().types.identifier("require"), [_core().types.stringLiteral(source)]);
+
+            let header;
+
+            if ((0, _helperModuleTransforms().isSideEffectImport)(metadata)) {
+              if (metadata.lazy) throw new Error("Assertion failure");
+              header = _core().types.expressionStatement(loadExpr);
+            } else {
+              const init = (0, _helperModuleTransforms().wrapInterop)(path, loadExpr, metadata.interop) || loadExpr;
+
+              if (metadata.lazy) {
+                header = _core().template.ast`
+                  function ${metadata.name}() {
+                    const data = ${init};
+                    ${metadata.name} = function(){ return data; };
+                    return data;
+                  }
+                `;
+              } else {
+                header = _core().template.ast`
+                  var ${metadata.name} = ${init};
+                `;
+              }
+            }
+
+            header.loc = metadata.loc;
+            headers.push(header);
+            headers.push(...(0, _helperModuleTransforms().buildNamespaceInitStatements)(meta, metadata, loose));
+          }
+
+          (0, _helperModuleTransforms().ensureStatementsHoisted)(headers);
+          path.unshiftContainer("body", headers);
+        }
+
+      }
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-modules-commonjs/package.json b/node_modules/@babel/plugin-transform-modules-commonjs/package.json
new file mode 100644
index 00000000..c5ee6622
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-modules-commonjs/package.json
@@ -0,0 +1,24 @@
+{
+  "name": "@babel/plugin-transform-modules-commonjs",
+  "version": "7.0.0-beta.47",
+  "description": "This plugin transforms ES2015 modules to CommonJS",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-modules-commonjs",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/helper-module-transforms": "7.0.0-beta.47",
+    "@babel/helper-plugin-utils": "7.0.0-beta.47",
+    "@babel/helper-simple-access": "7.0.0-beta.47"
+  },
+  "keywords": [
+    "babel-plugin"
+  ],
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47",
+    "@babel/plugin-syntax-object-rest-spread": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-modules-systemjs/README.md b/node_modules/@babel/plugin-transform-modules-systemjs/README.md
new file mode 100644
index 00000000..23c27bd3
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-modules-systemjs/README.md
@@ -0,0 +1,73 @@
+# @babel/plugin-transform-modules-systemjs
+
+> This plugin transforms ES2015 modules to [SystemJS](https://github.com/systemjs/systemjs).
+
+## Example
+
+**In**
+
+```javascript
+export default 42;
+```
+
+**Out**
+
+```javascript
+System.register([], function (_export, _context) {
+  return {
+    setters: [],
+    execute: function () {
+      _export("default", 42);
+    }
+  };
+});
+```
+
+For dynamic import support (`import('./lazy.js').then(m => ...)`), enable the [@babel/plugin-syntax-dynamic-import](https://babeljs.io/docs/plugins/syntax-dynamic-import/) plugin before this one.
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-modules-systemjs
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+Without options:
+
+```json
+{
+  "plugins": ["@babel/plugin-transform-modules-systemjs"]
+}
+```
+
+With options:
+
+```json
+{
+  "plugins": [
+    ["@babel/plugin-transform-modules-systemjs", {
+      // outputs SystemJS.register(...)
+      "systemGlobal": "SystemJS"
+    }]
+  ]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-modules-systemjs script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-modules-systemjs"]
+});
+```
diff --git a/node_modules/@babel/plugin-transform-modules-systemjs/lib/index.js b/node_modules/@babel/plugin-transform-modules-systemjs/lib/index.js
new file mode 100644
index 00000000..d0fc70f6
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-modules-systemjs/lib/index.js
@@ -0,0 +1,412 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperHoistVariables() {
+  const data = _interopRequireDefault(require("@babel/helper-hoist-variables"));
+
+  _helperHoistVariables = function _helperHoistVariables() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const buildTemplate = (0, _core().template)(`
+  SYSTEM_REGISTER(MODULE_NAME, SOURCES, function (EXPORT_IDENTIFIER, CONTEXT_IDENTIFIER) {
+    "use strict";
+    BEFORE_BODY;
+    return {
+      setters: SETTERS,
+      execute: function () {
+        BODY;
+      }
+    };
+  });
+`);
+const buildExportAll = (0, _core().template)(`
+  for (var KEY in TARGET) {
+    if (KEY !== "default" && KEY !== "__esModule") EXPORT_OBJ[KEY] = TARGET[KEY];
+  }
+`);
+const TYPE_IMPORT = "Import";
+
+var _default = (0, _helperPluginUtils().declare)((api, options) => {
+  api.assertVersion(7);
+  const _options$systemGlobal = options.systemGlobal,
+        systemGlobal = _options$systemGlobal === void 0 ? "System" : _options$systemGlobal;
+  const IGNORE_REASSIGNMENT_SYMBOL = Symbol();
+  const reassignmentVisitor = {
+    "AssignmentExpression|UpdateExpression"(path) {
+      if (path.node[IGNORE_REASSIGNMENT_SYMBOL]) return;
+      path.node[IGNORE_REASSIGNMENT_SYMBOL] = true;
+      const arg = path.get(path.isAssignmentExpression() ? "left" : "argument");
+      if (!arg.isIdentifier()) return;
+      const name = arg.node.name;
+      if (this.scope.getBinding(name) !== path.scope.getBinding(name)) return;
+      const exportedNames = this.exports[name];
+      if (!exportedNames) return;
+      let node = path.node;
+      const isPostUpdateExpression = path.isUpdateExpression({
+        prefix: false
+      });
+
+      if (isPostUpdateExpression) {
+        node = _core().types.binaryExpression(node.operator[0], _core().types.unaryExpression("+", _core().types.cloneNode(node.argument)), _core().types.numericLiteral(1));
+      }
+
+      for (var _iterator = exportedNames, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+        var _ref;
+
+        if (_isArray) {
+          if (_i >= _iterator.length) break;
+          _ref = _iterator[_i++];
+        } else {
+          _i = _iterator.next();
+          if (_i.done) break;
+          _ref = _i.value;
+        }
+
+        const exportedName = _ref;
+        node = this.buildCall(exportedName, node).expression;
+      }
+
+      if (isPostUpdateExpression) {
+        node = _core().types.sequenceExpression([node, path.node]);
+      }
+
+      path.replaceWith(node);
+    }
+
+  };
+  return {
+    visitor: {
+      CallExpression(path, state) {
+        if (path.node.callee.type === TYPE_IMPORT) {
+          path.replaceWith(_core().types.callExpression(_core().types.memberExpression(_core().types.identifier(state.contextIdent), _core().types.identifier("import")), path.node.arguments));
+        }
+      },
+
+      ReferencedIdentifier(path, state) {
+        if (path.node.name == "__moduleName" && !path.scope.hasBinding("__moduleName")) {
+          path.replaceWith(_core().types.memberExpression(_core().types.identifier(state.contextIdent), _core().types.identifier("id")));
+        }
+      },
+
+      Program: {
+        enter(path, state) {
+          state.contextIdent = path.scope.generateUid("context");
+        },
+
+        exit(path, state) {
+          const exportIdent = path.scope.generateUid("export");
+          const contextIdent = state.contextIdent;
+          const exportNames = Object.create(null);
+          const modules = [];
+          let beforeBody = [];
+          const setters = [];
+          const sources = [];
+          const variableIds = [];
+          const removedPaths = [];
+
+          function addExportName(key, val) {
+            exportNames[key] = exportNames[key] || [];
+            exportNames[key].push(val);
+          }
+
+          function pushModule(source, key, specifiers) {
+            let module;
+            modules.forEach(function (m) {
+              if (m.key === source) {
+                module = m;
+              }
+            });
+
+            if (!module) {
+              modules.push(module = {
+                key: source,
+                imports: [],
+                exports: []
+              });
+            }
+
+            module[key] = module[key].concat(specifiers);
+          }
+
+          function buildExportCall(name, val) {
+            return _core().types.expressionStatement(_core().types.callExpression(_core().types.identifier(exportIdent), [_core().types.stringLiteral(name), val]));
+          }
+
+          const body = path.get("body");
+          let canHoist = true;
+
+          for (var _iterator2 = body, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+            var _ref2;
+
+            if (_isArray2) {
+              if (_i2 >= _iterator2.length) break;
+              _ref2 = _iterator2[_i2++];
+            } else {
+              _i2 = _iterator2.next();
+              if (_i2.done) break;
+              _ref2 = _i2.value;
+            }
+
+            let path = _ref2;
+            if (path.isExportDeclaration()) path = path.get("declaration");
+
+            if (path.isVariableDeclaration() && path.node.kind !== "var") {
+              canHoist = false;
+              break;
+            }
+          }
+
+          for (var _iterator3 = body, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
+            var _ref3;
+
+            if (_isArray3) {
+              if (_i3 >= _iterator3.length) break;
+              _ref3 = _iterator3[_i3++];
+            } else {
+              _i3 = _iterator3.next();
+              if (_i3.done) break;
+              _ref3 = _i3.value;
+            }
+
+            const path = _ref3;
+
+            if (canHoist && path.isFunctionDeclaration()) {
+              beforeBody.push(path.node);
+              removedPaths.push(path);
+            } else if (path.isImportDeclaration()) {
+              const source = path.node.source.value;
+              pushModule(source, "imports", path.node.specifiers);
+
+              for (const name in path.getBindingIdentifiers()) {
+                path.scope.removeBinding(name);
+                variableIds.push(_core().types.identifier(name));
+              }
+
+              path.remove();
+            } else if (path.isExportAllDeclaration()) {
+              pushModule(path.node.source.value, "exports", path.node);
+              path.remove();
+            } else if (path.isExportDefaultDeclaration()) {
+              const declar = path.get("declaration");
+
+              if (declar.isClassDeclaration() || declar.isFunctionDeclaration()) {
+                const id = declar.node.id;
+                const nodes = [];
+
+                if (id) {
+                  nodes.push(declar.node);
+                  nodes.push(buildExportCall("default", _core().types.cloneNode(id)));
+                  addExportName(id.name, "default");
+                } else {
+                  nodes.push(buildExportCall("default", _core().types.toExpression(declar.node)));
+                }
+
+                if (!canHoist || declar.isClassDeclaration()) {
+                  path.replaceWithMultiple(nodes);
+                } else {
+                  beforeBody = beforeBody.concat(nodes);
+                  removedPaths.push(path);
+                }
+              } else {
+                path.replaceWith(buildExportCall("default", declar.node));
+              }
+            } else if (path.isExportNamedDeclaration()) {
+              const declar = path.get("declaration");
+
+              if (declar.node) {
+                path.replaceWith(declar);
+                const nodes = [];
+                let bindingIdentifiers;
+
+                if (path.isFunction()) {
+                  const node = declar.node;
+                  const name = node.id.name;
+
+                  if (canHoist) {
+                    addExportName(name, name);
+                    beforeBody.push(node);
+                    beforeBody.push(buildExportCall(name, _core().types.cloneNode(node.id)));
+                    removedPaths.push(path);
+                  } else {
+                    bindingIdentifiers = {
+                      [name]: node.id
+                    };
+                  }
+                } else {
+                  bindingIdentifiers = declar.getBindingIdentifiers();
+                }
+
+                for (const name in bindingIdentifiers) {
+                  addExportName(name, name);
+                  nodes.push(buildExportCall(name, _core().types.identifier(name)));
+                }
+
+                path.insertAfter(nodes);
+              } else {
+                const specifiers = path.node.specifiers;
+
+                if (specifiers && specifiers.length) {
+                  if (path.node.source) {
+                    pushModule(path.node.source.value, "exports", specifiers);
+                    path.remove();
+                  } else {
+                    const nodes = [];
+
+                    for (var _iterator6 = specifiers, _isArray6 = Array.isArray(_iterator6), _i7 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) {
+                      var _ref6;
+
+                      if (_isArray6) {
+                        if (_i7 >= _iterator6.length) break;
+                        _ref6 = _iterator6[_i7++];
+                      } else {
+                        _i7 = _iterator6.next();
+                        if (_i7.done) break;
+                        _ref6 = _i7.value;
+                      }
+
+                      const specifier = _ref6;
+                      nodes.push(buildExportCall(specifier.exported.name, specifier.local));
+                      addExportName(specifier.local.name, specifier.exported.name);
+                    }
+
+                    path.replaceWithMultiple(nodes);
+                  }
+                }
+              }
+            }
+          }
+
+          modules.forEach(function (specifiers) {
+            const setterBody = [];
+            const target = path.scope.generateUid(specifiers.key);
+
+            for (var _iterator4 = specifiers.imports, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
+              var _ref4;
+
+              if (_isArray4) {
+                if (_i4 >= _iterator4.length) break;
+                _ref4 = _iterator4[_i4++];
+              } else {
+                _i4 = _iterator4.next();
+                if (_i4.done) break;
+                _ref4 = _i4.value;
+              }
+
+              let specifier = _ref4;
+
+              if (_core().types.isImportNamespaceSpecifier(specifier)) {
+                setterBody.push(_core().types.expressionStatement(_core().types.assignmentExpression("=", specifier.local, _core().types.identifier(target))));
+              } else if (_core().types.isImportDefaultSpecifier(specifier)) {
+                specifier = _core().types.importSpecifier(specifier.local, _core().types.identifier("default"));
+              }
+
+              if (_core().types.isImportSpecifier(specifier)) {
+                setterBody.push(_core().types.expressionStatement(_core().types.assignmentExpression("=", specifier.local, _core().types.memberExpression(_core().types.identifier(target), specifier.imported))));
+              }
+            }
+
+            if (specifiers.exports.length) {
+              const exportObj = path.scope.generateUid("exportObj");
+              setterBody.push(_core().types.variableDeclaration("var", [_core().types.variableDeclarator(_core().types.identifier(exportObj), _core().types.objectExpression([]))]));
+
+              for (var _iterator5 = specifiers.exports, _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) {
+                var _ref5;
+
+                if (_isArray5) {
+                  if (_i5 >= _iterator5.length) break;
+                  _ref5 = _iterator5[_i5++];
+                } else {
+                  _i5 = _iterator5.next();
+                  if (_i5.done) break;
+                  _ref5 = _i5.value;
+                }
+
+                const node = _ref5;
+
+                if (_core().types.isExportAllDeclaration(node)) {
+                  setterBody.push(buildExportAll({
+                    KEY: path.scope.generateUidIdentifier("key"),
+                    EXPORT_OBJ: _core().types.identifier(exportObj),
+                    TARGET: _core().types.identifier(target)
+                  }));
+                } else if (_core().types.isExportSpecifier(node)) {
+                  setterBody.push(_core().types.expressionStatement(_core().types.assignmentExpression("=", _core().types.memberExpression(_core().types.identifier(exportObj), node.exported), _core().types.memberExpression(_core().types.identifier(target), node.local))));
+                } else {}
+              }
+
+              setterBody.push(_core().types.expressionStatement(_core().types.callExpression(_core().types.identifier(exportIdent), [_core().types.identifier(exportObj)])));
+            }
+
+            sources.push(_core().types.stringLiteral(specifiers.key));
+            setters.push(_core().types.functionExpression(null, [_core().types.identifier(target)], _core().types.blockStatement(setterBody)));
+          });
+          let moduleName = this.getModuleName();
+          if (moduleName) moduleName = _core().types.stringLiteral(moduleName);
+
+          if (canHoist) {
+            (0, _helperHoistVariables().default)(path, id => variableIds.push(id));
+          }
+
+          if (variableIds.length) {
+            beforeBody.unshift(_core().types.variableDeclaration("var", variableIds.map(id => _core().types.variableDeclarator(id))));
+          }
+
+          path.traverse(reassignmentVisitor, {
+            exports: exportNames,
+            buildCall: buildExportCall,
+            scope: path.scope
+          });
+
+          for (var _i6 = 0; _i6 < removedPaths.length; _i6++) {
+            const path = removedPaths[_i6];
+            path.remove();
+          }
+
+          path.node.body = [buildTemplate({
+            SYSTEM_REGISTER: _core().types.memberExpression(_core().types.identifier(systemGlobal), _core().types.identifier("register")),
+            BEFORE_BODY: beforeBody,
+            MODULE_NAME: moduleName,
+            SETTERS: _core().types.arrayExpression(setters),
+            SOURCES: _core().types.arrayExpression(sources),
+            BODY: path.node.body,
+            EXPORT_IDENTIFIER: _core().types.identifier(exportIdent),
+            CONTEXT_IDENTIFIER: _core().types.identifier(contextIdent)
+          })];
+        }
+
+      }
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-modules-systemjs/package.json b/node_modules/@babel/plugin-transform-modules-systemjs/package.json
new file mode 100644
index 00000000..08f77cc9
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-modules-systemjs/package.json
@@ -0,0 +1,23 @@
+{
+  "name": "@babel/plugin-transform-modules-systemjs",
+  "version": "7.0.0-beta.47",
+  "description": "This plugin transforms ES2015 modules to SystemJS",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-modules-systemjs",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/helper-hoist-variables": "7.0.0-beta.47",
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "keywords": [
+    "babel-plugin"
+  ],
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47",
+    "@babel/plugin-syntax-dynamic-import": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-modules-umd/README.md b/node_modules/@babel/plugin-transform-modules-umd/README.md
new file mode 100644
index 00000000..a8a919ad
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-modules-umd/README.md
@@ -0,0 +1,214 @@
+# @babel/plugin-transform-modules-umd
+
+> This plugin transforms ES2015 modules to [Universal Module Definition (UMD)](https://github.com/umdjs/umd).
+
+## Example
+
+**In**
+
+```javascript
+export default 42;
+```
+
+**Out**
+
+```javascript
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports);
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports);
+    global.actual = mod.exports;
+  }
+})(this, function (exports) {
+  "use strict";
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+
+  exports.default = 42;
+});
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-modules-umd
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-transform-modules-umd"]
+}
+```
+
+You can also override the names of particular libraries when this module is
+running in the browser.  For example the `es6-promise` library exposes itself
+as `global.Promise` rather than `global.es6Promise`. This can be accommodated by:
+
+```json
+{
+  "plugins": [
+    ["@babel/plugin-transform-modules-umd", {
+      "globals": {
+        "es6-promise": "Promise"
+      }
+    }]
+  ]
+}
+```
+
+#### Default semantics
+
+There are a few things to note about the default semantics.
+
+_First_, this transform uses the
+[basename](https://en.wikipedia.org/wiki/Basename) of each import to generate
+the global names in the UMD output. This means that if you're importing
+multiple modules with the same basename, like:
+
+```js
+import fooBar1 from "foo-bar";
+import fooBar2 from "./mylib/foo-bar";
+```
+
+it will transpile into two references to the same browser global:
+
+```js
+factory(global.fooBar, global.fooBar);
+```
+
+If you set the plugin options to:
+
+```json
+{
+  "globals": {
+    "foo-bar": "fooBAR",
+    "./mylib/foo-bar": "mylib.fooBar"
+  }
+}
+```
+
+it will still transpile both to one browser global:
+
+```js
+factory(global.fooBAR, global.fooBAR);
+```
+
+because again the transform is only using the basename of the import.
+
+_Second_, the specified override will still be passed to the `toIdentifier`
+function in [babel-types/src/converters](https://github.com/babel/babel/blob/master/packages/babel-types/src/converters.js).
+This means that if you specify an override as a member expression like:
+
+```json
+{
+  "globals": {
+    "fizzbuzz": "fizz.buzz"
+  }
+}
+```
+
+this will _not_ transpile to `factory(global.fizz.buzz)`. Instead, it will
+transpile to `factory(global.fizzBuzz)` based on the logic in `toIdentifier`.
+
+_Third_, you cannot override the exported global name.
+
+#### More flexible semantics with `exactGlobals: true`
+
+All of these behaviors can limit the flexibility of the `globals` map. To
+remove these limitations, you can set the `exactGlobals` option to `true`.
+Doing this instructs the plugin to:
+
+1. always use the full import string instead of the basename when generating
+the global names
+2. skip passing `globals` overrides to the `toIdentifier` function. Instead,
+they are used exactly as written, so you will get errors if you do not use
+valid identifiers or valid uncomputed (dot) member expressions.
+3. allow the exported global name to be overridden via the `globals` map. Any
+override must again be a valid identifier or valid member expression.
+
+Thus, if you set `exactGlobals` to `true` and do not pass any overrides, the
+first example of:
+
+```js
+import fooBar1 from "foo-bar";
+import fooBar2 from "./mylib/foo-bar";
+```
+
+will transpile to:
+
+```js
+factory(global.fooBar, global.mylibFooBar);
+```
+
+And if you set the plugin options to:
+
+```json
+{
+  "globals": {
+    "foo-bar": "fooBAR",
+    "./mylib/foo-bar": "mylib.fooBar"
+  },
+  "exactGlobals": true
+}
+```
+
+then it'll transpile to:
+
+```js
+factory(global.fooBAR, global.mylib.fooBar)
+```
+
+Finally, with the plugin options set to:
+
+```json
+{
+  "plugins": [
+    "@babel/plugin-external-helpers",
+    ["@babel/plugin-transform-modules-umd", {
+      "globals": {
+        "my/custom/module/name": "My.Custom.Module.Name"
+      },
+      "exactGlobals": true
+    }]
+  ],
+  "moduleId": "my/custom/module/name"
+}
+```
+
+it will transpile to:
+
+```js
+factory(mod.exports);
+global.My = global.My || {};
+global.My.Custom = global.My.Custom || {};
+global.My.Custom.Module = global.My.Custom.Module || {};
+global.My.Custom.Module.Name = mod.exports;
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-modules-umd script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-modules-umd"]
+});
+```
diff --git a/node_modules/@babel/plugin-transform-modules-umd/lib/index.js b/node_modules/@babel/plugin-transform-modules-umd/lib/index.js
new file mode 100644
index 00000000..7da15b1f
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-modules-umd/lib/index.js
@@ -0,0 +1,213 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _path() {
+  const data = require("path");
+
+  _path = function _path() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperModuleTransforms() {
+  const data = require("@babel/helper-module-transforms");
+
+  _helperModuleTransforms = function _helperModuleTransforms() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+const buildPrerequisiteAssignment = (0, _core().template)(`
+  GLOBAL_REFERENCE = GLOBAL_REFERENCE || {}
+`);
+const buildWrapper = (0, _core().template)(`
+  (function (global, factory) {
+    if (typeof define === "function" && define.amd) {
+      define(MODULE_NAME, AMD_ARGUMENTS, factory);
+    } else if (typeof exports !== "undefined") {
+      factory(COMMONJS_ARGUMENTS);
+    } else {
+      var mod = { exports: {} };
+      factory(BROWSER_ARGUMENTS);
+
+      GLOBAL_TO_ASSIGN;
+    }
+  })(this, function(IMPORT_NAMES) {
+  })
+`);
+
+var _default = (0, _helperPluginUtils().declare)((api, options) => {
+  api.assertVersion(7);
+  const globals = options.globals,
+        exactGlobals = options.exactGlobals,
+        loose = options.loose,
+        allowTopLevelThis = options.allowTopLevelThis,
+        strict = options.strict,
+        strictMode = options.strictMode,
+        noInterop = options.noInterop;
+
+  function buildBrowserInit(browserGlobals, exactGlobals, filename, moduleName) {
+    const moduleNameOrBasename = moduleName ? moduleName.value : (0, _path().basename)(filename, (0, _path().extname)(filename));
+
+    let globalToAssign = _core().types.memberExpression(_core().types.identifier("global"), _core().types.identifier(_core().types.toIdentifier(moduleNameOrBasename)));
+
+    let initAssignments = [];
+
+    if (exactGlobals) {
+      const globalName = browserGlobals[moduleNameOrBasename];
+
+      if (globalName) {
+        initAssignments = [];
+        const members = globalName.split(".");
+        globalToAssign = members.slice(1).reduce((accum, curr) => {
+          initAssignments.push(buildPrerequisiteAssignment({
+            GLOBAL_REFERENCE: _core().types.cloneNode(accum)
+          }));
+          return _core().types.memberExpression(accum, _core().types.identifier(curr));
+        }, _core().types.memberExpression(_core().types.identifier("global"), _core().types.identifier(members[0])));
+      }
+    }
+
+    initAssignments.push(_core().types.expressionStatement(_core().types.assignmentExpression("=", globalToAssign, _core().types.memberExpression(_core().types.identifier("mod"), _core().types.identifier("exports")))));
+    return initAssignments;
+  }
+
+  function buildBrowserArg(browserGlobals, exactGlobals, source) {
+    let memberExpression;
+
+    if (exactGlobals) {
+      const globalRef = browserGlobals[source];
+
+      if (globalRef) {
+        memberExpression = globalRef.split(".").reduce((accum, curr) => _core().types.memberExpression(accum, _core().types.identifier(curr)), _core().types.identifier("global"));
+      } else {
+        memberExpression = _core().types.memberExpression(_core().types.identifier("global"), _core().types.identifier(_core().types.toIdentifier(source)));
+      }
+    } else {
+      const requireName = (0, _path().basename)(source, (0, _path().extname)(source));
+      const globalName = browserGlobals[requireName] || requireName;
+      memberExpression = _core().types.memberExpression(_core().types.identifier("global"), _core().types.identifier(_core().types.toIdentifier(globalName)));
+    }
+
+    return memberExpression;
+  }
+
+  return {
+    visitor: {
+      Program: {
+        exit(path) {
+          if (!(0, _helperModuleTransforms().isModule)(path)) return;
+          const browserGlobals = globals || {};
+          let moduleName = this.getModuleName();
+          if (moduleName) moduleName = _core().types.stringLiteral(moduleName);
+
+          const _rewriteModuleStateme = (0, _helperModuleTransforms().rewriteModuleStatementsAndPrepareHeader)(path, {
+            loose,
+            strict,
+            strictMode,
+            allowTopLevelThis,
+            noInterop
+          }),
+                meta = _rewriteModuleStateme.meta,
+                headers = _rewriteModuleStateme.headers;
+
+          const amdArgs = [];
+          const commonjsArgs = [];
+          const browserArgs = [];
+          const importNames = [];
+
+          if ((0, _helperModuleTransforms().hasExports)(meta)) {
+            amdArgs.push(_core().types.stringLiteral("exports"));
+            commonjsArgs.push(_core().types.identifier("exports"));
+            browserArgs.push(_core().types.memberExpression(_core().types.identifier("mod"), _core().types.identifier("exports")));
+            importNames.push(_core().types.identifier(meta.exportName));
+          }
+
+          for (var _iterator = meta.source, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+            var _ref;
+
+            if (_isArray) {
+              if (_i >= _iterator.length) break;
+              _ref = _iterator[_i++];
+            } else {
+              _i = _iterator.next();
+              if (_i.done) break;
+              _ref = _i.value;
+            }
+
+            const _ref2 = _ref,
+                  source = _ref2[0],
+                  metadata = _ref2[1];
+            amdArgs.push(_core().types.stringLiteral(source));
+            commonjsArgs.push(_core().types.callExpression(_core().types.identifier("require"), [_core().types.stringLiteral(source)]));
+            browserArgs.push(buildBrowserArg(browserGlobals, exactGlobals, source));
+            importNames.push(_core().types.identifier(metadata.name));
+
+            if (!(0, _helperModuleTransforms().isSideEffectImport)(metadata)) {
+              const interop = (0, _helperModuleTransforms().wrapInterop)(path, _core().types.identifier(metadata.name), metadata.interop);
+
+              if (interop) {
+                const header = _core().types.expressionStatement(_core().types.assignmentExpression("=", _core().types.identifier(metadata.name), interop));
+
+                header.loc = meta.loc;
+                headers.push(header);
+              }
+            }
+
+            headers.push(...(0, _helperModuleTransforms().buildNamespaceInitStatements)(meta, metadata, loose));
+          }
+
+          (0, _helperModuleTransforms().ensureStatementsHoisted)(headers);
+          path.unshiftContainer("body", headers);
+          const _path$node = path.node,
+                body = _path$node.body,
+                directives = _path$node.directives;
+          path.node.directives = [];
+          path.node.body = [];
+          const umdWrapper = path.pushContainer("body", [buildWrapper({
+            MODULE_NAME: moduleName,
+            AMD_ARGUMENTS: _core().types.arrayExpression(amdArgs),
+            COMMONJS_ARGUMENTS: commonjsArgs,
+            BROWSER_ARGUMENTS: browserArgs,
+            IMPORT_NAMES: importNames,
+            GLOBAL_TO_ASSIGN: buildBrowserInit(browserGlobals, exactGlobals, this.filename || "unknown", moduleName)
+          })])[0];
+          const umdFactory = umdWrapper.get("expression.arguments")[1].get("body");
+          umdFactory.pushContainer("directives", directives);
+          umdFactory.pushContainer("body", body);
+        }
+
+      }
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-modules-umd/package.json b/node_modules/@babel/plugin-transform-modules-umd/package.json
new file mode 100644
index 00000000..3e8a5cdf
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-modules-umd/package.json
@@ -0,0 +1,22 @@
+{
+  "name": "@babel/plugin-transform-modules-umd",
+  "version": "7.0.0-beta.47",
+  "description": "This plugin transforms ES2015 modules to UMD",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-modules-umd",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/helper-module-transforms": "7.0.0-beta.47",
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "keywords": [
+    "babel-plugin"
+  ],
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-new-target/README.md b/node_modules/@babel/plugin-transform-new-target/README.md
new file mode 100644
index 00000000..ccd5b4a4
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-new-target/README.md
@@ -0,0 +1,104 @@
+# @babel/plugin-transform-new-target
+
+This plugins allows babel to transform `new.target` meta property into a
+(correct in most cases) `this.constructor` expression.
+
+## Example
+
+```js
+function Foo() {
+  console.log(new.target);
+}
+
+Foo(); // => undefined
+new Foo(); // => Foo
+```
+
+```js
+class Foo {
+  constructor() {
+    console.log(new.target);
+  }
+}
+
+class Bar extends Foo {
+}
+
+new Foo(); // => Foo
+new Bar(); // => Bar
+```
+
+### Caveats
+
+This plugin relies on `this.constructor`, which means `super` must
+already have been called when using untransformed classes.
+
+```js
+class Foo {}
+
+class Bar extends Foo {
+  constructor() {
+    // This will be a problem if classes aren't transformed to ES5
+    new.target;
+    super();
+  }
+}
+```
+
+Additionally, this plugin cannot transform all `Reflect.construct` cases
+when using `newTarget` with ES5 function classes (transformed ES6 classes).
+
+```js
+function Foo() {
+  console.log(new.target);
+}
+
+// Bar extends Foo in ES5
+function Bar() {
+  Foo.call(this);
+}
+Bar.prototype = Object.create(Foo.prototype);
+Bar.prototype.constructor = Bar;
+
+// Baz does not extend Foo
+function Baz() {}
+
+Reflect.construct(Foo, []); // => Foo (correct)
+Reflect.construct(Foo, [], Bar); // => Bar (correct)
+
+Reflect.construct(Bar, []); // => Bar (incorrect, though this is how ES5
+                            // inheritience is commonly implemented.)
+Reflect.construct(Foo, [], Baz); // => undefined (incorrect)
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-new-target
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-transform-new-target"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-new-target script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-new-target"]
+});
+```
diff --git a/node_modules/@babel/plugin-transform-new-target/lib/index.js b/node_modules/@babel/plugin-transform-new-target/lib/index.js
new file mode 100644
index 00000000..c8491997
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-new-target/lib/index.js
@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+  return {
+    name: "transform-new-target",
+    visitor: {
+      MetaProperty(path) {
+        const meta = path.get("meta");
+        const property = path.get("property");
+        const scope = path.scope;
+
+        if (meta.isIdentifier({
+          name: "new"
+        }) && property.isIdentifier({
+          name: "target"
+        })) {
+          const func = path.findParent(path => {
+            if (path.isClass()) return true;
+
+            if (path.isFunction() && !path.isArrowFunctionExpression()) {
+              if (path.isClassMethod({
+                kind: "constructor"
+              })) {
+                return false;
+              }
+
+              return true;
+            }
+
+            return false;
+          });
+
+          if (!func) {
+            throw path.buildCodeFrameError("new.target must be under a (non-arrow) function or a class.");
+          }
+
+          const node = func.node;
+
+          if (!node.id) {
+            if (func.isMethod()) {
+              path.replaceWith(scope.buildUndefinedNode());
+              return;
+            }
+
+            node.id = scope.generateUidIdentifier("target");
+          }
+
+          const constructor = _core().types.memberExpression(_core().types.thisExpression(), _core().types.identifier("constructor"));
+
+          if (func.isClass()) {
+            path.replaceWith(constructor);
+            return;
+          }
+
+          path.replaceWith(_core().types.conditionalExpression(_core().types.binaryExpression("instanceof", _core().types.thisExpression(), _core().types.cloneNode(node.id)), constructor, scope.buildUndefinedNode()));
+        }
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-new-target/package.json b/node_modules/@babel/plugin-transform-new-target/package.json
new file mode 100644
index 00000000..b5cbf22d
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-new-target/package.json
@@ -0,0 +1,23 @@
+{
+  "name": "@babel/plugin-transform-new-target",
+  "version": "7.0.0-beta.47",
+  "description": "Transforms new.target meta property",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-new-target",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47",
+    "@babel/plugin-proposal-class-properties": "7.0.0-beta.47",
+    "@babel/plugin-transform-arrow-functions": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-object-super/README.md b/node_modules/@babel/plugin-transform-object-super/README.md
new file mode 100644
index 00000000..8fa757cf
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-object-super/README.md
@@ -0,0 +1,73 @@
+# @babel/plugin-transform-object-super
+
+> Compile ES2015 object super to ES5
+
+## Examples
+
+**In**
+
+```javascript
+let obj = {
+  say () {
+    return "Hello"
+  }
+}
+
+let obj2 = {
+  say () {
+    return super.say() + "World!"
+  }
+}
+```
+
+**Out**
+
+```javascript
+var _obj;
+
+var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
+
+var obj = {
+  say: function say() {
+    return "Hello";
+  }
+};
+
+var obj2 = _obj = {
+  say: function say() {
+    return _get(_obj.__proto__ || Object.getPrototypeOf(_obj), "say", this).call(this) + "World!";
+  }
+};
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-object-super
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-transform-object-super"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-object-super script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-object-super"]
+});
+```
diff --git a/node_modules/@babel/plugin-transform-object-super/lib/index.js b/node_modules/@babel/plugin-transform-object-super/lib/index.js
new file mode 100644
index 00000000..9ffe62cd
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-object-super/lib/index.js
@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperReplaceSupers() {
+  const data = _interopRequireDefault(require("@babel/helper-replace-supers"));
+
+  _helperReplaceSupers = function _helperReplaceSupers() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function replacePropertySuper(path, getObjectRef, file) {
+  const replaceSupers = new (_helperReplaceSupers().default)({
+    getObjectRef: getObjectRef,
+    methodPath: path,
+    file: file
+  });
+  replaceSupers.replace();
+}
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+  return {
+    visitor: {
+      ObjectExpression(path, state) {
+        let objectRef;
+
+        const getObjectRef = () => objectRef = objectRef || path.scope.generateUidIdentifier("obj");
+
+        path.get("properties").forEach(propPath => {
+          if (!propPath.isMethod()) return;
+          replacePropertySuper(propPath, getObjectRef, state);
+        });
+
+        if (objectRef) {
+          path.scope.push({
+            id: _core().types.cloneNode(objectRef)
+          });
+          path.replaceWith(_core().types.assignmentExpression("=", _core().types.cloneNode(objectRef), path.node));
+        }
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-object-super/package.json b/node_modules/@babel/plugin-transform-object-super/package.json
new file mode 100644
index 00000000..155c8284
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-object-super/package.json
@@ -0,0 +1,22 @@
+{
+  "name": "@babel/plugin-transform-object-super",
+  "version": "7.0.0-beta.47",
+  "description": "Compile ES2015 object super to ES5",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-object-super",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47",
+    "@babel/helper-replace-supers": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-parameters/README.md b/node_modules/@babel/plugin-transform-parameters/README.md
new file mode 100644
index 00000000..1c96bcee
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-parameters/README.md
@@ -0,0 +1,94 @@
+# @babel/plugin-transform-parameters
+
+> Compile ES2015 default and rest parameters to ES5
+
+This plugin transforms ES2015 parameters to ES5, this includes:
+
+- Destructuring parameters
+- Default parameters
+- Rest parameters
+
+## Examples
+
+**In**
+
+```javascript
+function test(x = "hello", { a, b }, ...args) {
+  console.log(x, a, b, args);
+}
+```
+
+**Out**
+
+```javascript
+function test() {
+  var x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "hello";
+  var _ref = arguments[1];
+  var a = _ref.a,
+      b = _ref.b;
+
+  for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+    args[_key - 2] = arguments[_key];
+  }
+
+  console.log(x, a, b, args);
+}
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-parameters
+```
+
+## Caveats
+
+Default parameters desugar into `let` declarations to retain proper semantics. If this is
+not supported in your environment then you'll need the
+[@babel/plugin-transform-block-scoping](http://babeljs.io/docs/plugins/transform-block-scoping) plugin.
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-transform-parameters"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-parameters script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-parameters"]
+});
+```
+
+## Options
+
+### `loose`
+
+`boolean`, defaults to `false`.
+
+In loose mode, parameters with default values will be counted into the arity of the function. This is not spec behavior where these parameters do not add to function arity.
+
+The `loose` implementation is a more performant solution as JavaScript engines will fully optimize a function that doesn't reference `arguments`. Please do your own benchmarking and determine if this option is the right fit for your application.
+
+```javascript
+// Spec behavior
+function bar1 (arg1 = 1) {}
+bar1.length // 0
+
+// Loose mode
+function bar1 (arg1 = 1) {}
+bar1.length // 1
+```
diff --git a/node_modules/@babel/plugin-transform-parameters/lib/index.js b/node_modules/@babel/plugin-transform-parameters/lib/index.js
new file mode 100644
index 00000000..9d21bad0
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-parameters/lib/index.js
@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+var _params = _interopRequireDefault(require("./params"));
+
+var _rest = _interopRequireDefault(require("./rest"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _helperPluginUtils().declare)((api, options) => {
+  api.assertVersion(7);
+  const loose = options.loose;
+  return {
+    visitor: {
+      Function(path) {
+        if (path.isArrowFunctionExpression() && path.get("params").some(param => param.isRestElement() || param.isAssignmentPattern())) {
+          path.arrowFunctionToExpression();
+        }
+
+        const convertedRest = (0, _rest.default)(path);
+        const convertedParams = (0, _params.default)(path, loose);
+
+        if (convertedRest || convertedParams) {
+          path.scope.crawl();
+        }
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-parameters/lib/params.js b/node_modules/@babel/plugin-transform-parameters/lib/params.js
new file mode 100644
index 00000000..3563e08e
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-parameters/lib/params.js
@@ -0,0 +1,163 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = convertFunctionParams;
+
+function _helperCallDelegate() {
+  const data = _interopRequireDefault(require("@babel/helper-call-delegate"));
+
+  _helperCallDelegate = function _helperCallDelegate() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const buildDefaultParam = (0, _core().template)(`
+  let VARIABLE_NAME =
+    arguments.length > ARGUMENT_KEY && arguments[ARGUMENT_KEY] !== undefined ?
+      arguments[ARGUMENT_KEY]
+    :
+      DEFAULT_VALUE;
+`);
+const buildLooseDefaultParam = (0, _core().template)(`
+  if (ASSIGNMENT_IDENTIFIER === UNDEFINED) {
+    ASSIGNMENT_IDENTIFIER = DEFAULT_VALUE;
+  }
+`);
+const buildLooseDestructuredDefaultParam = (0, _core().template)(`
+  let ASSIGNMENT_IDENTIFIER = PARAMETER_NAME === UNDEFINED ? DEFAULT_VALUE : PARAMETER_NAME ;
+`);
+const buildSafeArgumentsAccess = (0, _core().template)(`
+  let $0 = arguments.length > $1 ? arguments[$1] : undefined;
+`);
+
+function isSafeBinding(scope, node) {
+  if (!scope.hasOwnBinding(node.name)) return true;
+
+  const _scope$getOwnBinding = scope.getOwnBinding(node.name),
+        kind = _scope$getOwnBinding.kind;
+
+  return kind === "param" || kind === "local";
+}
+
+const iifeVisitor = {
+  ReferencedIdentifier(path, state) {
+    const scope = path.scope,
+          node = path.node;
+
+    if (node.name === "eval" || !isSafeBinding(scope, node)) {
+      state.iife = true;
+      path.stop();
+    }
+  },
+
+  Scope(path) {
+    path.skip();
+  }
+
+};
+
+function convertFunctionParams(path, loose) {
+  const node = path.node,
+        scope = path.scope;
+  const state = {
+    iife: false,
+    scope: scope
+  };
+  const body = [];
+  const params = path.get("params");
+  let firstOptionalIndex = null;
+
+  for (let i = 0; i < params.length; i++) {
+    const param = params[i];
+
+    if (param.isAssignmentPattern() && loose) {
+      const left = param.get("left");
+      const right = param.get("right");
+      const undefinedNode = scope.buildUndefinedNode();
+
+      if (left.isIdentifier()) {
+        body.push(buildLooseDefaultParam({
+          ASSIGNMENT_IDENTIFIER: _core().types.cloneNode(left.node),
+          DEFAULT_VALUE: right.node,
+          UNDEFINED: undefinedNode
+        }));
+        param.replaceWith(left.node);
+      } else if (left.isObjectPattern() || left.isArrayPattern()) {
+        const paramName = scope.generateUidIdentifier();
+        body.push(buildLooseDestructuredDefaultParam({
+          ASSIGNMENT_IDENTIFIER: left.node,
+          DEFAULT_VALUE: right.node,
+          PARAMETER_NAME: _core().types.cloneNode(paramName),
+          UNDEFINED: undefinedNode
+        }));
+        param.replaceWith(paramName);
+      }
+    } else if (param.isAssignmentPattern()) {
+      if (firstOptionalIndex === null) firstOptionalIndex = i;
+      const left = param.get("left");
+      const right = param.get("right");
+
+      if (!state.iife) {
+        if (right.isIdentifier() && !isSafeBinding(scope, right.node)) {
+          state.iife = true;
+        } else {
+          right.traverse(iifeVisitor, state);
+        }
+      }
+
+      const defNode = buildDefaultParam({
+        VARIABLE_NAME: left.node,
+        DEFAULT_VALUE: right.node,
+        ARGUMENT_KEY: _core().types.numericLiteral(i)
+      });
+      body.push(defNode);
+    } else if (firstOptionalIndex !== null) {
+      const defNode = buildSafeArgumentsAccess([param.node, _core().types.numericLiteral(i)]);
+      body.push(defNode);
+    } else if (param.isObjectPattern() || param.isArrayPattern()) {
+      const uid = path.scope.generateUidIdentifier("ref");
+
+      const defNode = _core().types.variableDeclaration("let", [_core().types.variableDeclarator(param.node, uid)]);
+
+      body.push(defNode);
+      param.replaceWith(_core().types.cloneNode(uid));
+    }
+
+    if (!state.iife && !param.isIdentifier()) {
+      param.traverse(iifeVisitor, state);
+    }
+  }
+
+  if (body.length === 0) return false;
+
+  if (firstOptionalIndex !== null) {
+    node.params = node.params.slice(0, firstOptionalIndex);
+  }
+
+  path.ensureBlock();
+
+  if (state.iife) {
+    body.push((0, _helperCallDelegate().default)(path, scope));
+    path.set("body", _core().types.blockStatement(body));
+  } else {
+    path.get("body").unshiftContainer("body", body);
+  }
+
+  return true;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-parameters/lib/rest.js b/node_modules/@babel/plugin-transform-parameters/lib/rest.js
new file mode 100644
index 00000000..82238e81
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-parameters/lib/rest.js
@@ -0,0 +1,286 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = convertFunctionRest;
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+const buildRest = (0, _core().template)(`
+  for (var LEN = ARGUMENTS.length,
+           ARRAY = new Array(ARRAY_LEN),
+           KEY = START;
+       KEY < LEN;
+       KEY++) {
+    ARRAY[ARRAY_KEY] = ARGUMENTS[KEY];
+  }
+`);
+const restIndex = (0, _core().template)(`
+  (INDEX < OFFSET || ARGUMENTS.length <= INDEX) ? undefined : ARGUMENTS[INDEX]
+`);
+const restIndexImpure = (0, _core().template)(`
+  REF = INDEX, (REF < OFFSET || ARGUMENTS.length <= REF) ? undefined : ARGUMENTS[REF]
+`);
+const restLength = (0, _core().template)(`
+  ARGUMENTS.length <= OFFSET ? 0 : ARGUMENTS.length - OFFSET
+`);
+
+function referencesRest(path, state) {
+  if (path.node.name === state.name) {
+    return path.scope.bindingIdentifierEquals(state.name, state.outerBinding);
+  }
+
+  return false;
+}
+
+const memberExpressionOptimisationVisitor = {
+  Scope(path, state) {
+    if (!path.scope.bindingIdentifierEquals(state.name, state.outerBinding)) {
+      path.skip();
+    }
+  },
+
+  Flow(path) {
+    if (path.isTypeCastExpression()) return;
+    path.skip();
+  },
+
+  Function(path, state) {
+    const oldNoOptimise = state.noOptimise;
+    state.noOptimise = true;
+    path.traverse(memberExpressionOptimisationVisitor, state);
+    state.noOptimise = oldNoOptimise;
+    path.skip();
+  },
+
+  ReferencedIdentifier(path, state) {
+    const node = path.node;
+
+    if (node.name === "arguments") {
+      state.deopted = true;
+    }
+
+    if (!referencesRest(path, state)) return;
+
+    if (state.noOptimise) {
+      state.deopted = true;
+    } else {
+      const parentPath = path.parentPath;
+
+      if (parentPath.listKey === "params" && parentPath.key < state.offset) {
+        return;
+      }
+
+      if (parentPath.isMemberExpression({
+        object: node
+      })) {
+        const grandparentPath = parentPath.parentPath;
+        const argsOptEligible = !state.deopted && !(grandparentPath.isAssignmentExpression() && parentPath.node === grandparentPath.node.left || grandparentPath.isLVal() || grandparentPath.isForXStatement() || grandparentPath.isUpdateExpression() || grandparentPath.isUnaryExpression({
+          operator: "delete"
+        }) || (grandparentPath.isCallExpression() || grandparentPath.isNewExpression()) && parentPath.node === grandparentPath.node.callee);
+
+        if (argsOptEligible) {
+          if (parentPath.node.computed) {
+            if (parentPath.get("property").isBaseType("number")) {
+              state.candidates.push({
+                cause: "indexGetter",
+                path
+              });
+              return;
+            }
+          } else if (parentPath.node.property.name === "length") {
+            state.candidates.push({
+              cause: "lengthGetter",
+              path
+            });
+            return;
+          }
+        }
+      }
+
+      if (state.offset === 0 && parentPath.isSpreadElement()) {
+        const call = parentPath.parentPath;
+
+        if (call.isCallExpression() && call.node.arguments.length === 1) {
+          state.candidates.push({
+            cause: "argSpread",
+            path
+          });
+          return;
+        }
+      }
+
+      state.references.push(path);
+    }
+  },
+
+  BindingIdentifier(path, state) {
+    if (referencesRest(path, state)) {
+      state.deopted = true;
+    }
+  }
+
+};
+
+function hasRest(node) {
+  const length = node.params.length;
+  return length > 0 && _core().types.isRestElement(node.params[length - 1]);
+}
+
+function optimiseIndexGetter(path, argsId, offset) {
+  const offsetLiteral = _core().types.numericLiteral(offset);
+
+  let index;
+
+  if (_core().types.isNumericLiteral(path.parent.property)) {
+    index = _core().types.numericLiteral(path.parent.property.value + offset);
+  } else if (offset === 0) {
+    index = path.parent.property;
+  } else {
+    index = _core().types.binaryExpression("+", path.parent.property, _core().types.cloneNode(offsetLiteral));
+  }
+
+  const scope = path.scope;
+
+  if (!scope.isPure(index)) {
+    const temp = scope.generateUidIdentifierBasedOnNode(index);
+    scope.push({
+      id: temp,
+      kind: "var"
+    });
+    path.parentPath.replaceWith(restIndexImpure({
+      ARGUMENTS: argsId,
+      OFFSET: offsetLiteral,
+      INDEX: index,
+      REF: _core().types.cloneNode(temp)
+    }));
+  } else {
+    const parentPath = path.parentPath;
+    parentPath.replaceWith(restIndex({
+      ARGUMENTS: argsId,
+      OFFSET: offsetLiteral,
+      INDEX: index
+    }));
+    const offsetTestPath = parentPath.get("test").get("left");
+    const valRes = offsetTestPath.evaluate();
+
+    if (valRes.confident) {
+      if (valRes.value === true) {
+        parentPath.replaceWith(parentPath.scope.buildUndefinedNode());
+      } else {
+        parentPath.get("test").replaceWith(parentPath.get("test").get("right"));
+      }
+    }
+  }
+}
+
+function optimiseLengthGetter(path, argsId, offset) {
+  if (offset) {
+    path.parentPath.replaceWith(restLength({
+      ARGUMENTS: argsId,
+      OFFSET: _core().types.numericLiteral(offset)
+    }));
+  } else {
+    path.replaceWith(argsId);
+  }
+}
+
+function convertFunctionRest(path) {
+  const node = path.node,
+        scope = path.scope;
+  if (!hasRest(node)) return false;
+  const rest = node.params.pop().argument;
+
+  const argsId = _core().types.identifier("arguments");
+
+  const state = {
+    references: [],
+    offset: node.params.length,
+    argumentsNode: argsId,
+    outerBinding: scope.getBindingIdentifier(rest.name),
+    candidates: [],
+    name: rest.name,
+    deopted: false
+  };
+  path.traverse(memberExpressionOptimisationVisitor, state);
+
+  if (!state.deopted && !state.references.length) {
+    var _arr = state.candidates;
+
+    for (var _i = 0; _i < _arr.length; _i++) {
+      const _ref = _arr[_i];
+      const path = _ref.path,
+            cause = _ref.cause;
+
+      const clonedArgsId = _core().types.cloneNode(argsId);
+
+      switch (cause) {
+        case "indexGetter":
+          optimiseIndexGetter(path, clonedArgsId, state.offset);
+          break;
+
+        case "lengthGetter":
+          optimiseLengthGetter(path, clonedArgsId, state.offset);
+          break;
+
+        default:
+          path.replaceWith(clonedArgsId);
+      }
+    }
+
+    return true;
+  }
+
+  state.references = state.references.concat(state.candidates.map(({
+    path
+  }) => path));
+
+  const start = _core().types.numericLiteral(node.params.length);
+
+  const key = scope.generateUidIdentifier("key");
+  const len = scope.generateUidIdentifier("len");
+  let arrKey, arrLen;
+
+  if (node.params.length) {
+    arrKey = _core().types.binaryExpression("-", _core().types.cloneNode(key), _core().types.cloneNode(start));
+    arrLen = _core().types.conditionalExpression(_core().types.binaryExpression(">", _core().types.cloneNode(len), _core().types.cloneNode(start)), _core().types.binaryExpression("-", _core().types.cloneNode(len), _core().types.cloneNode(start)), _core().types.numericLiteral(0));
+  } else {
+    arrKey = _core().types.identifier(key.name);
+    arrLen = _core().types.identifier(len.name);
+  }
+
+  const loop = buildRest({
+    ARGUMENTS: argsId,
+    ARRAY_KEY: arrKey,
+    ARRAY_LEN: arrLen,
+    START: start,
+    ARRAY: rest,
+    KEY: key,
+    LEN: len
+  });
+
+  if (state.deopted) {
+    node.body.body.unshift(loop);
+  } else {
+    let target = path.getEarliestCommonAncestorFrom(state.references).getStatementParent();
+    target.findParent(path => {
+      if (path.isLoop()) {
+        target = path;
+      } else {
+        return path.isFunction();
+      }
+    });
+    target.insertBefore(loop);
+  }
+
+  return true;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-parameters/package.json b/node_modules/@babel/plugin-transform-parameters/package.json
new file mode 100644
index 00000000..6d9e2881
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-parameters/package.json
@@ -0,0 +1,23 @@
+{
+  "name": "@babel/plugin-transform-parameters",
+  "version": "7.0.0-beta.47",
+  "description": "Compile ES2015 default and rest parameters to ES5",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-parameters",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/helper-call-delegate": "7.0.0-beta.47",
+    "@babel/helper-get-function-arity": "7.0.0-beta.47",
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "keywords": [
+    "babel-plugin"
+  ],
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-regenerator/README.md b/node_modules/@babel/plugin-transform-regenerator/README.md
new file mode 100644
index 00000000..47b192a9
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-regenerator/README.md
@@ -0,0 +1,87 @@
+# @babel/plugin-transform-regenerator
+
+> Transform async/generator functions with [regenerator](https://github.com/facebook/regenerator)
+
+## Example
+
+**In**
+
+```javascript
+function* a() {
+  yield 1;
+}
+```
+
+**Out**
+
+```javascript
+var _marked = [a].map(regeneratorRuntime.mark);
+
+function a() {
+  return regeneratorRuntime.wrap(function a$(_context) {
+    while (1) {
+      switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return 1;
+
+        case 2:
+        case "end":
+          return _context.stop();
+      }
+    }
+  }, _marked[0], this);
+}
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-regenerator
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+Without options:
+
+```json
+{
+  "plugins": ["@babel/plugin-transform-regenerator"]
+}
+```
+
+With options:
+
+|name|default value|
+|---|---|
+|asyncGenerators|true|
+|generators|true|
+|async|true|
+
+```json
+{
+  "plugins": [
+    ["@babel/plugin-transform-regenerator", {
+      "asyncGenerators": false,
+      "generators": false,
+      "async": false
+    }]
+  ]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-regenerator script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-regenerator"]
+});
+```
diff --git a/node_modules/@babel/plugin-transform-regenerator/lib/index.js b/node_modules/@babel/plugin-transform-regenerator/lib/index.js
new file mode 100644
index 00000000..34a79b0c
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-regenerator/lib/index.js
@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function get() {
+    return _regeneratorTransform().default;
+  }
+});
+
+function _regeneratorTransform() {
+  const data = _interopRequireDefault(require("regenerator-transform"));
+
+  _regeneratorTransform = function _regeneratorTransform() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-regenerator/package.json b/node_modules/@babel/plugin-transform-regenerator/package.json
new file mode 100644
index 00000000..896d7758
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-regenerator/package.json
@@ -0,0 +1,20 @@
+{
+  "name": "@babel/plugin-transform-regenerator",
+  "author": "Ben Newman <bn@cs.stanford.edu>",
+  "description": "Explode async and generator functions into a state machine.",
+  "version": "7.0.0-beta.47",
+  "homepage": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-regenerator",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-regenerator",
+  "main": "lib/index.js",
+  "dependencies": {
+    "regenerator-transform": "^0.12.3"
+  },
+  "license": "MIT",
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-runtime/README.md b/node_modules/@babel/plugin-transform-runtime/README.md
new file mode 100644
index 00000000..7b39101f
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-runtime/README.md
@@ -0,0 +1,358 @@
+# @babel/plugin-transform-runtime
+
+> Externalise references to helpers and built-ins, automatically polyfilling your code without polluting globals. (This plugin is recommended in a library/tool)
+
+NOTE: Instance methods such as `"foobar".includes("foo")` will not work since that would require modification of existing built-ins (Use [`@babel/polyfill`](http://babeljs.io/docs/usage/polyfill) for that).
+
+## Why?
+
+Babel uses very small helpers for common functions such as `_extend`. By default this will be added to every file that requires it. This duplication is sometimes unnecessary, especially when your application is spread out over multiple files.
+
+This is where the `@babel/plugin-transform-runtime` plugin comes in: all of the helpers will reference the module `@babel/runtime` to avoid duplication across your compiled output. The runtime will be compiled into your build.
+
+Another purpose of this transformer is to create a sandboxed environment for your code. If you use [@babel/polyfill](http://babeljs.io/docs/usage/polyfill/) and the built-ins it provides such as `Promise`, `Set` and `Map`, those will pollute the global scope. While this might be ok for an app or a command line tool, it becomes a problem if your code is a library which you intend to publish for others to use or if you can't exactly control the environment in which your code will run.
+
+The transformer will alias these built-ins to `core-js` so you can use them seamlessly without having to require the polyfill.
+
+See the [technical details](#technical-details) section for more information on how this works and the types of transformations that occur.
+
+## Installation
+
+**NOTE - Production vs. development dependencies**
+
+In most cases, you should install `@babel/plugin-transform-runtime` as a development dependency (with `--save-dev`).
+
+```sh
+npm install --save-dev @babel/plugin-transform-runtime
+```
+
+and `@babel/runtime` as a production dependency (with `--save`).
+
+```sh
+npm install --save @babel/runtime
+```
+
+The transformation plugin is typically used only in development, but the runtime itself will be depended on by your deployed/published code. See the examples below for more details.
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+Add the following line to your `.babelrc` file:
+
+Without options:
+
+```json
+{
+  "plugins": ["@babel/plugin-transform-runtime"]
+}
+```
+
+With options:
+
+```json
+{
+  "plugins": [
+    ["@babel/plugin-transform-runtime", {
+      "helpers": false,
+      "polyfill": false,
+      "regenerator": true,
+      "moduleName": "@babel/runtime"
+    }]
+  ]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-runtime script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-runtime"]
+});
+```
+
+## Options
+
+### `helpers`
+
+`boolean`, defaults to `true`.
+
+Toggles whether or not inlined Babel helpers (`classCallCheck`, `extends`, etc.) are replaced with calls to `moduleName`.
+
+For more information, see [Helper aliasing](#helper-aliasing).
+
+### `polyfill`
+
+`boolean`, defaults to `true`.
+
+Toggles whether or not new built-ins (`Promise`, `Set`, `Map`, etc.) are transformed to use a non-global polluting polyfill.
+
+For more information, see [`core-js` aliasing](#core-js-aliasing).
+
+### `regenerator`
+
+`boolean`, defaults to `true`.
+
+Toggles whether or not generator functions are transformed to use a regenerator runtime that does not pollute the global scope.
+
+For more information, see [Regenerator aliasing](#regenerator-aliasing).
+
+### `moduleName`
+
+`string`, defaults to `"@babel/runtime"`.
+
+Sets the name/path of the module used when importing helpers.
+
+Example:
+
+```json
+{
+  "moduleName": "flavortown/runtime"
+}
+```
+
+```js
+import extends from 'flavortown/runtime/helpers/extends';
+```
+
+### `useBuiltIns`
+
+`boolean`, defaults to `false`.
+
+When enabled, the transform will use helpers that do not use _any_ polyfills
+from `core-js`.
+
+For example, here is the `instance` helper with `useBuiltIns` disabled:
+
+```js
+exports.__esModule = true;
+
+var _hasInstance = require("../core-js/symbol/has-instance");
+
+var _hasInstance2 = _interopRequireDefault(_hasInstance);
+
+var _symbol = require("../core-js/symbol");
+
+var _symbol2 = _interopRequireDefault(_symbol);
+
+exports.default = function (left, right) {
+  if (right != null && typeof _symbol2.default !== "undefined" && right[_hasInstance2.default]) {
+    return right[_hasInstance2.default](left);
+  } else {
+    return left instanceof right;
+  }
+};
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+```
+
+And, with it enabled:
+
+```js
+exports.__esModule = true;
+
+exports.default = function (left, right) {
+  if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+    return right[Symbol.hasInstance](left);
+  } else {
+    return left instanceof right;
+  }
+};
+```
+
+### `useESModules`
+
+`boolean`, defaults to `false`.
+
+When enabled, the transform will use helpers that do not get run through
+`@babel/plugin-transform-modules-commonjs`. This allows for smaller builds in module
+systems like webpack, since it doesn't need to preserve commonjs semantics.
+
+For example, here is the `classCallCheck` helper with `useESModules` disabled:
+
+```js
+exports.__esModule = true;
+
+exports.default = function (instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+};
+```
+
+And, with it enabled:
+
+```js
+export default function (instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+```
+
+## Technical details
+
+The `runtime` transformer plugin does three things:
+
+* Automatically requires `@babel/runtime/regenerator` when you use generators/async functions.
+* Automatically requires `@babel/runtime/core-js` and maps ES6 static methods and built-ins.
+* Removes the inline Babel helpers and uses the module `@babel/runtime/helpers` instead.
+
+What does this actually mean though? Basically, you can use built-ins such as `Promise`, `Set`, `Symbol`, etc., as well use all the Babel features that require a polyfill seamlessly, without global pollution, making it extremely suitable for libraries.
+
+Make sure you include `@babel/runtime` as a dependency.
+
+### Regenerator aliasing
+
+Whenever you use a generator function or async function:
+
+```javascript
+function* foo() {
+
+}
+```
+
+the following is generated:
+
+```javascript
+"use strict";
+
+var _marked = [foo].map(regeneratorRuntime.mark);
+
+function foo() {
+  return regeneratorRuntime.wrap(function foo$(_context) {
+    while (1) {
+      switch (_context.prev = _context.next) {
+        case 0:
+        case "end":
+          return _context.stop();
+      }
+    }
+  }, _marked[0], this);
+}
+```
+
+This isn't ideal since it relies on the regenerator runtime being included, which
+pollutes the global scope.
+
+With the `runtime` transformer, however, it is compiled to:
+
+```javascript
+"use strict";
+
+var _regenerator = require("@babel/runtime/regenerator");
+
+var _regenerator2 = _interopRequireDefault(_regenerator);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _marked = [foo].map(_regenerator2.default.mark);
+
+function foo() {
+  return _regenerator2.default.wrap(function foo$(_context) {
+    while (1) {
+      switch (_context.prev = _context.next) {
+        case 0:
+        case "end":
+          return _context.stop();
+      }
+    }
+  }, _marked[0], this);
+}
+```
+
+This means that you can use the regenerator runtime without polluting your current environment.
+
+### `core-js` aliasing
+
+Sometimes you may want to use new built-ins such as `Map`, `Set`, `Promise` etc. Your only way
+to use these is usually to include a globally polluting polyfill.
+
+What the `runtime` transformer does is transform the following:
+
+```javascript
+var sym = Symbol();
+
+var promise = new Promise;
+
+console.log(arr[Symbol.iterator]());
+```
+
+into the following:
+
+```javascript
+"use strict";
+
+var _getIterator2 = require("@babel/runtime/core-js/get-iterator");
+
+var _getIterator3 = _interopRequireDefault(_getIterator2);
+
+var _promise = require("@babel/runtime/core-js/promise");
+
+var _promise2 = _interopRequireDefault(_promise);
+
+var _symbol = require("@babel/runtime/core-js/symbol");
+
+var _symbol2 = _interopRequireDefault(_symbol);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var sym = (0, _symbol2.default)();
+
+var promise = new _promise2.default();
+
+console.log((0, _getIterator3.default)(arr));
+```
+
+This means is that you can seamlessly use these native built-ins and static methods
+without worrying about where they come from.
+
+**NOTE:** Instance methods such as `"foobar".includes("foo")` will **not** work.
+
+### Helper aliasing
+
+Usually Babel will place helpers at the top of your file to do common tasks to avoid
+duplicating the code around in the current file. Sometimes these helpers can get a
+little bulky and add unnecessary duplication across files. The `runtime`
+transformer replaces all the helper calls to a module.
+
+That means that the following code:
+
+```javascript
+class Person {
+}
+```
+
+usually turns into:
+
+```javascript
+"use strict";
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Person = function Person() {
+  _classCallCheck(this, Person);
+};
+```
+
+the `runtime` transformer however turns this into:
+
+```javascript
+"use strict";
+
+var _classCallCheck2 = require("@babel/runtime/helpers/classCallCheck");
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var Person = function Person() {
+  (0, _classCallCheck3.default)(this, Person);
+};
+```
diff --git a/node_modules/@babel/plugin-transform-runtime/lib/definitions.js b/node_modules/@babel/plugin-transform-runtime/lib/definitions.js
new file mode 100644
index 00000000..a6a4346e
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-runtime/lib/definitions.js
@@ -0,0 +1,168 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = {
+  builtins: {
+    Symbol: "symbol",
+    Promise: "promise",
+    Map: "map",
+    WeakMap: "weak-map",
+    Set: "set",
+    WeakSet: "weak-set",
+    Observable: "observable",
+    setImmediate: "set-immediate",
+    clearImmediate: "clear-immediate",
+    asap: "asap"
+  },
+  methods: {
+    Array: {
+      copyWithin: "array/copy-within",
+      entries: "array/entries",
+      every: "array/every",
+      fill: "array/fill",
+      filter: "array/filter",
+      findIndex: "array/find-index",
+      find: "array/find",
+      forEach: "array/for-each",
+      from: "array/from",
+      includes: "array/includes",
+      indexOf: "array/index-of",
+      join: "array/join",
+      keys: "array/keys",
+      lastIndexOf: "array/last-index-of",
+      map: "array/map",
+      of: "array/of",
+      reduceRight: "array/reduce-right",
+      reduce: "array/reduce",
+      some: "array/some",
+      sort: "array/sort",
+      splice: "array/splice",
+      values: "array/values"
+    },
+    JSON: {
+      stringify: "json/stringify"
+    },
+    Object: {
+      assign: "object/assign",
+      create: "object/create",
+      defineProperties: "object/define-properties",
+      defineProperty: "object/define-property",
+      entries: "object/entries",
+      freeze: "object/freeze",
+      getOwnPropertyDescriptor: "object/get-own-property-descriptor",
+      getOwnPropertyDescriptors: "object/get-own-property-descriptors",
+      getOwnPropertyNames: "object/get-own-property-names",
+      getOwnPropertySymbols: "object/get-own-property-symbols",
+      getPrototypeOf: "object/get-prototype-of",
+      isExtensible: "object/is-extensible",
+      isFrozen: "object/is-frozen",
+      isSealed: "object/is-sealed",
+      is: "object/is",
+      keys: "object/keys",
+      preventExtensions: "object/prevent-extensions",
+      seal: "object/seal",
+      setPrototypeOf: "object/set-prototype-of",
+      values: "object/values"
+    },
+    Math: {
+      acosh: "math/acosh",
+      asinh: "math/asinh",
+      atanh: "math/atanh",
+      cbrt: "math/cbrt",
+      clz32: "math/clz32",
+      cosh: "math/cosh",
+      expm1: "math/expm1",
+      fround: "math/fround",
+      hypot: "math/hypot",
+      imul: "math/imul",
+      log10: "math/log10",
+      log1p: "math/log1p",
+      log2: "math/log2",
+      sign: "math/sign",
+      sinh: "math/sinh",
+      tanh: "math/tanh",
+      trunc: "math/trunc",
+      iaddh: "math/iaddh",
+      isubh: "math/isubh",
+      imulh: "math/imulh",
+      umulh: "math/umulh"
+    },
+    Symbol: {
+      for: "symbol/for",
+      hasInstance: "symbol/has-instance",
+      isConcatSpreadable: "symbol/is-concat-spreadable",
+      iterator: "symbol/iterator",
+      keyFor: "symbol/key-for",
+      match: "symbol/match",
+      replace: "symbol/replace",
+      search: "symbol/search",
+      species: "symbol/species",
+      split: "symbol/split",
+      toPrimitive: "symbol/to-primitive",
+      toStringTag: "symbol/to-string-tag",
+      unscopables: "symbol/unscopables"
+    },
+    String: {
+      at: "string/at",
+      codePointAt: "string/code-point-at",
+      endsWith: "string/ends-with",
+      fromCodePoint: "string/from-code-point",
+      includes: "string/includes",
+      matchAll: "string/match-all",
+      padStart: "string/pad-start",
+      padEnd: "string/pad-end",
+      raw: "string/raw",
+      repeat: "string/repeat",
+      startsWith: "string/starts-with",
+      trim: "string/trim",
+      trimLeft: "string/trim-left",
+      trimRight: "string/trim-right",
+      trimStart: "string/trim-start",
+      trimEnd: "string/trim-end"
+    },
+    Number: {
+      EPSILON: "number/epsilon",
+      isFinite: "number/is-finite",
+      isInteger: "number/is-integer",
+      isNaN: "number/is-nan",
+      isSafeInteger: "number/is-safe-integer",
+      MAX_SAFE_INTEGER: "number/max-safe-integer",
+      MIN_SAFE_INTEGER: "number/min-safe-integer",
+      parseFloat: "number/parse-float",
+      parseInt: "number/parse-int"
+    },
+    Reflect: {
+      apply: "reflect/apply",
+      construct: "reflect/construct",
+      defineProperty: "reflect/define-property",
+      deleteProperty: "reflect/delete-property",
+      getOwnPropertyDescriptor: "reflect/get-own-property-descriptor",
+      getPrototypeOf: "reflect/get-prototype-of",
+      get: "reflect/get",
+      has: "reflect/has",
+      isExtensible: "reflect/is-extensible",
+      ownKeys: "reflect/own-keys",
+      preventExtensions: "reflect/prevent-extensions",
+      setPrototypeOf: "reflect/set-prototype-of",
+      set: "reflect/set",
+      defineMetadata: "reflect/define-metadata",
+      deleteMetadata: "reflect/delete-metadata",
+      getMetadata: "reflect/get-metadata",
+      getMetadataKeys: "reflect/get-metadata-keys",
+      getOwnMetadata: "reflect/get-own-metadata",
+      getOwnMetadataKeys: "reflect/get-own-metadata-keys",
+      hasMetadata: "reflect/has-metadata",
+      hasOwnMetadata: "reflect/has-own-metadata",
+      metadata: "reflect/metadata"
+    },
+    System: {
+      global: "system/global"
+    },
+    Date: {},
+    Function: {}
+  }
+};
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-runtime/lib/index.js b/node_modules/@babel/plugin-transform-runtime/lib/index.js
new file mode 100644
index 00000000..716e2b0f
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-runtime/lib/index.js
@@ -0,0 +1,184 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "definitions", {
+  enumerable: true,
+  get: function get() {
+    return _definitions.default;
+  }
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperModuleImports() {
+  const data = require("@babel/helper-module-imports");
+
+  _helperModuleImports = function _helperModuleImports() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+var _definitions = _interopRequireDefault(require("./definitions"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _helperPluginUtils().declare)((api, options) => {
+  api.assertVersion(7);
+  const helpers = options.helpers,
+        _options$moduleName = options.moduleName,
+        moduleName = _options$moduleName === void 0 ? "@babel/runtime" : _options$moduleName,
+        polyfill = options.polyfill,
+        regenerator = options.regenerator,
+        useBuiltIns = options.useBuiltIns,
+        useESModules = options.useESModules;
+  const regeneratorEnabled = regenerator !== false;
+  const notPolyfillOrDoesUseBuiltIns = polyfill === false || useBuiltIns;
+  const isPolyfillAndUseBuiltIns = polyfill && useBuiltIns;
+  const baseHelpersDir = useBuiltIns ? "helpers/builtin" : "helpers";
+  const helpersDir = useESModules ? `${baseHelpersDir}/es6` : baseHelpersDir;
+
+  function has(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+  }
+
+  const HEADER_HELPERS = ["interopRequireWildcard", "interopRequireDefault"];
+  return {
+    pre(file) {
+      if (helpers !== false) {
+        file.set("helperGenerator", name => {
+          const isInteropHelper = HEADER_HELPERS.indexOf(name) !== -1;
+          const blockHoist = isInteropHelper && !(0, _helperModuleImports().isModule)(file.path) ? 4 : undefined;
+          return this.addDefaultImport(`${moduleName}/${helpersDir}/${name}`, name, blockHoist);
+        });
+      }
+
+      if (isPolyfillAndUseBuiltIns) {
+        throw new Error("The polyfill option conflicts with useBuiltIns; use one or the other");
+      }
+
+      this.moduleName = moduleName;
+      const cache = new Map();
+
+      this.addDefaultImport = (source, nameHint, blockHoist) => {
+        const cacheKey = (0, _helperModuleImports().isModule)(file.path);
+        const key = `${source}:${nameHint}:${cacheKey || ""}`;
+        let cached = cache.get(key);
+
+        if (cached) {
+          cached = _core().types.cloneNode(cached);
+        } else {
+          cached = (0, _helperModuleImports().addDefault)(file.path, source, {
+            importedInterop: "uncompiled",
+            nameHint,
+            blockHoist
+          });
+          cache.set(key, cached);
+        }
+
+        return cached;
+      };
+    },
+
+    visitor: {
+      ReferencedIdentifier(path) {
+        const node = path.node,
+              parent = path.parent,
+              scope = path.scope;
+
+        if (node.name === "regeneratorRuntime" && regeneratorEnabled) {
+          path.replaceWith(this.addDefaultImport(`${this.moduleName}/regenerator`, "regeneratorRuntime"));
+          return;
+        }
+
+        if (notPolyfillOrDoesUseBuiltIns) return;
+        if (_core().types.isMemberExpression(parent)) return;
+        if (!has(_definitions.default.builtins, node.name)) return;
+        if (scope.getBindingIdentifier(node.name)) return;
+        path.replaceWith(this.addDefaultImport(`${moduleName}/core-js/${_definitions.default.builtins[node.name]}`, node.name));
+      },
+
+      CallExpression(path) {
+        if (notPolyfillOrDoesUseBuiltIns) return;
+        if (path.node.arguments.length) return;
+        const callee = path.node.callee;
+        if (!_core().types.isMemberExpression(callee)) return;
+        if (!callee.computed) return;
+
+        if (!path.get("callee.property").matchesPattern("Symbol.iterator")) {
+          return;
+        }
+
+        path.replaceWith(_core().types.callExpression(this.addDefaultImport(`${moduleName}/core-js/get-iterator`, "getIterator"), [callee.object]));
+      },
+
+      BinaryExpression(path) {
+        if (notPolyfillOrDoesUseBuiltIns) return;
+        if (path.node.operator !== "in") return;
+        if (!path.get("left").matchesPattern("Symbol.iterator")) return;
+        path.replaceWith(_core().types.callExpression(this.addDefaultImport(`${moduleName}/core-js/is-iterable`, "isIterable"), [path.node.right]));
+      },
+
+      MemberExpression: {
+        enter(path) {
+          if (notPolyfillOrDoesUseBuiltIns) return;
+          if (!path.isReferenced()) return;
+          const node = path.node;
+          const obj = node.object;
+          const prop = node.property;
+          if (!_core().types.isReferenced(obj, node)) return;
+          if (node.computed) return;
+          if (!has(_definitions.default.methods, obj.name)) return;
+          const methods = _definitions.default.methods[obj.name];
+          if (!has(methods, prop.name)) return;
+          if (path.scope.getBindingIdentifier(obj.name)) return;
+
+          if (obj.name === "Object" && prop.name === "defineProperty" && path.parentPath.isCallExpression()) {
+            const call = path.parentPath.node;
+
+            if (call.arguments.length === 3 && _core().types.isLiteral(call.arguments[1])) {
+              return;
+            }
+          }
+
+          path.replaceWith(this.addDefaultImport(`${moduleName}/core-js/${methods[prop.name]}`, `${obj.name}$${prop.name}`));
+        },
+
+        exit(path) {
+          if (notPolyfillOrDoesUseBuiltIns) return;
+          if (!path.isReferenced()) return;
+          const node = path.node;
+          const obj = node.object;
+          if (!has(_definitions.default.builtins, obj.name)) return;
+          if (path.scope.getBindingIdentifier(obj.name)) return;
+          path.replaceWith(_core().types.memberExpression(this.addDefaultImport(`${moduleName}/core-js/${_definitions.default.builtins[obj.name]}`, obj.name), node.property, node.computed));
+        }
+
+      }
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-runtime/package.json b/node_modules/@babel/plugin-transform-runtime/package.json
new file mode 100644
index 00000000..be24dbe8
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-runtime/package.json
@@ -0,0 +1,22 @@
+{
+  "name": "@babel/plugin-transform-runtime",
+  "version": "7.0.0-beta.47",
+  "description": "Externalise references to helpers and builtins, automatically polyfilling your code without polluting globals",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-runtime",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-module-imports": "7.0.0-beta.47",
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-shorthand-properties/README.md b/node_modules/@babel/plugin-transform-shorthand-properties/README.md
new file mode 100644
index 00000000..917c783f
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-shorthand-properties/README.md
@@ -0,0 +1,69 @@
+# @babel/plugin-transform-shorthand-properties
+
+> Compile ES2015 shorthand properties to ES5
+
+## Example
+
+**In**
+
+```js
+var o = { a, b, c };
+```
+
+**Out**
+
+```js
+var o = { a: a, b: b, c: c };
+```
+
+**In**
+
+```js
+var cat = {
+  getName() {
+    return name;
+  }
+};
+```
+
+**Out**
+
+```js
+var cat = {
+  getName: function () {
+    return name;
+  }
+};
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-shorthand-properties
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-transform-shorthand-properties"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-shorthand-properties script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-shorthand-properties"]
+});
+```
diff --git a/node_modules/@babel/plugin-transform-shorthand-properties/lib/index.js b/node_modules/@babel/plugin-transform-shorthand-properties/lib/index.js
new file mode 100644
index 00000000..5be0bd73
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-shorthand-properties/lib/index.js
@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+  return {
+    visitor: {
+      ObjectMethod(path) {
+        const node = path.node;
+
+        if (node.kind === "method") {
+          const func = _core().types.functionExpression(null, node.params, node.body, node.generator, node.async);
+
+          func.returnType = node.returnType;
+          path.replaceWith(_core().types.objectProperty(node.key, func, node.computed));
+        }
+      },
+
+      ObjectProperty({
+        node
+      }) {
+        if (node.shorthand) {
+          node.shorthand = false;
+        }
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-shorthand-properties/package.json b/node_modules/@babel/plugin-transform-shorthand-properties/package.json
new file mode 100644
index 00000000..6e726dd0
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-shorthand-properties/package.json
@@ -0,0 +1,21 @@
+{
+  "name": "@babel/plugin-transform-shorthand-properties",
+  "version": "7.0.0-beta.47",
+  "description": "Compile ES2015 shorthand properties to ES5",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-shorthand-properties",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-spread/README.md b/node_modules/@babel/plugin-transform-spread/README.md
new file mode 100644
index 00000000..75f2fcc1
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-spread/README.md
@@ -0,0 +1,83 @@
+# @babel/plugin-transform-spread
+
+> Compile ES2015 spread to ES5
+
+## Example
+
+**In**
+
+```js
+var a = ['a', 'b', 'c'];
+
+var b = [...a, 'foo'];
+
+var c = foo(...a);
+```
+
+**Out**
+
+```js
+var a = ['a', 'b', 'c'];
+
+var b = a.concat(['foo']);
+
+var c = foo.apply(void 0, a);
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-spread
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+Without options:
+
+```json
+{
+  "plugins": ["@babel/plugin-transform-spread"]
+}
+```
+
+With options:
+
+```json
+{
+  "plugins": [
+    ["@babel/plugin-transform-spread", {
+      "loose": true
+    }]
+  ]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-spread script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-spread"]
+});
+```
+
+## Options
+
+### `loose`
+
+`boolean`, defaults to `false`.
+
+In loose mode, **all** iterables are assumed to be arrays.
+
+## References
+
+* [MDN: Spread syntax](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax)
diff --git a/node_modules/@babel/plugin-transform-spread/lib/index.js b/node_modules/@babel/plugin-transform-spread/lib/index.js
new file mode 100644
index 00000000..42ce48fc
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-spread/lib/index.js
@@ -0,0 +1,176 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = (0, _helperPluginUtils().declare)((api, options) => {
+  api.assertVersion(7);
+  const loose = options.loose;
+
+  function getSpreadLiteral(spread, scope) {
+    if (loose && !_core().types.isIdentifier(spread.argument, {
+      name: "arguments"
+    })) {
+      return spread.argument;
+    } else {
+      return scope.toArray(spread.argument, true);
+    }
+  }
+
+  function hasSpread(nodes) {
+    for (let i = 0; i < nodes.length; i++) {
+      if (_core().types.isSpreadElement(nodes[i])) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  function push(_props, nodes) {
+    if (!_props.length) return _props;
+    nodes.push(_core().types.arrayExpression(_props));
+    return [];
+  }
+
+  function build(props, scope) {
+    const nodes = [];
+    let _props = [];
+
+    for (var _iterator = props, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i >= _iterator.length) break;
+        _ref = _iterator[_i++];
+      } else {
+        _i = _iterator.next();
+        if (_i.done) break;
+        _ref = _i.value;
+      }
+
+      const prop = _ref;
+
+      if (_core().types.isSpreadElement(prop)) {
+        _props = push(_props, nodes);
+        nodes.push(getSpreadLiteral(prop, scope));
+      } else {
+        _props.push(prop);
+      }
+    }
+
+    push(_props, nodes);
+    return nodes;
+  }
+
+  return {
+    visitor: {
+      ArrayExpression(path) {
+        const node = path.node,
+              scope = path.scope;
+        const elements = node.elements;
+        if (!hasSpread(elements)) return;
+        const nodes = build(elements, scope);
+        const first = nodes.shift();
+
+        if (nodes.length === 0 && first !== elements[0].argument) {
+          path.replaceWith(first);
+          return;
+        }
+
+        path.replaceWith(_core().types.callExpression(_core().types.memberExpression(first, _core().types.identifier("concat")), nodes));
+      },
+
+      CallExpression(path) {
+        const node = path.node,
+              scope = path.scope;
+        const args = node.arguments;
+        if (!hasSpread(args)) return;
+        const calleePath = path.get("callee");
+        if (calleePath.isSuper()) return;
+        let contextLiteral = scope.buildUndefinedNode();
+        node.arguments = [];
+        let nodes;
+
+        if (args.length === 1 && args[0].argument.name === "arguments") {
+          nodes = [args[0].argument];
+        } else {
+          nodes = build(args, scope);
+        }
+
+        const first = nodes.shift();
+
+        if (nodes.length) {
+          node.arguments.push(_core().types.callExpression(_core().types.memberExpression(first, _core().types.identifier("concat")), nodes));
+        } else {
+          node.arguments.push(first);
+        }
+
+        const callee = node.callee;
+
+        if (calleePath.isMemberExpression()) {
+          const temp = scope.maybeGenerateMemoised(callee.object);
+
+          if (temp) {
+            callee.object = _core().types.assignmentExpression("=", temp, callee.object);
+            contextLiteral = temp;
+          } else {
+            contextLiteral = _core().types.cloneNode(callee.object);
+          }
+
+          _core().types.appendToMemberExpression(callee, _core().types.identifier("apply"));
+        } else {
+          node.callee = _core().types.memberExpression(node.callee, _core().types.identifier("apply"));
+        }
+
+        if (_core().types.isSuper(contextLiteral)) {
+          contextLiteral = _core().types.thisExpression();
+        }
+
+        node.arguments.unshift(_core().types.cloneNode(contextLiteral));
+      },
+
+      NewExpression(path) {
+        const node = path.node,
+              scope = path.scope;
+        let args = node.arguments;
+        if (!hasSpread(args)) return;
+        const nodes = build(args, scope);
+        const first = nodes.shift();
+
+        if (nodes.length) {
+          args = _core().types.callExpression(_core().types.memberExpression(first, _core().types.identifier("concat")), nodes);
+        } else {
+          args = first;
+        }
+
+        path.replaceWith(_core().types.callExpression(path.hub.file.addHelper("construct"), [node.callee, args]));
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-spread/package.json b/node_modules/@babel/plugin-transform-spread/package.json
new file mode 100644
index 00000000..2caf0585
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-spread/package.json
@@ -0,0 +1,21 @@
+{
+  "name": "@babel/plugin-transform-spread",
+  "version": "7.0.0-beta.47",
+  "description": "Compile ES2015 spread to ES5",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-spread",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-sticky-regex/README.md b/node_modules/@babel/plugin-transform-sticky-regex/README.md
new file mode 100644
index 00000000..8c1bb2f8
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-sticky-regex/README.md
@@ -0,0 +1,49 @@
+# @babel/plugin-transform-sticky-regex
+
+> Compile ES2015 sticky regex to an ES5 RegExp constructor
+
+## Examples
+
+**In**
+
+```javascript
+const a = /o+/y;
+```
+
+**Out**
+
+```javascript
+var a = new RegExp("o+", "y");
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-sticky-regex
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-transform-sticky-regex"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-sticky-regex script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-sticky-regex"]
+});
+```
diff --git a/node_modules/@babel/plugin-transform-sticky-regex/lib/index.js b/node_modules/@babel/plugin-transform-sticky-regex/lib/index.js
new file mode 100644
index 00000000..9ec20067
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-sticky-regex/lib/index.js
@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function regex() {
+  const data = _interopRequireWildcard(require("@babel/helper-regex"));
+
+  regex = function regex() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+  return {
+    visitor: {
+      RegExpLiteral(path) {
+        const node = path.node;
+        if (!regex().is(node, "y")) return;
+        path.replaceWith(_core().types.newExpression(_core().types.identifier("RegExp"), [_core().types.stringLiteral(node.pattern), _core().types.stringLiteral(node.flags)]));
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-sticky-regex/package.json b/node_modules/@babel/plugin-transform-sticky-regex/package.json
new file mode 100644
index 00000000..5aa3b3f8
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-sticky-regex/package.json
@@ -0,0 +1,22 @@
+{
+  "name": "@babel/plugin-transform-sticky-regex",
+  "version": "7.0.0-beta.47",
+  "description": "Compile ES2015 sticky regex to an ES5 RegExp constructor",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-sticky-regex",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47",
+    "@babel/helper-regex": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-template-literals/README.md b/node_modules/@babel/plugin-transform-template-literals/README.md
new file mode 100644
index 00000000..d22f3b92
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-template-literals/README.md
@@ -0,0 +1,85 @@
+# @babel/plugin-transform-template-literals
+
+> Compile ES2015 template literals to ES5
+
+## Example
+
+**In**
+
+```javascript
+`foo${bar}`;
+```
+
+**Out**
+
+```javascript
+"foo".concat(bar);
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-template-literals
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+Without options:
+
+```json
+{
+  "plugins": ["@babel/plugin-transform-template-literals"]
+}
+```
+
+With options:
+
+```json
+{
+  "plugins": [
+    ["@babel/plugin-transform-template-literals", {
+      "loose": true
+    }]
+  ]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-template-literals script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-template-literals"]
+});
+```
+
+## Options
+
+### `loose`
+
+`boolean`, defaults to `false`.
+
+When `true`, tagged template literal objects aren't frozen. All template literal expressions and quasis are combined with the `+` operator instead of with `String.prototype.concat`.
+
+When `false` or not set, all template literal expressions and quasis are combined with `String.prototype.concat`. It will handle cases with `Symbol.toPrimitive` correctly and throw correctly if template literal expression is a `Symbol()`. See [babel/babel#5791](https://github.com/babel/babel/pull/5791).
+
+**In**
+
+```javascript
+`foo${bar}`;
+```
+
+**Out**
+
+```javascript
+"foo" + bar;
+```
diff --git a/node_modules/@babel/plugin-transform-template-literals/lib/index.js b/node_modules/@babel/plugin-transform-template-literals/lib/index.js
new file mode 100644
index 00000000..672aeaec
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-template-literals/lib/index.js
@@ -0,0 +1,145 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = (0, _helperPluginUtils().declare)((api, options) => {
+  api.assertVersion(7);
+  const loose = options.loose;
+  let helperName = "taggedTemplateLiteral";
+  if (loose) helperName += "Loose";
+
+  function buildConcatCallExressions(items) {
+    let avail = true;
+    return items.reduce(function (left, right) {
+      let canBeInserted = _core().types.isLiteral(right);
+
+      if (!canBeInserted && avail) {
+        canBeInserted = true;
+        avail = false;
+      }
+
+      if (canBeInserted && _core().types.isCallExpression(left)) {
+        left.arguments.push(right);
+        return left;
+      }
+
+      return _core().types.callExpression(_core().types.memberExpression(left, _core().types.identifier("concat")), [right]);
+    });
+  }
+
+  return {
+    visitor: {
+      TaggedTemplateExpression(path) {
+        const node = path.node;
+        const quasi = node.quasi;
+        const strings = [];
+        const raws = [];
+        let isStringsRawEqual = true;
+        var _arr = quasi.quasis;
+
+        for (var _i = 0; _i < _arr.length; _i++) {
+          const elem = _arr[_i];
+          const _elem$value = elem.value,
+                raw = _elem$value.raw,
+                cooked = _elem$value.cooked;
+          const value = cooked == null ? path.scope.buildUndefinedNode() : _core().types.stringLiteral(cooked);
+          strings.push(value);
+          raws.push(_core().types.stringLiteral(raw));
+
+          if (raw !== cooked) {
+            isStringsRawEqual = false;
+          }
+        }
+
+        const scope = path.scope.getProgramParent();
+        const templateObject = scope.generateUidIdentifier("templateObject");
+        const helperId = this.addHelper(helperName);
+        const callExpressionInput = [_core().types.arrayExpression(strings)];
+
+        if (!isStringsRawEqual) {
+          callExpressionInput.push(_core().types.arrayExpression(raws));
+        }
+
+        const lazyLoad = _core().template.ast`
+          function ${templateObject}() {
+            const data = ${_core().types.callExpression(helperId, callExpressionInput)};
+            ${templateObject} = function() { return data };
+            return data;
+          } 
+        `;
+        scope.path.unshiftContainer("body", lazyLoad);
+        path.replaceWith(_core().types.callExpression(node.tag, [_core().types.callExpression(_core().types.cloneNode(templateObject), []), ...quasi.expressions]));
+      },
+
+      TemplateLiteral(path) {
+        const nodes = [];
+        const expressions = path.get("expressions");
+        let index = 0;
+        var _arr2 = path.node.quasis;
+
+        for (var _i2 = 0; _i2 < _arr2.length; _i2++) {
+          const elem = _arr2[_i2];
+
+          if (elem.value.cooked) {
+            nodes.push(_core().types.stringLiteral(elem.value.cooked));
+          }
+
+          if (index < expressions.length) {
+            const expr = expressions[index++];
+            const node = expr.node;
+
+            if (!_core().types.isStringLiteral(node, {
+              value: ""
+            })) {
+              nodes.push(node);
+            }
+          }
+        }
+
+        const considerSecondNode = !loose || !_core().types.isStringLiteral(nodes[1]);
+
+        if (!_core().types.isStringLiteral(nodes[0]) && considerSecondNode) {
+          nodes.unshift(_core().types.stringLiteral(""));
+        }
+
+        let root = nodes[0];
+
+        if (loose) {
+          for (let i = 1; i < nodes.length; i++) {
+            root = _core().types.binaryExpression("+", root, nodes[i]);
+          }
+        } else if (nodes.length > 1) {
+          root = buildConcatCallExressions(nodes);
+        }
+
+        path.replaceWith(root);
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-template-literals/package.json b/node_modules/@babel/plugin-transform-template-literals/package.json
new file mode 100644
index 00000000..aa851d1e
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-template-literals/package.json
@@ -0,0 +1,22 @@
+{
+  "name": "@babel/plugin-transform-template-literals",
+  "version": "7.0.0-beta.47",
+  "description": "Compile ES2015 template literals to ES5",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-template-literals",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/helper-annotate-as-pure": "7.0.0-beta.47",
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "keywords": [
+    "babel-plugin"
+  ],
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-typeof-symbol/README.md b/node_modules/@babel/plugin-transform-typeof-symbol/README.md
new file mode 100644
index 00000000..03aa1704
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-typeof-symbol/README.md
@@ -0,0 +1,53 @@
+# @babel/plugin-transform-typeof-symbol
+
+> ES6 introduces a new native type called [symbols](https://babeljs.io/learn-es2015/#ecmascript-2015-features-symbols). This transformer wraps all `typeof` expressions with a method that replicates native behaviour. (ie. returning "symbol" for symbols)
+
+## Example
+
+**In**
+
+```javascript
+typeof Symbol() === "symbol";
+```
+
+**Out**
+
+```javascript
+var _typeof = function (obj) {
+  return obj && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+
+_typeof(Symbol()) === "symbol";
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-typeof-symbol
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-transform-typeof-symbol"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-typeof-symbol script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-typeof-symbol"]
+});
+```
diff --git a/node_modules/@babel/plugin-transform-typeof-symbol/lib/index.js b/node_modules/@babel/plugin-transform-typeof-symbol/lib/index.js
new file mode 100644
index 00000000..fbc627b6
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-typeof-symbol/lib/index.js
@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+  return {
+    visitor: {
+      Scope({
+        scope
+      }) {
+        if (!scope.getBinding("Symbol")) {
+          return;
+        }
+
+        scope.rename("Symbol");
+      },
+
+      UnaryExpression(path) {
+        const node = path.node,
+              parent = path.parent;
+        if (node.operator !== "typeof") return;
+
+        if (path.parentPath.isBinaryExpression() && _core().types.EQUALITY_BINARY_OPERATORS.indexOf(parent.operator) >= 0) {
+          const opposite = path.getOpposite();
+
+          if (opposite.isLiteral() && opposite.node.value !== "symbol" && opposite.node.value !== "object") {
+            return;
+          }
+        }
+
+        const helper = this.addHelper("typeof");
+        const isUnderHelper = path.findParent(path => {
+          return path.isVariableDeclarator() && path.node.id === helper || path.isFunctionDeclaration() && path.node.id && path.node.id.name === helper.name;
+        });
+
+        if (isUnderHelper) {
+          return;
+        }
+
+        const call = _core().types.callExpression(helper, [node.argument]);
+
+        const arg = path.get("argument");
+
+        if (arg.isIdentifier() && !path.scope.hasBinding(arg.node.name, true)) {
+          const unary = _core().types.unaryExpression("typeof", _core().types.cloneNode(node.argument));
+
+          path.replaceWith(_core().types.conditionalExpression(_core().types.binaryExpression("===", unary, _core().types.stringLiteral("undefined")), _core().types.stringLiteral("undefined"), call));
+        } else {
+          path.replaceWith(call);
+        }
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-typeof-symbol/package.json b/node_modules/@babel/plugin-transform-typeof-symbol/package.json
new file mode 100644
index 00000000..858f4803
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-typeof-symbol/package.json
@@ -0,0 +1,21 @@
+{
+  "name": "@babel/plugin-transform-typeof-symbol",
+  "version": "7.0.0-beta.47",
+  "description": "This transformer wraps all typeof expressions with a method that replicates native behaviour. (ie. returning “symbol” for symbols)",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-typeof-symbol",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/plugin-transform-unicode-regex/README.md b/node_modules/@babel/plugin-transform-unicode-regex/README.md
new file mode 100644
index 00000000..a6d79cf7
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-unicode-regex/README.md
@@ -0,0 +1,51 @@
+# @babel/plugin-transform-unicode-regex
+
+> Compile ES2015 unicode regex to ES5
+
+## Example
+
+**In**
+
+```js
+var string = "foo💩bar";
+var match = string.match(/foo(.)bar/u);
+```
+
+**Out**
+
+```js
+var string = "foo💩bar";
+var match = string.match(/foo((?:[\0-\t\x0B\f\x0E-\u2027\u202A-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]))bar/);
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-unicode-regex
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["@babel/plugin-transform-unicode-regex"]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-unicode-regex script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-unicode-regex"]
+});
+```
diff --git a/node_modules/@babel/plugin-transform-unicode-regex/lib/index.js b/node_modules/@babel/plugin-transform-unicode-regex/lib/index.js
new file mode 100644
index 00000000..6735b307
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-unicode-regex/lib/index.js
@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _regexpuCore() {
+  const data = _interopRequireDefault(require("regexpu-core"));
+
+  _regexpuCore = function _regexpuCore() {
+    return data;
+  };
+
+  return data;
+}
+
+function regex() {
+  const data = _interopRequireWildcard(require("@babel/helper-regex"));
+
+  regex = function regex() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _helperPluginUtils().declare)(api => {
+  api.assertVersion(7);
+  return {
+    visitor: {
+      RegExpLiteral({
+        node
+      }) {
+        if (!regex().is(node, "u")) return;
+        node.pattern = (0, _regexpuCore().default)(node.pattern, node.flags);
+        regex().pullFlag(node, "u");
+      }
+
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-unicode-regex/package.json b/node_modules/@babel/plugin-transform-unicode-regex/package.json
new file mode 100644
index 00000000..9bdfc9f4
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-unicode-regex/package.json
@@ -0,0 +1,23 @@
+{
+  "name": "@babel/plugin-transform-unicode-regex",
+  "version": "7.0.0-beta.47",
+  "description": "Compile ES2015 Unicode regex to ES5",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-unicode-regex",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47",
+    "@babel/helper-regex": "7.0.0-beta.47",
+    "regexpu-core": "^4.1.3"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/preset-env/CHANGELOG.md b/node_modules/@babel/preset-env/CHANGELOG.md
new file mode 100644
index 00000000..c550b987
--- /dev/null
+++ b/node_modules/@babel/preset-env/CHANGELOG.md
@@ -0,0 +1,668 @@
+# Changelog
+
+## v1.6.1 (2017-10-17)
+
+### :bug: Bug Fix
+
+- Update compat table to fix two small issues ([#445](https://github.com/babel/babel-preset-env/pull/445)) (@danez)
+
+ES2015 destructuring is not fully supported in Edge 15 and the polyfill required again. `es6.math.imul` is supported on Android as of version 4.4
+
+- Add polyfills for ES6 static Object methods ([#441](https://github.com/babel/babel-preset-env/pull/441)) (@danez)
+
+Functions such as `Object.keys`, `Object.freeze`, ... do already exist in ES5, but their behaviour changed in ES2015. `babel-preset-env` with `builtIns: true` now adds the core-js polyfills for this methods if the browser only supports the ES5 variant of the method (like IE11 for example)
+
+- Normalize module format of plugins/built-ins data ([#376](https://github.com/babel/babel-preset-env/pull/376)) (@rtsao)
+
+## v1.6.0 (2017-07-04)
+
+### :rocket: New Feature
+
+- Bump compat-table for node8 support ([#363](https://github.com/babel/babel-preset-env/pull/363)) (@existentialism)
+
+We updated our mappings to support native trailing function commas and string paddings in Node.js 8+.
+
+### :bug: Bug Fix
+
+- Handle `chromeandroid` browserslist value ([#367](https://github.com/babel/babel-preset-env/pull/367)) (@yavorsky)
+
+We added support for using browserslist's `chromeandroid` in `targets`.
+
+### :memo: Documentation
+
+- Tweak uglify option docs ([#368](https://github.com/babel/babel-preset-env/pull/368)) (@existentialism)
+
+Thanks to @graingert and @pfiaux for pointing out some needed updates to the `uglify-js`-related docs.
+
+## v1.5.2 (2017-06-07)
+
+### :bug: Bug Fix
+
+- Ensure explicit targets always override browsers key targets ([#346](https://github.com/babel/babel-preset-env/pull/346)) (@existentialism)
+
+`browser` targets should be overridden by explicit targets, and we inadvertently broke this when we landed string version support.
+
+## v1.5.1 (2017-05-22)
+
+### :bug: Bug Fix
+
+- Compile with loose mode ([#322](https://github.com/babel/babel-preset-env/pull/332)) (@existentialism)
+
+## v1.5.0 (2017-05-19)
+
+### :rocket: New Feature
+
+- Support target versions as strings ([#321](https://github.com/babel/babel-preset-env/pull/321)) (@existentialism)
+
+We were originally waiting on 2.x for a breaking change, but since node v7.10
+and other targets are causing some pain, we decided to land a backwards
+compatible version.
+
+### :house: Internal
+
+- Backport: use preset-env and remove flow-strip-types ([#324](https://github.com/babel/babel-preset-env/pull/324)) (@yavorsky)
+- Bump electron-to-chromium ([#329](https://github.com/babel/babel-preset-env/pull/329)) (@existentialism)
+- Tweak version mappings to match compat-table updates ([#323](https://github.com/babel/babel-preset-env/pull/323)) (@existentialism)
+- Bump browserslist ([#319](https://github.com/babel/babel-preset-env/pull/319)) (@existentialism)
+- Bump compat-table ([#307](https://github.com/babel/babel-preset-env/pull/307)) (@existentialism)
+- Add debug-fixtures and test/tmp to .eslintignore ([#305](https://github.com/babel/babel-preset-env/pull/305)) (@yavorsky)
+
+## v1.4.0 (2017-04-14)
+
+### :rocket: New Feature
+
+- Support `spec` option ([#98](https://github.com/babel/babel-preset-env/pull/98)) (@Kovensky)
+
+Added an option to enable more spec compliant, but potentially slower, transformations for any plugins in this preset that support them.
+
+- Bump compat-table for Edge 15 support ([#273](https://github.com/babel/babel-preset-env/pull/273)) (@existentialism)
+
+We updated our mappings so that you can get native support for async/await and other goodies when targeting Edge 15!
+
+### :bug: Bug Fix
+
+- Add Android browser to name map ([#270](https://github.com/babel/babel-preset-env/pull/270)) (@existentialism)
+
+Fixed a bug that was ignoring Android targets in browserslist queries (for example: "Android >= 4").
+
+### :memo: Documentation
+
+- Clarify note about loading polyfills only once ([#282](https://github.com/babel/babel-preset-env/pull/282)) (@darahak)
+- Add a reminder about include/exclude options ([#275](https://github.com/babel/babel-preset-env/pull/275)) (@existentialism)
+
+### :house: Internal
+
+- Chore: reduce package size. ([#281](https://github.com/babel/babel-preset-env/pull/281)) (@evilebottnawi)
+- Remove deprecated comment ([#271](https://github.com/babel/babel-preset-env/pull/271)) (@yavorsky)
+
+## v1.3.3 (2017-04-07)
+
+### :bug: Bug Fix
+
+- Support electron version in a string format ([#252](https://github.com/babel/babel-preset-env/pull/252)) (@yavorsky)
+
+Adding electron as a target was an inadvertent breaking change as it no longer
+allowed string versions. We added an exception for now, even though it is
+inconsistent with other versions. Just as a note, the upcoming version 2.x will
+allow _both_ number and string versions.
+
+- Ensure const-check plugin order ([#257](https://github.com/babel/babel-preset-env/pull/257)) (@existentialism)
+
+We now force the `const-es2015-check` plugin to run first (so that it can
+correctly report issues before they get transpiled away).
+
+### :rocket: New Feature
+
+- Allow use `babel-plugin-` prefix for include and exclude ([#242](https://github.com/babel/babel-preset-env/pull/242)) (@yavorsky)
+
+The `include` and `exclude` options now allow both prefixed (`babel-plugin-transform-es2015-spread`)
+and prefix-less (`transform-es2015-spread`) plugin names.
+
+### :memo: Documentation
+
+- Note babel plugin prefix handling in include/exclude ([#245](https://github.com/babel/babel-preset-env/pull/245)) (@existentialism)
+- Fix README: debug option shows info in stdout. ([#236](https://github.com/babel/babel-preset-env/pull/236)) (@Gerhut)
+
+### :house: Internal
+
+- Add simple smoke-test ([#240](https://github.com/babel/babel-preset-env/pull/240)) (@existentialism)
+- Add prepublish script (@existentialism)
+
+## v1.3.2 (2017-03-30)
+
+- Fixed an issue with a broken publish
+
+## v1.3.1 (2017-03-30)
+
+- Fixed a regression with missing files due to `.npmignore`.
+
+## v1.3.0 (2017-03-30)
+
+### :bug: Bug Fix
+
+- Add check for ArrayBuffer[Symbol.species] ([#233](https://github.com/babel/babel-preset-env/pull/233)) (@existentialism)
+
+We now properly check for `Symbol.species` support in ArrayBuffer and include the
+polyfill if necessary. This should, as a side effect, fix ArrayBuffer-related
+errors on IE9.
+
+### :nail_care: Polish
+
+- Fill data with electron as a target. ([#229](https://github.com/babel/babel-preset-env/pull/229)) (@yavorsky)
+
+We've simplified things by adding `electron` as a target instead of doing a bunch of
+things at runtime. Electron targets should now also be displayed in the debug output.
+
+- separate default builtins for platforms ([#226](https://github.com/babel/babel-preset-env/pull/226)) (@restrry)
+
+If you are targeting the `node` environment exclusively, the always-included web polyfills
+(like `dom.iterable`, and a few others) will now no longer be included.
+
+### :memo: Documentation
+
+ * remove deprecated projects ([#223](https://github.com/babel/babel-preset-env/pull/223)) [skip ci] (@stevemao)
+
+### :house: Internal
+
+ * npmignore: Add related to build data and codecov. ([#216](https://github.com/babel/babel-preset-env/pull/216)) (@yavorsky)
+
+## v1.2.2 (2017-03-14)
+
+### :bug: Bug Fix
+
+- Refactor browser data parsing to handle families ([#208](https://github.com/babel/babel-preset-env/pull/208)) (@existentialism)
+
+When parsing plugin data, we weren't properly handling browser families. This caused
+`transform-es2015-block-scoping` and other plugins to be incorrectly added for Edge >= 12.
+(s/o to @mgol for the the report and review!)
+
+- Add typed array methods to built-ins features. ([#198](https://github.com/babel/babel-preset-env/pull/198)) (@yavorsky)
+
+Fixes an issue where some TypedArray features were not being polyfilled properly. (s/o to @alippai for the report!)
+
+### :memo: Documentation
+
+- Fixed minor typo in readme ([#199](https://github.com/babel/babel-preset-env/pull/199)) (@bl4ckdu5t)
+- Add built-ins, better links, compat-table url, etc ([#195](https://github.com/babel/babel-preset-env/pull/195)) (@yavorsky)
+- Change CONTRIBUTING.md to use absolute paths ([#194](https://github.com/babel/babel-preset-env/pull/194)) (@aaronang)
+
+### :house: Internal
+
+- Bump plugins ([#201](https://github.com/babel/babel-preset-env/pull/201)) (@yavorsky)
+- Enable code coverage ([#200](https://github.com/babel/babel-preset-env/pull/200)) (@alxpy)
+- Increase mocha timeout to 10s ([#202](https://github.com/babel/babel-preset-env/pull/202)) (@yavorsky)
+
+## v1.2.1 (2017-03-06)
+
+### :bug: Bug Fix
+
+- Add transform-duplicate-keys mapping ([#192](https://github.com/babel/babel-preset-env/pull/192)) (@existentialism)
+
+Our plugin data was missing a mapping for the `transform-duplicate-keys` plugin which caused it to never be included. (s/o to @Timer for the report!)
+
+### :memo: Documentation
+
+- Clarify reasons for the uglify option in README.md ([#188](https://github.com/babel/babel-preset-env/pull/188)) (@mikegreiling)
+
+## v1.2.0 (2017-03-03)
+
+### :rocket: New Feature
+
+- Add uglify as a target ([#178](https://github.com/babel/babel-preset-env/pull/178)) (@yavorsky)
+
+Support for `uglify` as a target is now available! This will enable all plugins and, as a result, fully compiles your code to ES5. Note, that useBuiltIns will work as before, and only the polyfills that your other target(s) need will be included.
+
+```json
+{
+  "presets": [
+    ["env", {
+      "targets": {
+        "chrome": 55,
+        "uglify": true
+      },
+      "useBuiltIns": true,
+      "modules": false
+    }]
+  ]
+}
+```
+
+### :bug: Bug Fix
+
+- Respect older versions in invert equals map ([#180](https://github.com/babel/babel-preset-env/pull/180)) (@danez)
+
+Fixes a number of bugs that caused some incorrect and/or missing environment data when parsing `compat-table`.
+
+## v1.1.11 (2017-03-01)
+
+This release primarily upgrades `compat-table`, which adds support for async on Node 7.6!
+
+### :bug: Bug Fix
+
+- Fix hasBeenWarned condition. ([#175](https://github.com/babel/babel-preset-env/pull/175)) (@yavorsky)
+
+### :memo: Documentation
+
+- Add yarn example. ([#174](https://github.com/babel/babel-preset-env/pull/174)) (@yavorsky)
+
+### :house: Internal
+
+- Bump compat-table ([#177](https://github.com/babel/babel-preset-env/pull/177)) (@existentialism)
+- Add electron version exception test ([#176](https://github.com/babel/babel-preset-env/pull/176)) (@existentialism)
+
+## v1.1.10 (2017-02-24)
+
+### :bug: Bug Fix
+
+- Drop use of lodash/intersection from checkDuplicateIncludeExcludes ([#173](https://github.com/babel/babel-preset-env/pull/173)) (@existentialism)
+
+## v1.1.9 (2017-02-24)
+
+### :bug: Bug Fix
+
+- Add tests for debug output ([#156](https://github.com/babel/babel-preset-env/pull/156)) (@existentialism)
+
+Since we've (mostly @yavorsky) have fixed a number of bugs recently with the `debug` option output, we added the ability to assert stdout matches what we expect. Read the updated [CONTRIBUTING.md](https://github.com/babel/experimental/babel-preset-env/blob/master/CONTRIBUTING.md#testing-the-debug-option) for more info.
+
+- Fixes #143. Log correct targets. ([#155](https://github.com/babel/babel-preset-env/pull/155)) (@yavorsky)
+
+This fixes a bug in the `debug` output where incorrect target(s) were being displayed for why a particular plugin/preset was being included.
+
+Given targets:
+
+```txt
+{
+  "firefox": 52,
+  "node": 7.4
+}
+```
+
+Before:
+
+```txt
+Using plugins:
+  transform-es2015-destructuring {"node":6.5}
+  transform-es2015-for-of {"node":6.5}
+  transform-es2015-function-name {"node":6.5}
+  transform-es2015-literals {"node":4}
+  transform-exponentiation-operator {"firefox":52}
+  syntax-trailing-function-commas {"firefox":52}
+```
+
+After:
+
+```txt
+Using plugins:
+  transform-es2015-destructuring {"firefox":52}
+  transform-es2015-for-of {"firefox":52}
+  transform-es2015-function-name {"firefox":52}
+  transform-es2015-literals {"firefox":52}
+  transform-exponentiation-operator {"node":7.4}
+  syntax-trailing-function-commas {"node":7.4}
+```
+
+### :memo: Documentation
+
+- Fix compat-table link in contributing.md (@existentialism)
+- Update README examples to fix website ([#151](https://github.com/babel/babel-preset-env/pull/)) (@existentialism)
+- Fix few typos ([#146](https://github.com/babel/babel-preset-env/pull/146)) (@existentialism)
+- Add configuration example to clarify `debug: true` ([#138](https://github.com/babel/babel-preset-env/pull/138)) (@yavorsky)
+- Fix CHANGELOG’s v1.1.8 updates typo. ([#136](https://github.com/babel/babel-preset-env/pull/136)) (@yavorsky)
+- README: Update `debug: true` example. ([#138](https://github.com/babel/babel-preset-env/pull/138)) (@yavorsky)
+
+### :house: Internal
+
+- update compat ([#169](https://github.com/babel/babel-preset-env/pull/169)) (@hzoo)
+- Use external Electron to Chromium library ([#144](https://github.com/babel/babel-preset-env/pull/144)) (@Kilian)
+- Update yarn lockfile ([#152](https://github.com/babel/babel-preset-env/pull/152)) (@existentialism)
+- Extract option normalization into independant file ([#125](https://github.com/babel/babel-preset-env/pull/125)) (@baer)
+- Update yarnfile ([#145](https://github.com/babel/babel-preset-env/pull/145)) (@baer)
+- devDeps: eslint-config-babel v5.0.0 ([#139](https://github.com/babel/babel-preset-env/pull/139)) (@kaicataldo)
+- Update compat-table, build data ([#135](https://github.com/babel/babel-preset-env/pull/135)) (@hzoo)
+
+## v1.1.8 (2017-01-10)
+
+### :bug: Bug Fix
+
+- Debug: Transformations before logs. ([#128](https://github.com/babel/babel-preset-env/pull/128)) (@yavorsky)
+
+Makes sure that all transformations on `targets` (such as `exclude`/`include`) are run before logging out with the `debug` option. Fixes ([#127](https://github.com/babel/babel-preset-env/issues/127)).
+
+### :house: Internal
+
+- Remove unnecessary extension. ([#131](https://github.com/babel/babel-preset-env/pull/131)) (@roman-yakobnyuk)
+- Include yarn.lock and update CI. ([#124](https://github.com/babel/babel-preset-env/pull/124)) (@existentialism)
+
+## v1.1.7 (2017-01-09)
+
+Had a publishing issue in the previous release.
+
+## v1.1.6 (2017-01-06)
+
+### :bug: Bug Fix
+
+- Explicitly resolve lowest browser version. ([#121](https://github.com/babel/babel-preset-env/pull/121)) (@brokenmass)
+
+```js
+{
+  "targets": {
+    "browsers": ["ios >= 6"] // was resolving to {ios: 10} rather than {ios: 6}
+  }
+}
+```
+
+## v1.1.5 (2017-01-04)
+
+### :bug: Bug Fix
+
+- Show error if target version is not a number. ([#107](https://github.com/babel/babel-preset-env/pull/107)) (@existentialism)
+
+```js
+{
+  "presets": [
+    ["env", {
+      "targets": {
+        "chrome": "52", // will error since it's not a number,
+        "chrome": 52 // correct!
+      }
+    }]
+  ]
+}
+```
+
+- Fix targets for the `debug` option. ([#109](https://github.com/babel/babel-preset-env/pull/109)) (@yavorsky)
+
+Now it prints the transformed targets/environments rather than the browsers query.
+
+```txt
+Using targets:
+{
+  "chrome": 53,
+  "ie": 10,
+  "node": 6
+}
+
+Modules transform: false
+
+Using plugins:
+  transform-es2015-arrow-functions {"chrome":47,"node":6}
+  transform-es2015-block-scoped-functions {"chrome":41,"ie":11,"node":4}
+
+Using polyfills:
+  es6.typed.uint8-clamped-array {"chrome":5,"node":0.12}
+  es6.map {"chrome":51,"node":6.5}
+```
+
+## v1.1.4 (2016-12-16)
+
+v1.1.2-v1.1.4
+
+### :bug: Bug Fix
+
+The new `exclude`/`include` options weren't working correctly for built-ins. ([#102](https://github.com/babel/babel-preset-env/pull/102)).
+
+Also fixes an issue with debug option.
+
+## v1.1.1 (2016-12-13)
+
+### :bug: Bug Fix
+
+Regression with the previous release due to using `Object.values` (ES2017). This wasn't caught because we are using babel-register to run tests and includes polyfills so it didn't fail on CI even though we have Node 0.10 as an env. Looking into fixing this to prevent future issues.
+
+## v1.1.0 (2016-12-13)
+
+### :rocket: New Feature
+
+- Add `exclude` option, rename `whitelist` to `include` ([#89](https://github.com/babel/babel-preset-env/pull/89)) (@hzoo)
+
+Example:
+
+```js
+{
+  "presets": [
+    ["env", {
+      "targets": {
+        "browsers": ["last 2 versions", "safari >= 7"]
+      },
+      "include": ["transform-es2015-arrow-functions"],
+      "exclude": [
+        "transform-regenerator",
+        "transform-async-to-generator",
+        "map"
+      ],
+      "useBuiltIns": true
+    }]
+  ]
+}
+```
+
+`"exclude": ["transform-regenerator"]` doesn't transform generators and removes `regeneratorRuntime` from being imported.
+
+`"exclude": ["transform-async-to-generator"]` doesn't use the built-in async-to-gen transform so you can use something like [fast-async](https://github.com/MatAtBread/fast-async).
+
+`"exclude": ["map"]` doesn't include the `Map` polyfill if you know you aren't using it in your code (w/ `useBuiltIns`). (We will figure out a way to automatically do this [#84](https://github.com/babel/babel-preset-env/issues/84)).
+
+If you pass a wrong plugin it will error: valid options for `include/exclude` are in [/data/plugin-features.js](https://github.com/babel/experimental/babel-preset-env/blob/master/data/plugin-features.js) and [/data/built-in-features.js](https://github.com/babel/experimental/babel-preset-env/blob/master/data/built-in-features.js) (without the `es6.`)
+
+### :house: Internal
+
+- Optimize result filtration. ([#77](https://github.com/babel/babel-preset-env/pull/77)) (@yavorsky)
+- Update eslint config to align with other babel projects ([#79](https://github.com/babel/babel-preset-env/pull/79)) (@baer)
+- Update pathnames to avoid uppercase ([#80](https://github.com/babel/babel-preset-env/pull/80)) (@baer)
+- Refactor build data for clarity/consistency ([#81](https://github.com/babel/babel-preset-env/pull/81)) (@baer)
+- Update linting rules to cover all js ([#82](https://github.com/babel/babel-preset-env/pull/82)) (@baer)
+- Cleanup lib before rebuilding ([#87](https://github.com/babel/babel-preset-env/pull/87)) (@baer)
+- Move linting dependency to be dev only ([#88](https://github.com/babel/babel-preset-env/pull/88)) (@baer)
+
+### :memo: Documentation
+
+- Fix typo ([#78](https://github.com/babel/babel-preset-env/pull/78)) (@rohmanhm)
+- Fix PR link in changelog. ([#75](https://github.com/babel/babel-preset-env/pull/75)) (@nhajidin)
+
+## v1.0.2 (2016-12-10)
+
+### :bug: Bug Fix
+
+* Fix issue with Object.getOwnPropertySymbols ([#71](https://github.com/babel/babel-preset-env/pull/71)) ([@existentialism](https://github.com/existentialism))
+
+Was requiring the wrong module kinda of like in v1.0.1:
+
+https://github.com/zloirock/core-js#ecmascript-6-symbol
+
+```diff
+-import "core-js/modules/es6.object.get-own-property-symbols";
+```
+
+The test is just a part of `Symbol`.
+
+## v1.0.1 (2016-12-10)
+
+### :bug: Bug Fix
+
+* Fix regenerator import ([#68](https://github.com/babel/babel-preset-env/pull/68)) ([@hzoo](https://github.com/hzoo))
+
+We were outputting an invalid path for `regenerator`!
+
+```diff
++import "regenerator-runtime/runtime";
+-import "core-js/modules/regenerator-runtime/runtime"-
+```
+
+## v1.0.0 (2016-12-09)
+
+### :rocket: New Feature
+
+* Add `useBuiltIns` option ([#56](https://github.com/babel/babel-preset-env/pull/56)) ([@hzoo](https://github.com/hzoo)), ([@yavorsky](https://github.com/yavorsky)), ([@existentialism](https://github.com/existentialism))
+
+A way to apply `babel-preset-env` for polyfills (via `"babel-polyfill"``).
+
+> This option will apply a new Babel plugin that replaces `require("babel-polyfill")` with the individual requires for `babel-polyfill` based on the target environments.
+
+Install
+
+```
+npm install babel-polyfill --save
+```
+
+In
+
+```js
+import "babel-polyfill"; // create an entry js file that contains this
+// or
+import "core-js";
+```
+
+Out (different based on environment)
+
+```js
+// chrome 55
+import "core-js/modules/es7.string.pad-start"; // haha left_pad
+import "core-js/modules/es7.string.pad-end";
+import "core-js/modules/web.timers";
+import "core-js/modules/web.immediate";
+import "core-js/modules/web.dom.iterable";
+```
+
+`.babelrc` Usage
+
+```js
+{
+  "presets": [
+    ["env", {
+      "targets": {
+        "electron": 1.4
+      },
+      "modules": false, // webpack 2
+      "useBuiltIns": true // new option
+    }]
+  ]
+}
+```
+
+> Also looking to make an easier integration point via Webpack with this method. Please reach out if you have ideas!
+
+---
+
+* Support [Electron](http://electron.atom.io/) ([#55](https://github.com/babel/babel-preset-env/pull/55)) ([@paulcbetts](https://github.com/paulcbetts))
+
+Electron is also an environment, so [Paul went ahead](https://twitter.com/paulcbetts/status/804507070103851008) and added support for this!
+
+`.babelrc` Usage
+
+```js
+{
+  "presets": [ ["env", {"targets": { "electron": 1.4 }}]]
+}
+```
+
+> Currently we are manually updating the data in [/data/electron-to-chromium.js](https://github.com/babel/experimental/babel-preset-env/blob/master/data/electron-to-chromium.js), but [@kevinsawicki](https://github.com/kevinsawicki) says we could generate the data from [atom-shell/dist/index.json](https://gh-contractor-zcbenz.s3.amazonaws.com/atom-shell/dist/index.json) as well! (Someone should make a PR :smile:)
+
+
+
+## v0.0.9 (2016-11-24)
+
+### :rocket: New Feature
+
+* Support Opera ([#48](https://github.com/babel/babel-preset-env/pull/48)) (Henry Zhu)
+
+Was as simple as modifying the chrome version and subtracting 13! (so chrome 54 = opera 41)
+
+```js
+{
+  "presets": [
+    ["env", {
+      "targets": {
+        "opera": 41
+      }
+    }]
+  ]
+}
+```
+
+## v0.0.8 (2016-11-16)
+
+### :nail_care: Polish
+
+* Only print the debug info once ([#46](https://github.com/babel/babel-preset-env/pull/46) (Henry Zhu)
+
+When using the `debug` option it was printing the data for each file processed rather than once.
+
+```js
+{
+  "presets": [
+    ["env", {
+      "debug": true
+    }]
+  ]
+}
+```
+
+## v0.0.7 (2016-11-02)
+
+### :rocket: New Feature
+
+* hardcode a current node version option ([#35](https://github.com/babel/babel-preset-env/pull/35)) (Henry Zhu)
+
+```js
+{
+  "presets": [
+    ["env", {
+      "targets": {
+        "node": "current" // parseFloat(process.versions.node)
+      }
+    }]
+  ]
+}
+```
+
+* add 'whitelist' option ([#31](https://github.com/babel/babel-preset-env/pull/31)) (Henry Zhu)
+
+```js
+ {
+  "presets": [
+    ["env", {
+      "targets": {
+        "chrome": 52
+      },
+      "whitelist": ["transform-es2015-arrow-functions"]
+    }]
+  ]
+}
+```
+
+* Add more aliases (Henry Zhu)
+* Update plugin data: firefox 52 supports async/await! ([#29](https://github.com/babel/babel-preset-env/pull/29)) (Henry Zhu)
+
+### :bug: Bug Fixes
+
+* Use compat-table equals option ([#36](https://github.com/babel/babel-preset-env/pull/36)) (Henry Zhu)
+
+Compute and use `compat-table` equivalents
+
+```js
+{
+  "safari6": "phantom",
+  "chrome44": "iojs",
+  "chrome50": "node64",
+  "chrome51": "node65",
+  "chrome54": "node7",
+  "chrome30": "android44",
+  "chrome37": "android50",
+  "chrome39": "android51",
+  "safari7": "ios7",
+  "safari71_8": "ios8",
+  "safari9": "ios9",
+  "safari10": "ios10",
+  "chrome50": "node6"
+}
+```
+
+* Change default behavior to act the same as babel-preset-latest ([#33](https://github.com/babel/babel-preset-env/pull/33)) (Henry Zhu)
+
+```js
+{ "presets": ["env"] } // should act the same as babel-preset-latest
+```
+
+## Internal
+
+* Add fixture helper for tests ([#28](https://github.com/babel/babel-preset-env/pull/28)) (Henry Zhu)
diff --git a/node_modules/@babel/preset-env/CONTRIBUTING.md b/node_modules/@babel/preset-env/CONTRIBUTING.md
new file mode 100644
index 00000000..5b485a69
--- /dev/null
+++ b/node_modules/@babel/preset-env/CONTRIBUTING.md
@@ -0,0 +1,93 @@
+# Contributing
+
+## Adding a new plugin to support (when approved in the next ECMAScript version)
+
+### Update [`plugin-features.js`](https://github.com/babel/babel/blob/master/packages/babel-preset-env/data/plugin-features.js)
+
+*Example:*
+
+If you were going to add `**` which is in ES2016:
+
+Find the relevant entries on [compat-table](https://kangax.github.io/compat-table/es2016plus/#test-exponentiation_(**)_operator):
+
+`exponentiation (**) operator`
+
+Find the corresponding babel plugin:
+
+`@babel/plugin-transform-exponentiation-operator`
+
+And add them in this structure:
+
+```js
+// es2016
+"@babel/plugin-transform-exponentiation-operator": {
+  features: [
+    "exponentiation (**) operator",
+  ],
+},
+```
+
+### Update [`built-in-features.js`](https://github.com/babel/babel/blob/master/packages/babel-preset-env/data/built-in-features.js)
+
+*Example:*
+
+In case you want to add `Object.values` which is in ES2017:
+
+Find the relevant feature and subfeature on [compat-table](https://kangax.github.io/compat-table/es2016plus/#test-Object_static_methods_Object.values)
+and split it with `/`:
+
+`Object static methods / Object.values`
+
+Find the corresponding module on [core-js](https://github.com/zloirock/core-js/tree/master/modules):
+
+`es7.object.values.js`
+
+Find required ES version in [`built-in-features.js`](https://github.com/babel/babel/blob/master/packages/babel-preset-env/data/built-in-features.js) and add the new feature:
+
+```js
+const es2017 = {
+  //...
+  "es7.object.values": "Object static methods / Object.values"
+}
+```
+
+### Update [`plugins.json`](https://github.com/babel/babel/blob/master/packages/babel-preset-env/data/plugins.json)
+
+Until `compat-table` is a standalone npm module for data we are using the git url
+
+`"compat-table": "kangax/compat-table#[latest-commit-hash]"`,
+
+So we update and then run `npm run build-data`. If there are no changes, then `plugins.json` will be the same.
+
+## Tests
+
+### Running tests locally
+
+```bash
+npm test
+```
+
+### Checking code coverage locally
+
+```bash
+npm run coverage
+```
+
+### Writing tests
+
+#### General
+
+All the tests for `@babel/preset-env` exist in the `test/fixtures` folder. The
+test setup and conventions are exactly the same as testing a Babel plugin, so
+please read our [documentation on writing tests](https://github.com/babel/babel/blob/master/CONTRIBUTING.md#babel-plugin-x).
+
+#### Testing the `debug` option
+
+Testing debug output to `stdout` is similar. Under the `test/debug-fixtures`,
+create a folder with a descriptive name of your test, and add the following:
+
+* Add a `options.json` file (just as the other tests, this is essentially a
+`.babelrc`) with the desired test configuration (required)
+* Add a `stdout.txt` file with the expected debug output. For added
+convenience, if there is no `stdout.txt` present, the test runner will
+generate one for you.
diff --git a/node_modules/@babel/preset-env/README.md b/node_modules/@babel/preset-env/README.md
new file mode 100644
index 00000000..372b5a0c
--- /dev/null
+++ b/node_modules/@babel/preset-env/README.md
@@ -0,0 +1,598 @@
+# @babel/preset-env [![npm](https://img.shields.io/npm/v/babel-preset-env.svg)](https://www.npmjs.com/package/babel-preset-env) [![travis](https://img.shields.io/travis/babel/babel-preset-env/master.svg)](https://travis-ci.org/babel/babel-preset-env) [![npm-downloads](https://img.shields.io/npm/dm/babel-preset-env.svg)](https://www.npmjs.com/package/babel-preset-env) [![codecov](https://img.shields.io/codecov/c/github/babel/babel-preset-env/master.svg?maxAge=43200)](https://codecov.io/github/babel/babel-preset-env)
+
+> A Babel preset that compiles [ES2015+](https://github.com/tc39/proposals/blob/master/finished-proposals.md) down to ES5 by automatically determining the Babel plugins and polyfills you need based on your targeted browser or runtime environments.
+
+```sh
+npm install @babel/preset-env --save-dev
+```
+
+Without any configuration options, `@babel/preset-env` behaves exactly the same as [`@babel/preset-es2015`](https://github.com/babel/babel/tree/master/packages/babel-preset-es2015), [`@babel/preset-es2016`](https://github.com/babel/babel/tree/master/packages/babel-preset-es2016) and [`@babel/preset-es2017`](https://github.com/babel/babel/tree/master/packages/babel-preset-es2017) together (or the deprecated `babel-preset-latest`).
+
+> We don't recommend using `preset-env` this way because it doesn't take advantage of its ability to target specific browsers.
+
+```json
+{
+  "presets": ["@babel/preset-env"]
+}
+```
+
+You can also configure it to only include the polyfills and transforms needed for the browsers you support. Compiling only what's needed can make your bundles smaller and your life easier.
+
+If you want to specify target browsers, we recommend using a [`.browserslistrc`](https://github.com/browserslist/browserslist) config, which is also used by many tools including Autoprefixer.
+
+For example, to only include polyfills and code transforms needed for users whose browsers have >0.25% market share (ignoring browsers without security updates like IE 10 and BlackBerry):
+
+```
+> 0.25%
+not dead
+```
+
+The full list of queries could be found in [Browserslist docs](https://github.com/browserslist/browserslist#queries).
+
+If you need to use different browsers for Babel, you can also specify Browserslist queries in the [targets.browsers option](https://github.com/babel/babel/tree/master/packages/babel-preset-env#targetsbrowsers) in your Babel config.
+
+You may also target browsers supporting ES Modules (https://www.ecma-international.org/ecma-262/6.0/#sec-modules). When specifying this option, the browsers field will be ignored. You can use this approach in combination with `<script type="module"></script>` to conditionally serve smaller scripts to users (https://jakearchibald.com/2017/es-modules-in-browsers/#nomodule-for-backwards-compatibility).
+
+*Please note*: when specifying the esmodules target, browsers targets will be ignored.
+
+```json
+{
+  "presets": [
+    ["@babel/preset-env", {
+      "targets": {
+        "esmodules": true
+      }
+    }]
+  ]
+}
+```
+
+Similarly, if you're targeting Node.js instead of the browser, you can configure `@babel/preset-env` to only include the polyfills and transforms necessary for a particular version:
+
+```json
+{
+  "presets": [
+    ["@babel/preset-env", {
+      "targets": {
+        "node": "6.10"
+      }
+    }]
+  ]
+}
+```
+
+For convenience, you can use `"node": "current"` to only include the necessary polyfills and transforms for the Node.js version that you use to run Babel:
+
+```json
+{
+  "presets": [
+    ["@babel/preset-env", {
+      "targets": {
+        "node": "current"
+      }
+    }]
+  ]
+}
+```
+
+- [How it Works](#how-it-works)
+- [Install](#install)
+- [Usage](#usage)
+- [Options](#options)
+- [Examples](#examples)
+- [Issues](#issues)
+
+## How it Works
+
+### Determine environment support for ECMAScript features
+
+Use external data such as [`compat-table`](https://github.com/kangax/compat-table) to determine browser support. (We should create PRs there when necessary)
+
+![](https://cloud.githubusercontent.com/assets/588473/19214029/58deebce-8d48-11e6-9004-ee3fbcb75d8b.png)
+
+We can periodically run [build-data.js](https://github.com/babel/babel/blob/master/packages/babel-preset-env/scripts/build-data.js) which generates [plugins.json](https://github.com/babel/babel/blob/master/packages/babel-preset-env/data/plugins.json).
+
+Ref: [#7](https://github.com/babel/babel-preset-env/issues/7)
+
+### Maintain a mapping between JavaScript features and Babel plugins
+
+> Currently located at [plugin-features.js](https://github.com/babel/babel/blob/master/packages/babel-preset-env/data/plugin-features.js).
+
+This should be straightforward to do in most cases. There might be cases where plugins should be split up more or certain plugins aren't standalone enough (or impossible to do).
+
+### Support all plugins in Babel that are considered `latest`
+
+> Default behavior without options is the same as `@babel/preset-latest`.
+
+It won't include `stage-x` plugins. env will support all plugins in what we consider the latest version of JavaScript (by matching what we do in [`@babel/preset-latest`](http://babeljs.io/docs/plugins/preset-latest/)).
+
+Ref: [#14](https://github.com/babel/babel-preset-env/issues/14)
+
+### Determine the lowest common denominator of plugins to be included in the preset
+
+If you are targeting IE 8 and Chrome 55 it will include all plugins required by IE 8 since you would need to support both still.
+
+### Support a target option `"node": "current"` to compile for the currently running node version.
+
+For example, if you are building on Node 6, arrow functions won't be converted, but they will if you build on Node 0.12.
+
+### Support a `browsers` option like autoprefixer.
+
+Use [browserslist](https://github.com/ai/browserslist) to declare supported environments by performing queries like `> 1%, last 2 versions`.
+
+Ref: [#19](https://github.com/babel/babel-preset-env/pull/19)
+
+### Browserslist support.
+
+[Browserslist](https://github.com/ai/browserslist) is a library used to share a supported list of browsers between different front-end tools like [autoprefixer](https://github.com/postcss/autoprefixer), [stylelint](https://stylelint.io/), [eslint-plugin-compat](https://github.com/amilajack/eslint-plugin-compat) and many others.
+
+By default, @babel/preset-env will use [browserslist config sources](https://github.com/ai/browserslist#queries).
+
+For example, to enable only the polyfills and plugins needed for a project targeting *last 2 versions* and *IE10*:
+
+**.babelrc**
+```json
+{
+  "presets": [
+    ["@babel/preset-env", {
+      "useBuiltIns": "entry"
+    }]
+  ]
+}
+```
+
+**browserslist**
+```
+Last 2 versions
+IE 10
+```
+
+or
+
+**package.json**
+```
+"browserslist": "last 2 versions, ie 10"
+```
+
+Browserslist config will be ignored if: 1) `targets.browsers` was specified 2) or with `ignoreBrowserslistConfig: true` option ([see more](#ignoreBrowserslistConfig)):
+
+#### Targets merging.
+
+1. If [targets.browsers](#targetsbrowsers) is defined - the browserslist config will be ignored. The browsers specified in `targets` will be merged with [any other explicitly defined targets](#targets). If merged, targets defined explicitly will override the same targets received from `targets.browsers`.
+
+2. If [targets.browsers](#targetsbrowsers) is _not_ defined - the program will search browserslist file or `package.json` with `browserslist` field. The search will start from the working directory of the process or from the path specified by the `configPath` option, and go up to the system root. If both a browserslist file and configuration inside a `package.json` are found, an exception will be thrown.
+
+3. If a browserslist config was found and other targets are defined (but not [targets.browsers](#targetsbrowsers)), the targets will be merged in the same way as `targets` defined explicitly with `targets.browsers`.
+
+## Install
+
+With [npm](https://www.npmjs.com):
+
+```sh
+npm install --save-dev @babel/preset-env
+```
+
+Or [yarn](https://yarnpkg.com):
+
+```sh
+yarn add @babel/preset-env --dev
+```
+
+## Usage
+
+The default behavior without options runs all transforms (behaves the same as [@babel/preset-latest](https://babeljs.io/docs/plugins/preset-latest/)).
+
+```json
+{
+  "presets": ["@babel/preset-env"]
+}
+```
+
+## Options
+
+For more information on setting options for a preset, refer to the [plugin/preset options](http://babeljs.io/docs/plugins/#plugin-preset-options) documentation.
+
+### `targets`
+
+`{ [string]: number | string }`, defaults to `{}`.
+
+Takes an object of environment versions to support.
+
+Each target environment takes a number or a string (we recommend using a string when specifying minor versions like `node: "6.10"`). You can also specify `tp` (technology preview) version for Safari.
+
+Example environments: `chrome`, `opera`, `edge`, `firefox`, `safari`, `ie`, `ios`, `android`, `node`, `electron`.
+
+The [data](https://github.com/babel/babel/blob/master/packages/babel-preset-env/data/plugins.json) for this is generated by running the [build-data script](https://github.com/babel/babel/blob/master/packages/babel-preset-env/scripts/build-data.js) which pulls in data from [compat-table](https://kangax.github.io/compat-table).
+
+### `targets.node`
+
+`number | string | "current" | true`
+
+If you want to compile against the current node version, you can specify `"node": true` or `"node": "current"`, which would be the same as `"node": process.versions.node`.
+
+### `targets.browsers`
+
+`Array<string> | string`
+
+A query to select browsers (ex: last 2 versions, > 5%, safari tp) using [browserslist](https://github.com/ai/browserslist).
+
+Note, browsers' results are overridden by explicit items from `targets`.
+
+### `spec`
+
+`boolean`, defaults to `false`.
+
+Enable more spec compliant, but potentially slower, transformations for any plugins in this preset that support them.
+
+### `loose`
+
+`boolean`, defaults to `false`.
+
+Enable ["loose" transformations](http://2ality.com/2015/12/babel6-loose-mode.html) for any plugins in this preset that allow them.
+
+### `modules`
+
+`"amd" | "umd" | "systemjs" | "commonjs" | "cjs" | false`, defaults to `"commonjs"`.
+
+Enable transformation of ES6 module syntax to another module type.
+
+Setting this to `false` will not transform modules.
+
+### `debug`
+
+`boolean`, defaults to `false`.
+
+Outputs the targets/plugins used and the version specified in [plugin data version](https://github.com/babel/babel/blob/master/packages/babel-preset-env/data/plugins.json) to `console.log`.
+
+### `include`
+
+`Array<string|RegExp>`, defaults to `[]`.
+
+An array of plugins to always include.
+
+Valid options include any:
+
+- [Babel plugins](https://github.com/babel/babel/blob/master/packages/babel-preset-env/data/plugin-features.js) - both with (`@babel/plugin-transform-spread`) and without prefix (`plugin-transform-spread`) are supported.
+
+- [Built-ins](https://github.com/babel/babel/blob/master/packages/babel-preset-env/data/built-in-features.js), such as `es6.map`, `es6.set`, or `es6.object.assign`.
+
+Plugin names can be fully or partially specified (or using `RegExp`).
+
+Acceptable inputs:
+
+- Full name (`string`): `"es6.math.sign"`
+- Partial name (`string`): `"es6.math.*"` (resolves to all plugins with `es6.math` prefix)
+- `RegExp` Object: `/^transform-.*$/` or `new RegExp("^transform-modules-.*")`
+
+Note that the above `.` is the `RegExp` equivalent to match any character, and not the actual `'.'` character. Also note that to match any character `.*` is used in `RegExp` as opposed to `*` in `glob` format.
+
+This option is useful if there is a bug in a native implementation, or a combination of a non-supported feature + a supported one doesn't work.
+
+For example, Node 4 supports native classes but not spread. If `super` is used with a spread argument, then the `@babel/plugin-transform-classes` transform needs to be `include`d, as it is not possible to transpile a spread with `super` otherwise.
+
+> NOTE: The `include` and `exclude` options _only_ work with the [plugins included with this preset](https://github.com/babel/babel/blob/master/packages/babel-preset-env/data/plugin-features.js); so, for example, including `@babel/plugin-proposal-do-expressions` or excluding `@babel/plugin-proposal-function-bind` will throw errors. To use a plugin _not_ included with this preset, add them to your [config](https://babeljs.io/docs/usage/babelrc/) directly.
+
+### `exclude`
+
+`Array<string|RegExp>`, defaults to `[]`.
+
+An array of plugins to always exclude/remove.
+
+The possible options are the same as the `include` option.
+
+This option is useful for "blacklisting" a transform like `@babel/plugin-transform-regenerator` if you don't use generators and don't want to include `regeneratorRuntime` (when using `useBuiltIns`) or for using another plugin like [fast-async](https://github.com/MatAtBread/fast-async) instead of [Babel's async-to-gen](http://babeljs.io/docs/plugins/proposal-async-generator-functions/).
+
+### `useBuiltIns`
+
+`"usage"` | `"entry"` | `false`, defaults to `false`.
+
+A way to apply `@babel/preset-env` for polyfills (via `@babel/polyfill`).
+
+```sh
+npm install @babel/polyfill --save
+```
+
+#### `useBuiltIns: 'usage'`
+
+Adds specific imports for polyfills when they are used in each file. We take advantage of the fact that a bundler will load the same polyfill only once.
+
+**In**
+
+a.js
+
+```js
+var a = new Promise();
+```
+
+b.js
+
+```js
+var b = new Map();
+```
+
+**Out (if environment doesn't support it)**
+
+```js
+import "core-js/modules/es6.promise";
+var a = new Promise();
+```
+
+```js
+import "core-js/modules/es6.map";
+var b = new Map();
+```
+
+**Out (if environment supports it)**
+
+```js
+var a = new Promise();
+```
+
+```js
+var b = new Map();
+```
+
+#### `useBuiltIns: 'entry'`
+
+> NOTE: Only use `require("@babel/polyfill");` once in your whole app.
+> Multiple imports or requires of `@babel/polyfill` will throw an error since it can cause global collisions and other issues that are hard to trace.
+> We recommend creating a single entry file that only contains the `require` statement.
+
+This option enables a new plugin that replaces the statement `import "@babel/polyfill"` or `require("@babel/polyfill")` with individual requires for `@babel/polyfill` based on environment.
+
+**In**
+
+```js
+import "@babel/polyfill";
+```
+
+**Out (different based on environment)**
+
+```js
+import "core-js/modules/es7.string.pad-start";
+import "core-js/modules/es7.string.pad-end";
+```
+
+This will also work for `core-js` directly (`import "core-js";` or `require('core-js');`)
+
+#### `useBuiltIns: false`
+
+Don't add polyfills automatically per file, or transform `import "@babel/polyfill"` to individual polyfills.
+
+### `forceAllTransforms`
+
+`boolean`, defaults to `false`.
+
+<p><details>
+  <summary><b>Example</b></summary>
+
+  With Babel 7's .babelrc.js support, you can force all transforms to be run if env is set to `production`.
+
+  ```js
+  module.exports = {
+    presets: [
+      ["@babel/preset-env", {
+        targets: {
+          chrome: 59,
+          edge: 13,
+          firefox: 50,
+        },
+        // for uglifyjs...
+        forceAllTransforms: process.env === "production"
+      }],
+    ],
+  };
+  ```
+</details></p>
+
+
+> NOTE: `targets.uglify` is deprecated and will be removed in the next major in
+favor of this.
+
+By default, this preset will run all the transforms needed for the targeted
+environment(s). Enable this option if you want to force running _all_
+transforms, which is useful if the output will be run through UglifyJS or an
+environment that only supports ES5.
+
+> NOTE: Uglify has a work-in-progress "Harmony" branch to address the lack of
+ES6 support, but it is not yet stable.  You can follow its progress in
+[UglifyJS2 issue #448](https://github.com/mishoo/UglifyJS2/issues/448).  If you
+require an alternative minifier which _does_ support ES6 syntax, we recommend
+using [babel-minify](https://github.com/babel/minify).
+
+### `configPath`
+
+`string`, defaults to `process.cwd()`
+
+The starting point where the config search for browserslist will start, and ascend to the system root until found.
+
+### `ignoreBrowserslistConfig`
+
+`boolean`, defaults to `false`
+
+Toggles whether or not [browserslist config sources](https://github.com/ai/browserslist#queries) are used, which includes searching for any browserslist files or referencing the browserslist key inside package.json. This is useful for projects that use a browserslist config for files that won't be compiled with Babel.
+
+### `shippedProposals`
+
+`boolean`, defaults to `false`
+
+Toggles enabling support for builtin/feature proposals that have shipped in browsers. If your target environments have native support for a feature proposal, its matching parser syntax plugin is enabled instead of performing any transform. Note that this _does not_ enable the same transformations as [`@babel/preset-stage-3`](https://babeljs.io/docs/plugins/preset-stage-3/), since proposals can continue to change before landing in browsers.
+
+The following are currently supported:
+
+**Builtins**
+
+- None
+
+**Features**
+
+- [Optional catch binding](https://github.com/tc39/proposal-optional-catch-binding)
+
+---
+
+## Examples
+
+### Export with various targets
+
+```js
+export class A {}
+```
+
+#### Target only Chrome 52
+
+**.babelrc**
+
+```json
+{
+  "presets": [
+    ["@babel/preset-env", {
+      "targets": {
+        "chrome": 52
+      }
+    }]
+  ]
+}
+```
+
+**Out**
+
+```js
+class A {}
+exports.A = A;
+```
+
+#### Target Chrome 52 with webpack 2/rollup and loose mode
+
+**.babelrc**
+
+```json
+{
+  "presets": [
+    ["@babel/preset-env", {
+      "targets": {
+        "chrome": 52
+      },
+      "modules": false,
+      "loose": true
+    }]
+  ]
+}
+```
+
+**Out**
+
+```js
+export class A {}
+```
+
+#### Target specific browsers via browserslist
+
+**.babelrc**
+
+```json
+{
+  "presets": [
+    ["@babel/preset-env", {
+      "targets": {
+        "chrome": 52,
+        "browsers": ["last 2 versions", "safari 7"]
+      }
+    }]
+  ]
+}
+```
+
+**Out**
+
+```js
+export var A = function A() {
+  _classCallCheck(this, A);
+};
+```
+
+#### Target latest node via `node: true` or `node: "current"`
+
+**.babelrc**
+
+```json
+{
+  "presets": [
+    ["@babel/preset-env", {
+      "targets": {
+        "node": "current"
+      }
+    }]
+  ]
+}
+```
+
+**Out**
+
+```js
+class A {}
+exports.A = A;
+```
+
+### Show debug output
+
+**.babelrc**
+
+```json
+{
+  "presets": [
+    ["@babel/preset-env", {
+      "targets": {
+        "safari": 10
+      },
+      "modules": false,
+      "useBuiltIns": "entry",
+      "debug": true
+    }]
+  ]
+}
+```
+
+**stdout**
+
+```sh
+Using targets:
+{
+  "safari": 10
+}
+
+Modules transform: false
+
+Using plugins:
+  @babel/plugin-transform-exponentiation-operator {}
+  @babel/plugin-transform-async-to-generator {}
+
+Using polyfills:
+  es7.object.values {}
+  es7.object.entries {}
+  es7.object.get-own-property-descriptors {}
+  web.timers {}
+  web.immediate {}
+  web.dom.iterable {}
+```
+
+### Include and exclude specific plugins/built-ins
+
+> always include arrow functions, explicitly exclude generators
+
+```json
+{
+  "presets": [
+    ["@babel/preset-env", {
+      "targets": {
+        "browsers": ["last 2 versions", "safari >= 7"]
+      },
+      "include": ["@babel/plugin-transform-arrow-functions", "es6.map"],
+      "exclude": ["@babel/plugin-transform-regenerator", "es6.set"]
+    }]
+  ]
+}
+```
+
+## Issues
+
+If you get a `SyntaxError: Unexpected token ...` error when using the [object-rest-spread](https://github.com/babel/babel/tree/master/packages/babel-plugin-proposal-object-rest-spread) transform then make sure the plugin has been updated to, at least, `v6.19.0`.
diff --git a/node_modules/@babel/preset-env/data/built-in-features.js b/node_modules/@babel/preset-env/data/built-in-features.js
new file mode 100644
index 00000000..89d4474d
--- /dev/null
+++ b/node_modules/@babel/preset-env/data/built-in-features.js
@@ -0,0 +1,331 @@
+const typedArrayMethods = [
+  "typed arrays / %TypedArray%.from",
+  "typed arrays / %TypedArray%.of",
+  "typed arrays / %TypedArray%.prototype.subarray",
+  "typed arrays / %TypedArray%.prototype.join",
+  "typed arrays / %TypedArray%.prototype.indexOf",
+  "typed arrays / %TypedArray%.prototype.lastIndexOf",
+  "typed arrays / %TypedArray%.prototype.slice",
+  "typed arrays / %TypedArray%.prototype.every",
+  "typed arrays / %TypedArray%.prototype.filter",
+  "typed arrays / %TypedArray%.prototype.forEach",
+  "typed arrays / %TypedArray%.prototype.map",
+  "typed arrays / %TypedArray%.prototype.reduce",
+  "typed arrays / %TypedArray%.prototype.reduceRight",
+  "typed arrays / %TypedArray%.prototype.reverse",
+  "typed arrays / %TypedArray%.prototype.some",
+  "typed arrays / %TypedArray%.prototype.sort",
+  "typed arrays / %TypedArray%.prototype.copyWithin",
+  "typed arrays / %TypedArray%.prototype.find",
+  "typed arrays / %TypedArray%.prototype.findIndex",
+  "typed arrays / %TypedArray%.prototype.fill",
+  "typed arrays / %TypedArray%.prototype.keys",
+  "typed arrays / %TypedArray%.prototype.values",
+  "typed arrays / %TypedArray%.prototype.entries",
+  "typed arrays / %TypedArray%.prototype[Symbol.iterator]",
+  "typed arrays / %TypedArray%[Symbol.species]",
+];
+
+const es = {
+  // compat-table missing babel6 mapping
+  // "es6.array.concat": {
+  //   features: [
+  //     "well-known symbols / Symbol.isConcatSpreadable",
+  //     "well-known symbols / Symbol.species, Array.prototype.concat",
+  //   ]
+  // },
+  "es6.array.copy-within": "Array.prototype methods / Array.prototype.copyWithin",
+  "es6.array.every": "Array methods / Array.prototype.every",
+  "es6.array.fill": "Array.prototype methods / Array.prototype.fill",
+  "es6.array.filter": {
+    features: [
+      "Array methods / Array.prototype.filter",
+      // compat-table missing babel6 mapping
+      // "well-known symbols / Symbol.species, Array.prototype.filter",
+    ],
+  },
+  "es6.array.find": "Array.prototype methods / Array.prototype.find",
+  "es6.array.find-index": "Array.prototype methods / Array.prototype.findIndex",
+  "es6.array.for-each": "Array methods / Array.prototype.forEach",
+  "es6.array.from": "Array static methods / Array.from",
+  "es7.array.includes": "Array.prototype.includes",
+  "es6.array.index-of": "Array methods / Array.prototype.indexOf",
+  "es6.array.is-array": "Array methods / Array.isArray",
+  // "es.array.join": "", required tests for that
+  "es6.array.iterator": {
+    features: [
+      "Array.prototype methods / Array.prototype.keys",
+      // can use Symbol.iterator, not implemented in many environments
+      // "Array.prototype methods / Array.prototype.values",
+      "Array.prototype methods / Array.prototype.entries",
+    ],
+  },
+  "es6.array.last-index-of": "Array methods / Array.prototype.lastIndexOf",
+  "es6.array.map": {
+    features: [
+      "Array methods / Array.prototype.map",
+      // compat-table missing babel6 mapping
+      // "well-known symbols / Symbol.species, Array.prototype.map",
+    ],
+  },
+  "es6.array.of": "Array static methods / Array.of",
+  "es6.array.reduce": "Array methods / Array.prototype.reduce",
+  "es6.array.reduce-right": "Array methods / Array.prototype.reduceRight",
+  // compat-table missing babel6 mapping
+  // "es6.array.slice": "well-known symbols / Symbol.species, Array.prototype.slice",
+  "es6.array.some": "Array methods / Array.prototype.some",
+  "es6.array.sort": "Array methods / Array.prototype.sort",
+  "es6.array.species": "Array static methods / Array[Symbol.species]",
+  // compat-table missing babel6 mapping
+  //"es6.array.splice": "well-known symbols / Symbol.species, Array.prototype.splice",
+
+  "es6.date.now": "Date methods / Date.now",
+  "es6.date.to-iso-string": "Date methods / Date.prototype.toISOString",
+  "es6.date.to-json": "Date methods / Date.prototype.toJSON",
+  "es6.date.to-primitive": "Date.prototype[Symbol.toPrimitive]",
+  "es6.date.to-string": "miscellaneous / Invalid Date",
+
+  "es6.function.bind": "Function.prototype.bind",
+  "es6.function.has-instance": "well-known symbols / Symbol.hasInstance",
+  "es6.function.name": {
+    features: [
+      "function \"name\" property / function statements",
+      "function \"name\" property / function expressions",
+    ],
+  },
+
+  "es6.map": "Map",
+
+  "es6.math.acosh": "Math methods / Math.acosh",
+  "es6.math.asinh": "Math methods / Math.asinh",
+  "es6.math.atanh": "Math methods / Math.atanh",
+  "es6.math.cbrt": "Math methods / Math.cbrt",
+  "es6.math.clz32": "Math methods / Math.clz32",
+  "es6.math.cosh": "Math methods / Math.cosh",
+  "es6.math.expm1": "Math methods / Math.expm1",
+  "es6.math.fround": "Math methods / Math.fround",
+  "es6.math.hypot": "Math methods / Math.hypot",
+  "es6.math.imul": "Math methods / Math.imul",
+  "es6.math.log1p": "Math methods / Math.log1p",
+  "es6.math.log10": "Math methods / Math.log10",
+  "es6.math.log2": "Math methods / Math.log2",
+  "es6.math.sign": "Math methods / Math.sign",
+  "es6.math.sinh": "Math methods / Math.sinh",
+  "es6.math.tanh": "Math methods / Math.tanh",
+  "es6.math.trunc": "Math methods / Math.trunc",
+
+  "es6.number.constructor": {
+    features: [
+      "octal and binary literals / octal supported by Number()",
+      "octal and binary literals / binary supported by Number()",
+    ],
+  },
+  "es6.number.epsilon": "Number properties / Number.EPSILON",
+  "es6.number.is-finite": "Number properties / Number.isFinite",
+  "es6.number.is-integer": "Number properties / Number.isInteger",
+  "es6.number.is-nan": "Number properties / Number.isNaN",
+  "es6.number.is-safe-integer": "Number properties / Number.isSafeInteger",
+  "es6.number.max-safe-integer": "Number properties / Number.MAX_SAFE_INTEGER",
+  "es6.number.min-safe-integer": "Number properties / Number.MIN_SAFE_INTEGER",
+  "es6.number.parse-float": "Number properties / Number.parseFloat",
+  "es6.number.parse-int": "Number properties / Number.parseInt",
+
+  "es6.object.assign": {
+    features: ["Object static methods / Object.assign", "Symbol"],
+  },
+  "es6.object.create": "Object static methods / Object.create",
+  "es7.object.define-getter": {
+    features: [
+      "Object.prototype getter/setter methods / __defineGetter__",
+      "Object.prototype getter/setter methods / __defineGetter__, symbols",
+      "Object.prototype getter/setter methods / __defineGetter__, ToObject(this)",
+    ],
+  },
+  "es7.object.define-setter": {
+    features: [
+      "Object.prototype getter/setter methods / __defineSetter__",
+      "Object.prototype getter/setter methods / __defineSetter__, symbols",
+      "Object.prototype getter/setter methods / __defineSetter__, ToObject(this)",
+    ],
+  },
+  "es6.object.define-property": "Object static methods / Object.defineProperty",
+  "es6.object.define-properties": "Object static methods / Object.defineProperties",
+  "es7.object.entries": "Object static methods / Object.entries",
+  "es6.object.freeze": "Object static methods accept primitives / Object.freeze",
+  "es6.object.get-own-property-descriptor": "Object static methods accept primitives / Object.getOwnPropertyDescriptor",
+  "es7.object.get-own-property-descriptors": "Object static methods / Object.getOwnPropertyDescriptors",
+  "es6.object.get-own-property-names": "Object static methods accept primitives / Object.getOwnPropertyNames",
+  "es6.object.get-prototype-of": "Object static methods accept primitives / Object.getPrototypeOf",
+  "es7.object.lookup-getter": {
+    features: [
+      "Object.prototype getter/setter methods / __lookupGetter__",
+      "Object.prototype getter/setter methods / __lookupGetter__, prototype chain",
+      "Object.prototype getter/setter methods / __lookupGetter__, symbols",
+      "Object.prototype getter/setter methods / __lookupGetter__, ToObject(this)",
+      "Object.prototype getter/setter methods / __lookupGetter__, data properties can shadow accessors",
+    ],
+  },
+  "es7.object.lookup-setter": {
+    features: [
+      "Object.prototype getter/setter methods / __lookupSetter__",
+      "Object.prototype getter/setter methods / __lookupSetter__, prototype chain",
+      "Object.prototype getter/setter methods / __lookupSetter__, symbols",
+      "Object.prototype getter/setter methods / __lookupSetter__, ToObject(this)",
+      "Object.prototype getter/setter methods / __lookupSetter__, data properties can shadow accessors",
+    ],
+  },
+  "es6.object.prevent-extensions": "Object static methods accept primitives / Object.preventExtensions",
+  "es6.object.is": "Object static methods / Object.is",
+  "es6.object.is-frozen": "Object static methods accept primitives / Object.isFrozen",
+  "es6.object.is-sealed": "Object static methods accept primitives / Object.isSealed",
+  "es6.object.is-extensible": "Object static methods accept primitives / Object.isExtensible",
+  "es6.object.keys": "Object static methods accept primitives / Object.keys",
+  "es6.object.seal": "Object static methods accept primitives / Object.seal",
+  "es6.object.set-prototype-of": "Object static methods / Object.setPrototypeOf",
+  "es7.object.values": "Object static methods / Object.values",
+
+  "es6.promise": {
+    features: [
+      // required unhandled rejection tracking tests
+      "Promise",
+      "well-known symbols / Symbol.species, Promise.prototype.then",
+    ],
+  },
+  "es7.promise.finally": "Promise.prototype.finally",
+
+  "es6.reflect.apply": "Reflect / Reflect.apply",
+  "es6.reflect.construct": "Reflect / Reflect.construct",
+  "es6.reflect.define-property": "Reflect / Reflect.defineProperty",
+  "es6.reflect.delete-property": "Reflect / Reflect.deleteProperty",
+  "es6.reflect.get": "Reflect / Reflect.get",
+  "es6.reflect.get-own-property-descriptor": "Reflect / Reflect.getOwnPropertyDescriptor",
+  "es6.reflect.get-prototype-of": "Reflect / Reflect.getPrototypeOf",
+  "es6.reflect.has": "Reflect / Reflect.has",
+  "es6.reflect.is-extensible": "Reflect / Reflect.isExtensible",
+  "es6.reflect.own-keys": "Reflect / Reflect.ownKeys",
+  "es6.reflect.prevent-extensions": "Reflect / Reflect.preventExtensions",
+  "es6.reflect.set": "Reflect / Reflect.set",
+  "es6.reflect.set-prototype-of": "Reflect / Reflect.setPrototypeOf",
+
+  "es6.regexp.constructor": {
+    features: [
+      "miscellaneous / RegExp constructor can alter flags",
+      "well-known symbols / Symbol.match, RegExp constructor",
+    ],
+  },
+  "es6.regexp.flags": "RegExp.prototype properties / RegExp.prototype.flags",
+  "es6.regexp.match": "RegExp.prototype properties / RegExp.prototype[Symbol.match]",
+  "es6.regexp.replace": "RegExp.prototype properties / RegExp.prototype[Symbol.replace]",
+  "es6.regexp.split": "RegExp.prototype properties / RegExp.prototype[Symbol.split]",
+  "es6.regexp.search": "RegExp.prototype properties / RegExp.prototype[Symbol.search]",
+  "es6.regexp.to-string": "miscellaneous / RegExp.prototype.toString generic and uses \"flags\" property",
+
+  // This is explicit due to prevent the stage-1 Set proposals under the
+  // category "Set methods" from being included.
+  "es6.set": {
+    features: [
+      "Set / basic functionality",
+      "Set / constructor arguments",
+      "Set / constructor requires new",
+      "Set / constructor accepts null",
+      "Set / constructor invokes add",
+      "Set / iterator closing",
+      "Set / Set.prototype.add returns this",
+      "Set / -0 key converts to +0",
+      "Set / Set.prototype.size",
+      "Set / Set.prototype.delete",
+      "Set / Set.prototype.clear",
+      "Set / Set.prototype.forEach",
+      "Set / Set.prototype.keys",
+      "Set / Set.prototype.values",
+      "Set / Set.prototype.entries",
+      "Set / Set.prototype[Symbol.iterator]",
+      "Set / Set.prototype isn't an instance",
+      "Set / Set iterator prototype chain",
+      "Set / Set[Symbol.species]",
+    ],
+  },
+
+  "es6.symbol": {
+    features: [
+      "Symbol",
+      "Object static methods / Object.getOwnPropertySymbols",
+      "well-known symbols / Symbol.hasInstance",
+      "well-known symbols / Symbol.isConcatSpreadable",
+      "well-known symbols / Symbol.iterator",
+      "well-known symbols / Symbol.match",
+      "well-known symbols / Symbol.replace",
+      "well-known symbols / Symbol.search",
+      "well-known symbols / Symbol.species",
+      "well-known symbols / Symbol.split",
+      "well-known symbols / Symbol.toPrimitive",
+      "well-known symbols / Symbol.toStringTag",
+      "well-known symbols / Symbol.unscopables",
+    ],
+  },
+  "es7.symbol.async-iterator": "Asynchronous Iterators",
+
+  "es6.string.anchor": "String.prototype HTML methods",
+  "es6.string.big": "String.prototype HTML methods",
+  "es6.string.blink": "String.prototype HTML methods",
+  "es6.string.bold": "String.prototype HTML methods",
+  "es6.string.code-point-at": "String.prototype methods / String.prototype.codePointAt",
+  "es6.string.ends-with": "String.prototype methods / String.prototype.endsWith",
+  "es6.string.fixed": "String.prototype HTML methods",
+  "es6.string.fontcolor": "String.prototype HTML methods",
+  "es6.string.fontsize": "String.prototype HTML methods",
+  "es6.string.from-code-point": "String static methods / String.fromCodePoint",
+  "es6.string.includes": "String.prototype methods / String.prototype.includes",
+  "es6.string.italics": "String.prototype HTML methods",
+  "es6.string.iterator": "String properties and methods / Property access on strings",
+  "es6.string.link": "String.prototype HTML methods",
+  // "String.prototype methods / String.prototype.normalize" not implemented
+  "es7.string.pad-start": "String padding / String.prototype.padStart",
+  "es7.string.pad-end": "String padding / String.prototype.padEnd",
+  "es6.string.raw": "String static methods / String.raw",
+  "es6.string.repeat": "String.prototype methods / String.prototype.repeat",
+  "es6.string.small": "String.prototype HTML methods",
+  "es6.string.starts-with": "String.prototype methods / String.prototype.startsWith",
+  "es6.string.strike": "String.prototype HTML methods",
+  "es6.string.sub": "String.prototype HTML methods",
+  "es6.string.sup": "String.prototype HTML methods",
+  "es6.string.trim": "String properties and methods / String.prototype.trim",
+
+  "es6.typed.array-buffer": "typed arrays / ArrayBuffer[Symbol.species]",
+  "es6.typed.data-view": "typed arrays / DataView",
+  "es6.typed.int8-array": {
+    features: ["typed arrays / Int8Array"].concat(typedArrayMethods),
+  },
+  "es6.typed.uint8-array": {
+    features: ["typed arrays / Uint8Array"].concat(typedArrayMethods),
+  },
+  "es6.typed.uint8-clamped-array": {
+    features: ["typed arrays / Uint8ClampedArray"].concat(typedArrayMethods),
+  },
+  "es6.typed.int16-array": {
+    features: ["typed arrays / Int16Array"].concat(typedArrayMethods),
+  },
+  "es6.typed.uint16-array": {
+    features: ["typed arrays / Uint16Array"].concat(typedArrayMethods),
+  },
+  "es6.typed.int32-array": {
+    features: ["typed arrays / Int32Array"].concat(typedArrayMethods),
+  },
+  "es6.typed.uint32-array": {
+    features: ["typed arrays / Uint32Array"].concat(typedArrayMethods),
+  },
+  "es6.typed.float32-array": {
+    features: ["typed arrays / Float32Array"].concat(typedArrayMethods),
+  },
+  "es6.typed.float64-array": {
+    features: ["typed arrays / Float64Array"].concat(typedArrayMethods),
+  },
+
+  "es6.weak-map": "WeakMap",
+
+  "es6.weak-set": "WeakSet",
+};
+
+const proposals = require("./shipped-proposals").builtIns;
+
+module.exports = Object.assign({}, es, proposals);
diff --git a/node_modules/@babel/preset-env/data/built-in-modules.json b/node_modules/@babel/preset-env/data/built-in-modules.json
new file mode 100644
index 00000000..c2d05dbd
--- /dev/null
+++ b/node_modules/@babel/preset-env/data/built-in-modules.json
@@ -0,0 +1,9 @@
+{
+  "es6.module": {
+    "edge": "16",
+    "firefox": "60",
+    "chrome": "61",
+    "safari": "10.1",
+    "ios_saf": "10.3"
+  }
+}
diff --git a/node_modules/@babel/preset-env/data/built-ins.json b/node_modules/@babel/preset-env/data/built-ins.json
new file mode 100644
index 00000000..91877c45
--- /dev/null
+++ b/node_modules/@babel/preset-env/data/built-ins.json
@@ -0,0 +1,1434 @@
+{
+  "es6.array.copy-within": {
+    "chrome": "45",
+    "edge": "12",
+    "firefox": "32",
+    "safari": "9",
+    "node": "4",
+    "ios": "9",
+    "opera": "32",
+    "electron": "0.35"
+  },
+  "es6.array.every": {
+    "chrome": "5",
+    "opera": "10.10",
+    "edge": "12",
+    "firefox": "2",
+    "safari": "3.1",
+    "node": "0.10",
+    "ie": "9",
+    "android": "4.0",
+    "ios": "6",
+    "electron": "1.1"
+  },
+  "es6.array.fill": {
+    "chrome": "45",
+    "edge": "12",
+    "firefox": "31",
+    "safari": "7.1",
+    "node": "4",
+    "ios": "8",
+    "opera": "32",
+    "electron": "0.35"
+  },
+  "es6.array.filter": {
+    "chrome": "5",
+    "opera": "10.10",
+    "edge": "12",
+    "firefox": "2",
+    "safari": "3.1",
+    "node": "0.10",
+    "ie": "9",
+    "android": "4.0",
+    "ios": "6",
+    "electron": "1.1"
+  },
+  "es6.array.find": {
+    "chrome": "45",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "4",
+    "ios": "8",
+    "opera": "32",
+    "electron": "0.35"
+  },
+  "es6.array.find-index": {
+    "chrome": "45",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "4",
+    "ios": "8",
+    "opera": "32",
+    "electron": "0.35"
+  },
+  "es6.array.for-each": {
+    "chrome": "5",
+    "opera": "10.10",
+    "edge": "12",
+    "firefox": "2",
+    "safari": "3.1",
+    "node": "0.10",
+    "ie": "9",
+    "android": "4.0",
+    "ios": "6",
+    "electron": "1.1"
+  },
+  "es6.array.from": {
+    "chrome": "51",
+    "edge": "15",
+    "firefox": "36",
+    "safari": "10",
+    "node": "6.5",
+    "ios": "10",
+    "opera": "38",
+    "electron": "1.2"
+  },
+  "es7.array.includes": {
+    "chrome": "47",
+    "edge": "14",
+    "firefox": "43",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "34",
+    "electron": "0.36"
+  },
+  "es6.array.index-of": {
+    "chrome": "5",
+    "opera": "10.10",
+    "edge": "12",
+    "firefox": "2",
+    "safari": "3.1",
+    "node": "0.10",
+    "ie": "9",
+    "android": "4.0",
+    "ios": "6",
+    "electron": "1.1"
+  },
+  "es6.array.is-array": {
+    "chrome": "5",
+    "opera": "10.50",
+    "edge": "12",
+    "firefox": "4",
+    "safari": "4",
+    "node": "0.10",
+    "ie": "9",
+    "android": "4.0",
+    "ios": "6",
+    "electron": "1.1"
+  },
+  "es6.array.iterator": {
+    "chrome": "38",
+    "edge": "12",
+    "firefox": "28",
+    "safari": "7.1",
+    "node": "0.12",
+    "ios": "8",
+    "opera": "25",
+    "electron": "0.2"
+  },
+  "es6.array.last-index-of": {
+    "chrome": "5",
+    "opera": "10.10",
+    "edge": "12",
+    "firefox": "2",
+    "safari": "3.1",
+    "node": "0.10",
+    "ie": "9",
+    "android": "4.0",
+    "ios": "6",
+    "electron": "1.1"
+  },
+  "es6.array.map": {
+    "chrome": "5",
+    "opera": "10.10",
+    "edge": "12",
+    "firefox": "2",
+    "safari": "3.1",
+    "node": "0.10",
+    "ie": "9",
+    "android": "4.0",
+    "ios": "6",
+    "electron": "1.1"
+  },
+  "es6.array.of": {
+    "chrome": "45",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "9",
+    "node": "4",
+    "ios": "9",
+    "opera": "32",
+    "electron": "0.35"
+  },
+  "es6.array.reduce": {
+    "chrome": "5",
+    "opera": "10.50",
+    "edge": "12",
+    "firefox": "3",
+    "safari": "4",
+    "node": "0.10",
+    "ie": "9",
+    "android": "4.0",
+    "ios": "6",
+    "electron": "1.1"
+  },
+  "es6.array.reduce-right": {
+    "chrome": "5",
+    "opera": "10.50",
+    "edge": "12",
+    "firefox": "3",
+    "safari": "4",
+    "node": "0.10",
+    "ie": "9",
+    "android": "4.0",
+    "ios": "6",
+    "electron": "1.1"
+  },
+  "es6.array.some": {
+    "chrome": "5",
+    "opera": "10.10",
+    "edge": "12",
+    "firefox": "2",
+    "safari": "3.1",
+    "node": "0.10",
+    "ie": "9",
+    "android": "4.0",
+    "ios": "6",
+    "electron": "1.1"
+  },
+  "es6.array.sort": {
+    "chrome": "63",
+    "opera": "50",
+    "edge": "12",
+    "firefox": "5",
+    "safari": "10.1",
+    "ie": "9",
+    "ios": "10.3"
+  },
+  "es6.array.species": {
+    "chrome": "51",
+    "edge": "13",
+    "firefox": "48",
+    "safari": "10",
+    "node": "6.5",
+    "ios": "10",
+    "opera": "38",
+    "electron": "1.2"
+  },
+  "es6.date.now": {
+    "chrome": "5",
+    "opera": "10.50",
+    "edge": "12",
+    "firefox": "2",
+    "safari": "4",
+    "node": "0.10",
+    "ie": "9",
+    "android": "4.0",
+    "ios": "6",
+    "electron": "1.1"
+  },
+  "es6.date.to-iso-string": {
+    "chrome": "5",
+    "opera": "10.50",
+    "edge": "12",
+    "firefox": "3.5",
+    "safari": "4",
+    "node": "0.10",
+    "ie": "9",
+    "android": "4.0",
+    "ios": "6",
+    "electron": "1.1"
+  },
+  "es6.date.to-json": {
+    "chrome": "5",
+    "opera": "12.10",
+    "edge": "12",
+    "firefox": "4",
+    "safari": "10",
+    "node": "0.10",
+    "ie": "9",
+    "android": "4.0",
+    "ios": "10",
+    "electron": "1.1"
+  },
+  "es6.date.to-primitive": {
+    "chrome": "47",
+    "edge": "15",
+    "firefox": "44",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "34",
+    "electron": "0.36"
+  },
+  "es6.date.to-string": {
+    "chrome": "5",
+    "opera": "10.50",
+    "edge": "12",
+    "firefox": "2",
+    "safari": "3.1",
+    "node": "0.12",
+    "ie": "10",
+    "android": "4.0",
+    "ios": "6",
+    "electron": "1.1"
+  },
+  "es6.function.bind": {
+    "chrome": "7",
+    "opera": "12",
+    "edge": "12",
+    "firefox": "4",
+    "safari": "5.1",
+    "node": "0.10",
+    "ie": "9",
+    "android": "4.0",
+    "ios": "7"
+  },
+  "es6.function.has-instance": {
+    "chrome": "51",
+    "edge": "15",
+    "firefox": "50",
+    "safari": "10",
+    "node": "6.5",
+    "ios": "10",
+    "opera": "38",
+    "electron": "1.2"
+  },
+  "es6.function.name": {
+    "chrome": "5",
+    "opera": "10.50",
+    "edge": "12",
+    "firefox": "2",
+    "safari": "4",
+    "node": "0.12",
+    "android": "4.0",
+    "ios": "6",
+    "electron": "1.1"
+  },
+  "es6.map": {
+    "chrome": "51",
+    "edge": "15",
+    "firefox": "53",
+    "safari": "10",
+    "node": "6.5",
+    "ios": "10",
+    "opera": "38",
+    "electron": "1.2"
+  },
+  "es6.math.acosh": {
+    "chrome": "38",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "0.12",
+    "ios": "8",
+    "opera": "25",
+    "electron": "0.2"
+  },
+  "es6.math.asinh": {
+    "chrome": "38",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "0.12",
+    "ios": "8",
+    "opera": "25",
+    "electron": "0.2"
+  },
+  "es6.math.atanh": {
+    "chrome": "38",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "0.12",
+    "ios": "8",
+    "opera": "25",
+    "electron": "0.2"
+  },
+  "es6.math.cbrt": {
+    "chrome": "38",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "0.12",
+    "ios": "8",
+    "opera": "25",
+    "electron": "0.2"
+  },
+  "es6.math.clz32": {
+    "chrome": "38",
+    "edge": "12",
+    "firefox": "31",
+    "safari": "9",
+    "node": "0.12",
+    "ios": "9",
+    "opera": "25",
+    "electron": "0.2"
+  },
+  "es6.math.cosh": {
+    "chrome": "38",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "0.12",
+    "ios": "8",
+    "opera": "25",
+    "electron": "0.2"
+  },
+  "es6.math.expm1": {
+    "chrome": "38",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "0.12",
+    "ios": "8",
+    "opera": "25",
+    "electron": "0.2"
+  },
+  "es6.math.fround": {
+    "chrome": "38",
+    "edge": "12",
+    "firefox": "26",
+    "safari": "7.1",
+    "node": "0.12",
+    "ios": "8",
+    "opera": "25",
+    "electron": "0.2"
+  },
+  "es6.math.hypot": {
+    "chrome": "38",
+    "edge": "12",
+    "firefox": "27",
+    "safari": "7.1",
+    "node": "0.12",
+    "ios": "8",
+    "opera": "25",
+    "electron": "0.2"
+  },
+  "es6.math.imul": {
+    "chrome": "30",
+    "edge": "12",
+    "firefox": "23",
+    "safari": "7",
+    "node": "0.12",
+    "android": "4.4",
+    "ios": "7",
+    "opera": "17",
+    "electron": "0.2"
+  },
+  "es6.math.log1p": {
+    "chrome": "38",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "0.12",
+    "ios": "8",
+    "opera": "25",
+    "electron": "0.2"
+  },
+  "es6.math.log10": {
+    "chrome": "38",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "0.12",
+    "ios": "8",
+    "opera": "25",
+    "electron": "0.2"
+  },
+  "es6.math.log2": {
+    "chrome": "38",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "0.12",
+    "ios": "8",
+    "opera": "25",
+    "electron": "0.2"
+  },
+  "es6.math.sign": {
+    "chrome": "38",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "9",
+    "node": "0.12",
+    "ios": "9",
+    "opera": "25",
+    "electron": "0.2"
+  },
+  "es6.math.sinh": {
+    "chrome": "38",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "0.12",
+    "ios": "8",
+    "opera": "25",
+    "electron": "0.2"
+  },
+  "es6.math.tanh": {
+    "chrome": "38",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "0.12",
+    "ios": "8",
+    "opera": "25",
+    "electron": "0.2"
+  },
+  "es6.math.trunc": {
+    "chrome": "38",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "0.12",
+    "ios": "8",
+    "opera": "25",
+    "electron": "0.2"
+  },
+  "es6.number.constructor": {
+    "chrome": "41",
+    "edge": "12",
+    "firefox": "36",
+    "safari": "9",
+    "node": "4",
+    "ios": "9",
+    "opera": "28",
+    "electron": "0.24"
+  },
+  "es6.number.epsilon": {
+    "chrome": "34",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "9",
+    "node": "0.12",
+    "ios": "9",
+    "opera": "21",
+    "electron": "0.2"
+  },
+  "es6.number.is-finite": {
+    "chrome": "19",
+    "edge": "12",
+    "firefox": "16",
+    "safari": "9",
+    "node": "0.12",
+    "android": "4.1",
+    "ios": "9",
+    "electron": "0.2"
+  },
+  "es6.number.is-integer": {
+    "chrome": "34",
+    "edge": "12",
+    "firefox": "16",
+    "safari": "9",
+    "node": "0.12",
+    "ios": "9",
+    "opera": "21",
+    "electron": "0.2"
+  },
+  "es6.number.is-nan": {
+    "chrome": "19",
+    "edge": "12",
+    "firefox": "15",
+    "safari": "9",
+    "node": "0.12",
+    "android": "4.1",
+    "ios": "9",
+    "electron": "0.2"
+  },
+  "es6.number.is-safe-integer": {
+    "chrome": "34",
+    "edge": "12",
+    "firefox": "32",
+    "safari": "9",
+    "node": "0.12",
+    "ios": "9",
+    "opera": "21",
+    "electron": "0.2"
+  },
+  "es6.number.max-safe-integer": {
+    "chrome": "34",
+    "edge": "12",
+    "firefox": "31",
+    "safari": "9",
+    "node": "0.12",
+    "ios": "9",
+    "opera": "21",
+    "electron": "0.2"
+  },
+  "es6.number.min-safe-integer": {
+    "chrome": "34",
+    "edge": "12",
+    "firefox": "31",
+    "safari": "9",
+    "node": "0.12",
+    "ios": "9",
+    "opera": "21",
+    "electron": "0.2"
+  },
+  "es6.number.parse-float": {
+    "chrome": "34",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "9",
+    "node": "0.12",
+    "ios": "9",
+    "opera": "21",
+    "electron": "0.2"
+  },
+  "es6.number.parse-int": {
+    "chrome": "34",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "9",
+    "node": "0.12",
+    "ios": "9",
+    "opera": "21",
+    "electron": "0.2"
+  },
+  "es6.object.assign": {
+    "chrome": "49",
+    "edge": "13",
+    "firefox": "36",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "36",
+    "electron": "1"
+  },
+  "es6.object.create": {
+    "chrome": "5",
+    "opera": "12",
+    "edge": "12",
+    "firefox": "4",
+    "safari": "4",
+    "node": "0.10",
+    "ie": "9",
+    "android": "4.0",
+    "ios": "6",
+    "electron": "1.1"
+  },
+  "es7.object.define-getter": {
+    "chrome": "62",
+    "edge": "16",
+    "firefox": "48",
+    "safari": "9",
+    "node": "8.10",
+    "ios": "9",
+    "opera": "49"
+  },
+  "es7.object.define-setter": {
+    "chrome": "62",
+    "edge": "16",
+    "firefox": "48",
+    "safari": "9",
+    "node": "8.10",
+    "ios": "9",
+    "opera": "49"
+  },
+  "es6.object.define-property": {
+    "chrome": "5",
+    "opera": "12",
+    "edge": "12",
+    "firefox": "4",
+    "safari": "5.1",
+    "node": "0.10",
+    "ie": "9",
+    "android": "4.0",
+    "ios": "6",
+    "electron": "1.1"
+  },
+  "es6.object.define-properties": {
+    "chrome": "5",
+    "opera": "12",
+    "edge": "12",
+    "firefox": "4",
+    "safari": "4",
+    "node": "0.10",
+    "ie": "9",
+    "android": "4.0",
+    "ios": "6",
+    "electron": "1.1"
+  },
+  "es7.object.entries": {
+    "chrome": "54",
+    "edge": "14",
+    "firefox": "47",
+    "safari": "10.1",
+    "node": "7",
+    "ios": "10.3",
+    "opera": "41",
+    "electron": "1.5"
+  },
+  "es6.object.freeze": {
+    "chrome": "44",
+    "edge": "12",
+    "firefox": "35",
+    "safari": "9",
+    "node": "4",
+    "ios": "9",
+    "opera": "31",
+    "electron": "0.31"
+  },
+  "es6.object.get-own-property-descriptor": {
+    "chrome": "44",
+    "edge": "12",
+    "firefox": "35",
+    "safari": "9",
+    "node": "4",
+    "ios": "9",
+    "opera": "31",
+    "electron": "0.31"
+  },
+  "es7.object.get-own-property-descriptors": {
+    "chrome": "54",
+    "edge": "15",
+    "firefox": "50",
+    "safari": "10.1",
+    "node": "7",
+    "ios": "10.3",
+    "opera": "41",
+    "electron": "1.5"
+  },
+  "es6.object.get-own-property-names": {
+    "chrome": "40",
+    "edge": "12",
+    "firefox": "33",
+    "safari": "9",
+    "node": "4",
+    "ios": "9",
+    "opera": "27",
+    "electron": "0.21"
+  },
+  "es6.object.get-prototype-of": {
+    "chrome": "44",
+    "edge": "12",
+    "firefox": "3.5",
+    "safari": "9",
+    "node": "4",
+    "ios": "9",
+    "opera": "31",
+    "electron": "0.31"
+  },
+  "es7.object.lookup-getter": {
+    "chrome": "62",
+    "firefox": "36",
+    "safari": "9",
+    "node": "8.10",
+    "ios": "9",
+    "opera": "49"
+  },
+  "es7.object.lookup-setter": {
+    "chrome": "62",
+    "firefox": "36",
+    "safari": "9",
+    "node": "8.10",
+    "ios": "9",
+    "opera": "49"
+  },
+  "es6.object.prevent-extensions": {
+    "chrome": "44",
+    "edge": "12",
+    "firefox": "35",
+    "safari": "9",
+    "node": "4",
+    "ios": "9",
+    "opera": "31",
+    "electron": "0.31"
+  },
+  "es6.object.is": {
+    "chrome": "19",
+    "edge": "12",
+    "firefox": "22",
+    "safari": "9",
+    "node": "0.12",
+    "android": "4.1",
+    "ios": "9",
+    "electron": "0.2"
+  },
+  "es6.object.is-frozen": {
+    "chrome": "44",
+    "edge": "12",
+    "firefox": "35",
+    "safari": "9",
+    "node": "4",
+    "ios": "9",
+    "opera": "31",
+    "electron": "0.31"
+  },
+  "es6.object.is-sealed": {
+    "chrome": "44",
+    "edge": "12",
+    "firefox": "35",
+    "safari": "9",
+    "node": "4",
+    "ios": "9",
+    "opera": "31",
+    "electron": "0.31"
+  },
+  "es6.object.is-extensible": {
+    "chrome": "44",
+    "edge": "12",
+    "firefox": "35",
+    "safari": "9",
+    "node": "4",
+    "ios": "9",
+    "opera": "31",
+    "electron": "0.31"
+  },
+  "es6.object.keys": {
+    "chrome": "40",
+    "edge": "12",
+    "firefox": "35",
+    "safari": "9",
+    "node": "4",
+    "ios": "9",
+    "opera": "27",
+    "electron": "0.21"
+  },
+  "es6.object.seal": {
+    "chrome": "44",
+    "edge": "12",
+    "firefox": "35",
+    "safari": "9",
+    "node": "4",
+    "ios": "9",
+    "opera": "31",
+    "electron": "0.31"
+  },
+  "es6.object.set-prototype-of": {
+    "chrome": "34",
+    "edge": "12",
+    "firefox": "31",
+    "safari": "9",
+    "node": "0.12",
+    "ie": "11",
+    "ios": "9",
+    "opera": "21",
+    "electron": "0.2"
+  },
+  "es7.object.values": {
+    "chrome": "54",
+    "edge": "14",
+    "firefox": "47",
+    "safari": "10.1",
+    "node": "7",
+    "ios": "10.3",
+    "opera": "41",
+    "electron": "1.5"
+  },
+  "es6.promise": {
+    "chrome": "51",
+    "edge": "14",
+    "firefox": "45",
+    "safari": "10",
+    "node": "6.5",
+    "ios": "10",
+    "opera": "38",
+    "electron": "1.2"
+  },
+  "es7.promise.finally": {
+    "chrome": "63",
+    "firefox": "58",
+    "safari": "11.1",
+    "ios": "11.3",
+    "opera": "50"
+  },
+  "es6.reflect.apply": {
+    "chrome": "49",
+    "edge": "12",
+    "firefox": "42",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "36",
+    "electron": "1"
+  },
+  "es6.reflect.construct": {
+    "chrome": "49",
+    "edge": "13",
+    "firefox": "44",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "36",
+    "electron": "1"
+  },
+  "es6.reflect.define-property": {
+    "chrome": "49",
+    "edge": "13",
+    "firefox": "42",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "36",
+    "electron": "1"
+  },
+  "es6.reflect.delete-property": {
+    "chrome": "49",
+    "edge": "12",
+    "firefox": "42",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "36",
+    "electron": "1"
+  },
+  "es6.reflect.get": {
+    "chrome": "49",
+    "edge": "12",
+    "firefox": "42",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "36",
+    "electron": "1"
+  },
+  "es6.reflect.get-own-property-descriptor": {
+    "chrome": "49",
+    "edge": "12",
+    "firefox": "42",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "36",
+    "electron": "1"
+  },
+  "es6.reflect.get-prototype-of": {
+    "chrome": "49",
+    "edge": "12",
+    "firefox": "42",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "36",
+    "electron": "1"
+  },
+  "es6.reflect.has": {
+    "chrome": "49",
+    "edge": "12",
+    "firefox": "42",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "36",
+    "electron": "1"
+  },
+  "es6.reflect.is-extensible": {
+    "chrome": "49",
+    "edge": "12",
+    "firefox": "42",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "36",
+    "electron": "1"
+  },
+  "es6.reflect.own-keys": {
+    "chrome": "49",
+    "edge": "12",
+    "firefox": "42",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "36",
+    "electron": "1"
+  },
+  "es6.reflect.prevent-extensions": {
+    "chrome": "49",
+    "edge": "12",
+    "firefox": "42",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "36",
+    "electron": "1"
+  },
+  "es6.reflect.set": {
+    "chrome": "49",
+    "edge": "12",
+    "firefox": "42",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "36",
+    "electron": "1"
+  },
+  "es6.reflect.set-prototype-of": {
+    "chrome": "49",
+    "edge": "12",
+    "firefox": "42",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "36",
+    "electron": "1"
+  },
+  "es6.regexp.constructor": {
+    "chrome": "50",
+    "firefox": "40",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "37",
+    "electron": "1.1"
+  },
+  "es6.regexp.flags": {
+    "chrome": "49",
+    "firefox": "37",
+    "safari": "9",
+    "node": "6",
+    "ios": "9",
+    "opera": "36",
+    "electron": "1"
+  },
+  "es6.regexp.match": {
+    "chrome": "50",
+    "firefox": "49",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "37",
+    "electron": "1.1"
+  },
+  "es6.regexp.replace": {
+    "chrome": "50",
+    "firefox": "49",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "37",
+    "electron": "1.1"
+  },
+  "es6.regexp.split": {
+    "chrome": "50",
+    "firefox": "49",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "37",
+    "electron": "1.1"
+  },
+  "es6.regexp.search": {
+    "chrome": "50",
+    "firefox": "49",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "37",
+    "electron": "1.1"
+  },
+  "es6.regexp.to-string": {
+    "chrome": "50",
+    "firefox": "39",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "37",
+    "electron": "1.1"
+  },
+  "es6.set": {
+    "chrome": "51",
+    "edge": "15",
+    "firefox": "53",
+    "safari": "10",
+    "node": "6.5",
+    "ios": "10",
+    "opera": "38",
+    "electron": "1.2"
+  },
+  "es6.symbol": {
+    "chrome": "51",
+    "firefox": "51",
+    "safari": "10",
+    "node": "6.5",
+    "ios": "10",
+    "opera": "38",
+    "electron": "1.2"
+  },
+  "es7.symbol.async-iterator": {
+    "chrome": "63",
+    "firefox": "57",
+    "safari": "tp",
+    "opera": "50"
+  },
+  "es6.string.anchor": {
+    "chrome": "5",
+    "edge": "12",
+    "firefox": "17",
+    "safari": "6",
+    "node": "0.12",
+    "android": "4.0",
+    "ios": "7",
+    "electron": "1.1"
+  },
+  "es6.string.big": {
+    "chrome": "5",
+    "edge": "12",
+    "firefox": "17",
+    "safari": "6",
+    "node": "0.12",
+    "android": "4.0",
+    "ios": "7",
+    "electron": "1.1"
+  },
+  "es6.string.blink": {
+    "chrome": "5",
+    "edge": "12",
+    "firefox": "17",
+    "safari": "6",
+    "node": "0.12",
+    "android": "4.0",
+    "ios": "7",
+    "electron": "1.1"
+  },
+  "es6.string.bold": {
+    "chrome": "5",
+    "edge": "12",
+    "firefox": "17",
+    "safari": "6",
+    "node": "0.12",
+    "android": "4.0",
+    "ios": "7",
+    "electron": "1.1"
+  },
+  "es6.string.code-point-at": {
+    "chrome": "41",
+    "edge": "12",
+    "firefox": "29",
+    "safari": "9",
+    "node": "4",
+    "ios": "9",
+    "opera": "28",
+    "electron": "0.24"
+  },
+  "es6.string.ends-with": {
+    "chrome": "41",
+    "edge": "12",
+    "firefox": "29",
+    "safari": "9",
+    "node": "4",
+    "ios": "9",
+    "opera": "28",
+    "electron": "0.24"
+  },
+  "es6.string.fixed": {
+    "chrome": "5",
+    "edge": "12",
+    "firefox": "17",
+    "safari": "6",
+    "node": "0.12",
+    "android": "4.0",
+    "ios": "7",
+    "electron": "1.1"
+  },
+  "es6.string.fontcolor": {
+    "chrome": "5",
+    "edge": "12",
+    "firefox": "17",
+    "safari": "6",
+    "node": "0.12",
+    "android": "4.0",
+    "ios": "7",
+    "electron": "1.1"
+  },
+  "es6.string.fontsize": {
+    "chrome": "5",
+    "edge": "12",
+    "firefox": "17",
+    "safari": "6",
+    "node": "0.12",
+    "android": "4.0",
+    "ios": "7",
+    "electron": "1.1"
+  },
+  "es6.string.from-code-point": {
+    "chrome": "41",
+    "edge": "12",
+    "firefox": "29",
+    "safari": "9",
+    "node": "4",
+    "ios": "9",
+    "opera": "28",
+    "electron": "0.24"
+  },
+  "es6.string.includes": {
+    "chrome": "41",
+    "edge": "12",
+    "firefox": "40",
+    "safari": "9",
+    "node": "4",
+    "ios": "9",
+    "opera": "28",
+    "electron": "0.24"
+  },
+  "es6.string.italics": {
+    "chrome": "5",
+    "edge": "12",
+    "firefox": "17",
+    "safari": "6",
+    "node": "0.12",
+    "android": "4.0",
+    "ios": "7",
+    "electron": "1.1"
+  },
+  "es6.string.iterator": {
+    "chrome": "5",
+    "opera": "10.10",
+    "edge": "12",
+    "firefox": "2",
+    "safari": "3.1",
+    "node": "0.10",
+    "ie": "8",
+    "android": "4.0",
+    "ios": "6",
+    "electron": "1.1"
+  },
+  "es6.string.link": {
+    "chrome": "5",
+    "edge": "12",
+    "firefox": "17",
+    "safari": "6",
+    "node": "0.12",
+    "android": "4.0",
+    "ios": "7",
+    "electron": "1.1"
+  },
+  "es7.string.pad-start": {
+    "chrome": "57",
+    "edge": "15",
+    "firefox": "48",
+    "safari": "10",
+    "node": "8",
+    "ios": "10",
+    "opera": "44",
+    "electron": "1.7"
+  },
+  "es7.string.pad-end": {
+    "chrome": "57",
+    "edge": "15",
+    "firefox": "48",
+    "safari": "10",
+    "node": "8",
+    "ios": "10",
+    "opera": "44",
+    "electron": "1.7"
+  },
+  "es6.string.raw": {
+    "chrome": "41",
+    "edge": "12",
+    "firefox": "34",
+    "safari": "9",
+    "node": "4",
+    "ios": "9",
+    "opera": "28",
+    "electron": "0.24"
+  },
+  "es6.string.repeat": {
+    "chrome": "41",
+    "edge": "12",
+    "firefox": "24",
+    "safari": "9",
+    "node": "4",
+    "ios": "9",
+    "opera": "28",
+    "electron": "0.24"
+  },
+  "es6.string.small": {
+    "chrome": "5",
+    "edge": "12",
+    "firefox": "17",
+    "safari": "6",
+    "node": "0.12",
+    "android": "4.0",
+    "ios": "7",
+    "electron": "1.1"
+  },
+  "es6.string.starts-with": {
+    "chrome": "41",
+    "edge": "12",
+    "firefox": "29",
+    "safari": "9",
+    "node": "4",
+    "ios": "9",
+    "opera": "28",
+    "electron": "0.24"
+  },
+  "es6.string.strike": {
+    "chrome": "5",
+    "edge": "12",
+    "firefox": "17",
+    "safari": "6",
+    "node": "0.12",
+    "android": "4.0",
+    "ios": "7",
+    "electron": "1.1"
+  },
+  "es6.string.sub": {
+    "chrome": "5",
+    "edge": "12",
+    "firefox": "17",
+    "safari": "6",
+    "node": "0.12",
+    "android": "4.0",
+    "ios": "7",
+    "electron": "1.1"
+  },
+  "es6.string.sup": {
+    "chrome": "5",
+    "edge": "12",
+    "firefox": "17",
+    "safari": "6",
+    "node": "0.12",
+    "android": "4.0",
+    "ios": "7",
+    "electron": "1.1"
+  },
+  "es6.string.trim": {
+    "chrome": "5",
+    "opera": "10.50",
+    "edge": "12",
+    "firefox": "3.5",
+    "safari": "4",
+    "node": "0.10",
+    "ie": "9",
+    "android": "4.0",
+    "ios": "6",
+    "electron": "1.1"
+  },
+  "es6.typed.array-buffer": {
+    "chrome": "51",
+    "edge": "13",
+    "firefox": "48",
+    "safari": "10",
+    "node": "6.5",
+    "ios": "10",
+    "opera": "38",
+    "electron": "1.2"
+  },
+  "es6.typed.data-view": {
+    "chrome": "5",
+    "opera": "12",
+    "edge": "12",
+    "firefox": "15",
+    "safari": "5.1",
+    "node": "0.12",
+    "ie": "10",
+    "android": "4.0",
+    "ios": "6",
+    "electron": "1.1"
+  },
+  "es6.typed.int8-array": {
+    "chrome": "51",
+    "edge": "13",
+    "firefox": "48",
+    "safari": "10",
+    "node": "6.5",
+    "ios": "10",
+    "opera": "38",
+    "electron": "1.2"
+  },
+  "es6.typed.uint8-array": {
+    "chrome": "51",
+    "edge": "13",
+    "firefox": "48",
+    "safari": "10",
+    "node": "6.5",
+    "ios": "10",
+    "opera": "38",
+    "electron": "1.2"
+  },
+  "es6.typed.uint8-clamped-array": {
+    "chrome": "51",
+    "edge": "13",
+    "firefox": "48",
+    "safari": "10",
+    "node": "6.5",
+    "ios": "10",
+    "opera": "38",
+    "electron": "1.2"
+  },
+  "es6.typed.int16-array": {
+    "chrome": "51",
+    "edge": "13",
+    "firefox": "48",
+    "safari": "10",
+    "node": "6.5",
+    "ios": "10",
+    "opera": "38",
+    "electron": "1.2"
+  },
+  "es6.typed.uint16-array": {
+    "chrome": "51",
+    "edge": "13",
+    "firefox": "48",
+    "safari": "10",
+    "node": "6.5",
+    "ios": "10",
+    "opera": "38",
+    "electron": "1.2"
+  },
+  "es6.typed.int32-array": {
+    "chrome": "51",
+    "edge": "13",
+    "firefox": "48",
+    "safari": "10",
+    "node": "6.5",
+    "ios": "10",
+    "opera": "38",
+    "electron": "1.2"
+  },
+  "es6.typed.uint32-array": {
+    "chrome": "51",
+    "edge": "13",
+    "firefox": "48",
+    "safari": "10",
+    "node": "6.5",
+    "ios": "10",
+    "opera": "38",
+    "electron": "1.2"
+  },
+  "es6.typed.float32-array": {
+    "chrome": "51",
+    "edge": "13",
+    "firefox": "48",
+    "safari": "10",
+    "node": "6.5",
+    "ios": "10",
+    "opera": "38",
+    "electron": "1.2"
+  },
+  "es6.typed.float64-array": {
+    "chrome": "51",
+    "edge": "13",
+    "firefox": "48",
+    "safari": "10",
+    "node": "6.5",
+    "ios": "10",
+    "opera": "38",
+    "electron": "1.2"
+  },
+  "es6.weak-map": {
+    "chrome": "51",
+    "edge": "15",
+    "firefox": "53",
+    "safari": "9",
+    "node": "6.5",
+    "ios": "9",
+    "opera": "38",
+    "electron": "1.2"
+  },
+  "es6.weak-set": {
+    "chrome": "51",
+    "edge": "15",
+    "firefox": "53",
+    "safari": "9",
+    "node": "6.5",
+    "ios": "9",
+    "opera": "38",
+    "electron": "1.2"
+  }
+}
diff --git a/node_modules/@babel/preset-env/data/plugin-features.js b/node_modules/@babel/preset-env/data/plugin-features.js
new file mode 100644
index 00000000..eb417db7
--- /dev/null
+++ b/node_modules/@babel/preset-env/data/plugin-features.js
@@ -0,0 +1,96 @@
+const es2015 = {
+  "transform-template-literals": {
+    features: ["template literals"],
+  },
+  "transform-literals": {
+    features: ["Unicode code point escapes"],
+  },
+  "transform-function-name": {
+    features: ['function "name" property'],
+  },
+  "transform-arrow-functions": {
+    features: ["arrow functions"],
+  },
+  "transform-block-scoped-functions": {
+    features: ["block-level function declaration"],
+  },
+  "transform-classes": {
+    features: ["class", "super"],
+  },
+  "transform-object-super": {
+    features: ["super"],
+  },
+  "transform-shorthand-properties": {
+    features: ["object literal extensions / shorthand properties"],
+  },
+  "transform-duplicate-keys": {
+    features: ["miscellaneous / duplicate property names in strict mode"],
+  },
+  "transform-computed-properties": {
+    features: ["object literal extensions / computed properties"],
+  },
+  "transform-for-of": {
+    features: ["for..of loops"],
+  },
+  "transform-sticky-regex": {
+    features: [
+      'RegExp "y" and "u" flags / "y" flag, lastIndex',
+      'RegExp "y" and "u" flags / "y" flag',
+    ],
+  },
+  "transform-unicode-regex": {
+    features: [
+      'RegExp "y" and "u" flags / "u" flag, case folding',
+      'RegExp "y" and "u" flags / "u" flag, Unicode code point escapes',
+      'RegExp "y" and "u" flags / "u" flag',
+    ],
+  },
+  "transform-spread": {
+    features: ["spread (...) operator"],
+  },
+  "transform-parameters": {
+    features: ["default function parameters", "rest parameters"],
+  },
+  "transform-destructuring": {
+    features: [
+      "destructuring, assignment",
+      "destructuring, declarations",
+      "destructuring, parameters",
+    ],
+  },
+  "transform-block-scoping": {
+    features: ["const", "let"],
+  },
+  "transform-typeof-symbol": {
+    features: ["Symbol / typeof support"],
+  },
+  "transform-new-target": {
+    features: ["new.target"],
+  },
+  "transform-regenerator": {
+    features: ["generators"],
+  },
+};
+
+const es2016 = {
+  "transform-exponentiation-operator": {
+    features: ["exponentiation (**) operator"],
+  },
+};
+
+const es2017 = {
+  "transform-async-to-generator": {
+    features: ["async functions"],
+  },
+};
+
+const es2018 = {
+  "proposal-async-generator-functions": "Asynchronous Iterators",
+  "proposal-object-rest-spread": "object rest/spread properties",
+  "proposal-unicode-property-regex": "RegExp Unicode Property Escapes",
+  "transform-dotall-regex": "s (dotAll) flag for regular expressions",
+};
+
+const proposals = require("./shipped-proposals").features;
+
+module.exports = Object.assign({}, es2015, es2016, es2017, es2018, proposals);
diff --git a/node_modules/@babel/preset-env/data/plugins.json b/node_modules/@babel/preset-env/data/plugins.json
new file mode 100644
index 00000000..204b3a79
--- /dev/null
+++ b/node_modules/@babel/preset-env/data/plugins.json
@@ -0,0 +1,256 @@
+{
+  "transform-template-literals": {
+    "chrome": "41",
+    "edge": "13",
+    "firefox": "34",
+    "safari": "9",
+    "node": "4",
+    "ios": "9",
+    "opera": "28",
+    "electron": "0.24"
+  },
+  "transform-literals": {
+    "chrome": "44",
+    "edge": "12",
+    "firefox": "53",
+    "safari": "9",
+    "node": "4",
+    "ios": "9",
+    "opera": "31",
+    "electron": "0.31"
+  },
+  "transform-function-name": {
+    "chrome": "51",
+    "firefox": "53",
+    "safari": "10",
+    "node": "6.5",
+    "ios": "10",
+    "opera": "38",
+    "electron": "1.2"
+  },
+  "transform-arrow-functions": {
+    "chrome": "47",
+    "edge": "13",
+    "firefox": "45",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "34",
+    "electron": "0.36"
+  },
+  "transform-block-scoped-functions": {
+    "chrome": "41",
+    "edge": "12",
+    "firefox": "46",
+    "safari": "10",
+    "node": "4",
+    "ie": "11",
+    "ios": "10",
+    "opera": "28",
+    "electron": "0.24"
+  },
+  "transform-classes": {
+    "chrome": "46",
+    "edge": "13",
+    "firefox": "45",
+    "safari": "10",
+    "node": "5",
+    "ios": "10",
+    "opera": "33",
+    "electron": "0.36"
+  },
+  "transform-object-super": {
+    "chrome": "46",
+    "edge": "13",
+    "firefox": "45",
+    "safari": "10",
+    "node": "5",
+    "ios": "10",
+    "opera": "33",
+    "electron": "0.36"
+  },
+  "transform-shorthand-properties": {
+    "chrome": "43",
+    "edge": "12",
+    "firefox": "33",
+    "safari": "9",
+    "node": "4",
+    "ios": "9",
+    "opera": "30",
+    "electron": "0.29"
+  },
+  "transform-duplicate-keys": {
+    "chrome": "42",
+    "edge": "12",
+    "firefox": "34",
+    "safari": "9",
+    "node": "4",
+    "ios": "9",
+    "opera": "29",
+    "electron": "0.27"
+  },
+  "transform-computed-properties": {
+    "chrome": "44",
+    "edge": "12",
+    "firefox": "34",
+    "safari": "7.1",
+    "node": "4",
+    "ios": "8",
+    "opera": "31",
+    "electron": "0.31"
+  },
+  "transform-for-of": {
+    "chrome": "51",
+    "edge": "15",
+    "firefox": "53",
+    "safari": "10",
+    "node": "6.5",
+    "ios": "10",
+    "opera": "38",
+    "electron": "1.2"
+  },
+  "transform-sticky-regex": {
+    "chrome": "49",
+    "edge": "13",
+    "firefox": "3",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "36",
+    "electron": "1"
+  },
+  "transform-unicode-regex": {
+    "chrome": "50",
+    "edge": "13",
+    "firefox": "46",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "37",
+    "electron": "1.1"
+  },
+  "transform-spread": {
+    "chrome": "46",
+    "edge": "13",
+    "firefox": "36",
+    "safari": "10",
+    "node": "5",
+    "ios": "10",
+    "opera": "33",
+    "electron": "0.36"
+  },
+  "transform-parameters": {
+    "chrome": "49",
+    "edge": "14",
+    "firefox": "53",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "36",
+    "electron": "1"
+  },
+  "transform-destructuring": {
+    "chrome": "51",
+    "firefox": "53",
+    "safari": "10",
+    "node": "6.5",
+    "ios": "10",
+    "opera": "38",
+    "electron": "1.2"
+  },
+  "transform-block-scoping": {
+    "chrome": "49",
+    "edge": "14",
+    "firefox": "51",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "36",
+    "electron": "1"
+  },
+  "transform-typeof-symbol": {
+    "chrome": "38",
+    "edge": "12",
+    "firefox": "36",
+    "safari": "9",
+    "node": "0.12",
+    "ios": "9",
+    "opera": "25",
+    "electron": "0.2"
+  },
+  "transform-new-target": {
+    "chrome": "46",
+    "edge": "14",
+    "firefox": "41",
+    "safari": "10",
+    "node": "5",
+    "ios": "10",
+    "opera": "33",
+    "electron": "0.36"
+  },
+  "transform-regenerator": {
+    "chrome": "50",
+    "edge": "13",
+    "firefox": "53",
+    "safari": "10",
+    "node": "6",
+    "ios": "10",
+    "opera": "37",
+    "electron": "1.1"
+  },
+  "transform-exponentiation-operator": {
+    "chrome": "52",
+    "edge": "14",
+    "firefox": "52",
+    "safari": "10.1",
+    "node": "7",
+    "ios": "10.3",
+    "opera": "39",
+    "electron": "1.3"
+  },
+  "transform-async-to-generator": {
+    "chrome": "55",
+    "edge": "15",
+    "firefox": "52",
+    "safari": "10.1",
+    "node": "7.6",
+    "ios": "10.3",
+    "opera": "42",
+    "electron": "1.6"
+  },
+  "proposal-async-generator-functions": {
+    "chrome": "63",
+    "firefox": "57",
+    "safari": "tp",
+    "opera": "50"
+  },
+  "proposal-object-rest-spread": {
+    "chrome": "60",
+    "firefox": "55",
+    "safari": "11.1",
+    "node": "8.3",
+    "ios": "11.3",
+    "opera": "47",
+    "electron": "2"
+  },
+  "proposal-unicode-property-regex": {
+    "chrome": "64",
+    "safari": "11.1",
+    "ios": "11.3",
+    "opera": "51"
+  },
+  "transform-dotall-regex": {
+    "chrome": "62",
+    "safari": "11.1",
+    "node": "8.10",
+    "ios": "11.3",
+    "opera": "49"
+  },
+  "proposal-optional-catch-binding": {
+    "chrome": "66",
+    "firefox": "58",
+    "safari": "11.1",
+    "ios": "11.3",
+    "opera": "53"
+  }
+}
diff --git a/node_modules/@babel/preset-env/data/shipped-proposals.js b/node_modules/@babel/preset-env/data/shipped-proposals.js
new file mode 100644
index 00000000..23b74501
--- /dev/null
+++ b/node_modules/@babel/preset-env/data/shipped-proposals.js
@@ -0,0 +1,17 @@
+// These mappings represent the builtin/feature proposals that have been
+// shipped by browsers, and are enabled by the `shippedProposals` option.
+
+const builtIns = {};
+
+const features = {
+  "proposal-optional-catch-binding": "optional catch binding",
+};
+
+const pluginSyntaxMap = new Map([
+  ["proposal-async-generator-functions", "syntax-async-generators"],
+  ["proposal-object-rest-spread", "syntax-object-rest-spread"],
+  ["proposal-optional-catch-binding", "syntax-optional-catch-binding"],
+  ["proposal-unicode-property-regex", null],
+]);
+
+module.exports = { builtIns, features, pluginSyntaxMap };
diff --git a/node_modules/@babel/preset-env/data/unreleased-labels.js b/node_modules/@babel/preset-env/data/unreleased-labels.js
new file mode 100644
index 00000000..bc513056
--- /dev/null
+++ b/node_modules/@babel/preset-env/data/unreleased-labels.js
@@ -0,0 +1,3 @@
+module.exports = {
+  safari: "tp",
+};
diff --git a/node_modules/@babel/preset-env/lib/available-plugins.js b/node_modules/@babel/preset-env/lib/available-plugins.js
new file mode 100644
index 00000000..d57c0f29
--- /dev/null
+++ b/node_modules/@babel/preset-env/lib/available-plugins.js
@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = {
+  "syntax-async-generators": require("@babel/plugin-syntax-async-generators"),
+  "syntax-object-rest-spread": require("@babel/plugin-syntax-object-rest-spread"),
+  "syntax-optional-catch-binding": require("@babel/plugin-syntax-optional-catch-binding"),
+  "transform-async-to-generator": require("@babel/plugin-transform-async-to-generator"),
+  "proposal-async-generator-functions": require("@babel/plugin-proposal-async-generator-functions"),
+  "transform-arrow-functions": require("@babel/plugin-transform-arrow-functions"),
+  "transform-block-scoped-functions": require("@babel/plugin-transform-block-scoped-functions"),
+  "transform-block-scoping": require("@babel/plugin-transform-block-scoping"),
+  "transform-classes": require("@babel/plugin-transform-classes"),
+  "transform-computed-properties": require("@babel/plugin-transform-computed-properties"),
+  "transform-destructuring": require("@babel/plugin-transform-destructuring"),
+  "transform-dotall-regex": require("@babel/plugin-transform-dotall-regex"),
+  "transform-duplicate-keys": require("@babel/plugin-transform-duplicate-keys"),
+  "transform-for-of": require("@babel/plugin-transform-for-of"),
+  "transform-function-name": require("@babel/plugin-transform-function-name"),
+  "transform-literals": require("@babel/plugin-transform-literals"),
+  "transform-modules-amd": require("@babel/plugin-transform-modules-amd"),
+  "transform-modules-commonjs": require("@babel/plugin-transform-modules-commonjs"),
+  "transform-modules-systemjs": require("@babel/plugin-transform-modules-systemjs"),
+  "transform-modules-umd": require("@babel/plugin-transform-modules-umd"),
+  "transform-object-super": require("@babel/plugin-transform-object-super"),
+  "transform-parameters": require("@babel/plugin-transform-parameters"),
+  "transform-shorthand-properties": require("@babel/plugin-transform-shorthand-properties"),
+  "transform-spread": require("@babel/plugin-transform-spread"),
+  "transform-sticky-regex": require("@babel/plugin-transform-sticky-regex"),
+  "transform-template-literals": require("@babel/plugin-transform-template-literals"),
+  "transform-typeof-symbol": require("@babel/plugin-transform-typeof-symbol"),
+  "transform-unicode-regex": require("@babel/plugin-transform-unicode-regex"),
+  "transform-exponentiation-operator": require("@babel/plugin-transform-exponentiation-operator"),
+  "transform-new-target": require("@babel/plugin-transform-new-target"),
+  "proposal-object-rest-spread": require("@babel/plugin-proposal-object-rest-spread"),
+  "proposal-optional-catch-binding": require("@babel/plugin-proposal-optional-catch-binding"),
+  "transform-regenerator": require("@babel/plugin-transform-regenerator"),
+  "proposal-unicode-property-regex": require("@babel/plugin-proposal-unicode-property-regex")
+};
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/preset-env/lib/built-in-definitions.js b/node_modules/@babel/preset-env/lib/built-in-definitions.js
new file mode 100644
index 00000000..57e700b0
--- /dev/null
+++ b/node_modules/@babel/preset-env/lib/built-in-definitions.js
@@ -0,0 +1,168 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.definitions = void 0;
+const ArrayNatureIterators = ["es6.object.to-string", "es6.array.iterator", "web.dom.iterable"];
+const CommonIterators = ["es6.string.iterator"].concat(ArrayNatureIterators);
+const definitions = {
+  builtins: {
+    DataView: "es6.typed.data-view",
+    Float32Array: "es6.typed.float32-array",
+    Float64Array: "es6.typed.float64-array",
+    Int8Array: "es6.typed.int8-array",
+    Int16Array: "es6.typed.int16-array",
+    Int32Array: "es6.typed.int32-array",
+    Map: ["es6.map"].concat(CommonIterators),
+    Number: "es6.number.constructor",
+    Promise: ["es6.object.to-string", "es6.promise"],
+    RegExp: ["es6.regexp.constructor"],
+    Set: ["es6.set"].concat(CommonIterators),
+    Symbol: ["es6.symbol", "es7.symbol.async-iterator"],
+    Uint8Array: "es6.typed.uint8-array",
+    Uint8ClampedArray: "es6.typed.uint8-clamped-array",
+    Uint16Array: "es6.typed.uint16-array",
+    Uint32Array: "es6.typed.uint32-array",
+    WeakMap: ["es6.weak-map"].concat(CommonIterators),
+    WeakSet: ["es6.weak-set"].concat(CommonIterators)
+  },
+  instanceMethods: {
+    __defineGetter__: ["es7.object.define-getter"],
+    __defineSetter__: ["es7.object.define-setter"],
+    __lookupGetter__: ["es7.object.lookup-getter"],
+    __lookupSetter__: ["es7.object.lookup-setter"],
+    anchor: ["es6.string.anchor"],
+    big: ["es6.string.big"],
+    bind: ["es6.function.bind"],
+    blink: ["es6.string.blink"],
+    bold: ["es6.string.bold"],
+    codePointAt: ["es6.string.code-point-at"],
+    copyWithin: ["es6.array.copy-within"],
+    endsWith: ["es6.string.ends-with"],
+    entries: ArrayNatureIterators,
+    every: ["es6.array.is-array"],
+    fill: ["es6.array.fill"],
+    filter: ["es6.array.filter"],
+    find: ["es6.array.find"],
+    findIndex: ["es6.array.find-index"],
+    fixed: ["es6.string.fixed"],
+    flags: ["es6.regexp.flags"],
+    fontcolor: ["es6.string.fontcolor"],
+    fontsize: ["es6.string.fontsize"],
+    forEach: ["es6.array.for-each", "web.dom.iterable"],
+    includes: ["es6.string.includes", "es7.array.includes"],
+    indexOf: ["es6.array.index-of"],
+    italics: ["es6.string.italics"],
+    keys: ArrayNatureIterators,
+    lastIndexOf: ["es6.array.last-index-of"],
+    link: ["es6.string.link"],
+    map: ["es6.array.map"],
+    match: ["es6.regexp.match"],
+    name: ["es6.function.name"],
+    padStart: ["es7.string.pad-start"],
+    padEnd: ["es7.string.pad-end"],
+    reduce: ["es6.array.reduce"],
+    reduceRight: ["es6.array.reduce-right"],
+    repeat: ["es6.string.repeat"],
+    replace: ["es6.regexp.replace"],
+    search: ["es6.regexp.search"],
+    slice: ["es6.array.slice"],
+    small: ["es6.string.small"],
+    some: ["es6.array.some"],
+    sort: ["es6.array.sort"],
+    split: ["es6.regexp.split"],
+    startsWith: ["es6.string.starts-with"],
+    strike: ["es6.string.strike"],
+    sub: ["es6.string.sub"],
+    sup: ["es6.string.sup"],
+    toISOString: ["es6.date.to-iso-string"],
+    toJSON: ["es6.date.to-json"],
+    toString: ["es6.object.to-string", "es6.date.to-string", "es6.regexp.to-string"],
+    trim: ["es6.string.trim"],
+    values: ArrayNatureIterators
+  },
+  staticMethods: {
+    Array: {
+      from: ["es6.array.from", "es6.string.iterator"],
+      isArray: "es6.array.is-array",
+      of: "es6.array.of"
+    },
+    Date: {
+      now: "es6.date.now"
+    },
+    Object: {
+      assign: "es6.object.assign",
+      create: "es6.object.create",
+      defineProperty: "es6.object.define-property",
+      defineProperties: "es6.object.define-properties",
+      entries: "es7.object.entries",
+      freeze: "es6.object.freeze",
+      getOwnPropertyDescriptors: "es7.object.get-own-property-descriptors",
+      getOwnPropertySymbols: "es6.object.get-own-property-symbols",
+      is: "es6.object.is",
+      isExtensible: "es6.object.is-extensible",
+      isFrozen: "es6.object.is-frozen",
+      isSealed: "es6.object.is-sealed",
+      keys: "es6.object.keys",
+      preventExtensions: "es6.object.prevent-extensions",
+      seal: "es6.object.seal",
+      setPrototypeOf: "es6.object.set-prototype-of",
+      values: "es7.object.values"
+    },
+    Math: {
+      acosh: "es6.math.acosh",
+      asinh: "es6.math.asinh",
+      atanh: "es6.math.atanh",
+      cbrt: "es6.math.cbrt",
+      clz32: "es6.math.clz32",
+      cosh: "es6.math.cosh",
+      expm1: "es6.math.expm1",
+      fround: "es6.math.fround",
+      hypot: "es6.math.hypot",
+      imul: "es6.math.imul",
+      log1p: "es6.math.log1p",
+      log10: "es6.math.log10",
+      log2: "es6.math.log2",
+      sign: "es6.math.sign",
+      sinh: "es6.math.sinh",
+      tanh: "es6.math.tanh",
+      trunc: "es6.math.trunc"
+    },
+    String: {
+      fromCodePoint: "es6.string.from-code-point",
+      raw: "es6.string.raw"
+    },
+    Number: {
+      EPSILON: "es6.number.epsilon",
+      MIN_SAFE_INTEGER: "es6.number.min-safe-integer",
+      MAX_SAFE_INTEGER: "es6.number.max-safe-integer",
+      isFinite: "es6.number.is-finite",
+      isInteger: "es6.number.is-integer",
+      isSafeInteger: "es6.number.is-safe-integer",
+      isNaN: "es6.number.is-nan",
+      parseFloat: "es6.number.parse-float",
+      parseInt: "es6.number.parse-int"
+    },
+    Promise: {
+      all: CommonIterators,
+      race: CommonIterators
+    },
+    Reflect: {
+      apply: "es6.reflect.apply",
+      construct: "es6.reflect.construct",
+      defineProperty: "es6.reflect.define-property",
+      deleteProperty: "es6.reflect.delete-property",
+      get: "es6.reflect.get",
+      getOwnPropertyDescriptor: "es6.reflect.get-own-property-descriptor",
+      getPrototypeOf: "es6.reflect.get-prototype-of",
+      has: "es6.reflect.has",
+      isExtensible: "es6.reflect.is-extensible",
+      ownKeys: "es6.reflect.own-keys",
+      preventExtensions: "es6.reflect.prevent-extensions",
+      set: "es6.reflect.set",
+      setPrototypeOf: "es6.reflect.set-prototype-of"
+    }
+  }
+};
+exports.definitions = definitions;
\ No newline at end of file
diff --git a/node_modules/@babel/preset-env/lib/debug.js b/node_modules/@babel/preset-env/lib/debug.js
new file mode 100644
index 00000000..57bd263d
--- /dev/null
+++ b/node_modules/@babel/preset-env/lib/debug.js
@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.logUsagePolyfills = exports.logEntryPolyfills = exports.logPlugin = exports.logMessage = void 0;
+
+function _semver() {
+  const data = _interopRequireDefault(require("semver"));
+
+  _semver = function _semver() {
+    return data;
+  };
+
+  return data;
+}
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const wordEnds = size => {
+  return size > 1 ? "s" : "";
+};
+
+const logMessage = (message, context) => {
+  const pre = context ? `[${context}] ` : "";
+  const logStr = `  ${pre}${message}`;
+  console.log(logStr);
+};
+
+exports.logMessage = logMessage;
+
+const logPlugin = (item, targetVersions, list, context) => {
+  const minVersions = list[item] || {};
+  const filteredList = Object.keys(targetVersions).reduce((result, env) => {
+    const minVersion = minVersions[env];
+    const targetVersion = targetVersions[env];
+
+    if (!minVersion) {
+      result[env] = (0, _utils.prettifyVersion)(targetVersion);
+    } else {
+      const minIsUnreleased = (0, _utils.isUnreleasedVersion)(minVersion, env);
+      const targetIsUnreleased = (0, _utils.isUnreleasedVersion)(targetVersion, env);
+
+      if (!targetIsUnreleased && (minIsUnreleased || _semver().default.lt(targetVersion, (0, _utils.semverify)(minVersion)))) {
+        result[env] = (0, _utils.prettifyVersion)(targetVersion);
+      }
+    }
+
+    return result;
+  }, {});
+  const formattedTargets = JSON.stringify(filteredList).replace(/,/g, ", ").replace(/^\{"/, '{ "').replace(/"\}$/, '" }');
+  logMessage(`${item} ${formattedTargets}`, context);
+};
+
+exports.logPlugin = logPlugin;
+
+const logEntryPolyfills = (importPolyfillIncluded, polyfills, filename, onDebug) => {
+  if (!importPolyfillIncluded) {
+    console.log(`
+[${filename}] \`import '@babel/polyfill'\` was not found.`);
+    return;
+  }
+
+  if (!polyfills.size) {
+    console.log(`
+[${filename}] Based on your targets, none were added.`);
+    return;
+  }
+
+  console.log(`
+[${filename}] Replaced \`@babel/polyfill\` with the following polyfill${wordEnds(polyfills.size)}:`);
+  onDebug(polyfills);
+};
+
+exports.logEntryPolyfills = logEntryPolyfills;
+
+const logUsagePolyfills = (polyfills, filename, onDebug) => {
+  if (!polyfills.size) {
+    console.log(`
+[${filename}] Based on your code and targets, none were added.`);
+    return;
+  }
+
+  console.log(`
+[${filename}] Added following polyfill${wordEnds(polyfills.size)}:`);
+  onDebug(polyfills);
+};
+
+exports.logUsagePolyfills = logUsagePolyfills;
\ No newline at end of file
diff --git a/node_modules/@babel/preset-env/lib/default-includes.js b/node_modules/@babel/preset-env/lib/default-includes.js
new file mode 100644
index 00000000..0579abfb
--- /dev/null
+++ b/node_modules/@babel/preset-env/lib/default-includes.js
@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultWebIncludes = void 0;
+const defaultWebIncludes = ["web.timers", "web.immediate", "web.dom.iterable"];
+exports.defaultWebIncludes = defaultWebIncludes;
\ No newline at end of file
diff --git a/node_modules/@babel/preset-env/lib/defaults.js b/node_modules/@babel/preset-env/lib/defaults.js
new file mode 100644
index 00000000..e1d714b7
--- /dev/null
+++ b/node_modules/@babel/preset-env/lib/defaults.js
@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getOptionSpecificExcludesFor = exports.getPlatformSpecificDefaultFor = void 0;
+const defaultWebIncludes = ["web.timers", "web.immediate", "web.dom.iterable"];
+const defaultExcludesForLooseMode = ["transform-typeof-symbol"];
+
+const getPlatformSpecificDefaultFor = targets => {
+  const targetNames = Object.keys(targets);
+  const isAnyTarget = !targetNames.length;
+  const isWebTarget = targetNames.some(name => name !== "node");
+  return isAnyTarget || isWebTarget ? defaultWebIncludes : null;
+};
+
+exports.getPlatformSpecificDefaultFor = getPlatformSpecificDefaultFor;
+
+const getOptionSpecificExcludesFor = ({
+  loose
+}) => {
+  if (loose) {
+    return defaultExcludesForLooseMode;
+  }
+
+  return null;
+};
+
+exports.getOptionSpecificExcludesFor = getOptionSpecificExcludesFor;
\ No newline at end of file
diff --git a/node_modules/@babel/preset-env/lib/index.js b/node_modules/@babel/preset-env/lib/index.js
new file mode 100644
index 00000000..cbf730f1
--- /dev/null
+++ b/node_modules/@babel/preset-env/lib/index.js
@@ -0,0 +1,253 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.transformIncludesAndExcludes = exports.isPluginRequired = void 0;
+
+function _semver() {
+  const data = _interopRequireDefault(require("semver"));
+
+  _semver = function _semver() {
+    return data;
+  };
+
+  return data;
+}
+
+var _builtIns = _interopRequireDefault(require("../data/built-ins.json"));
+
+var _debug = require("./debug");
+
+var _defaults = require("./defaults");
+
+var _moduleTransformations = _interopRequireDefault(require("./module-transformations"));
+
+var _normalizeOptions2 = _interopRequireDefault(require("./normalize-options.js"));
+
+var _plugins = _interopRequireDefault(require("../data/plugins.json"));
+
+var _shippedProposals = require("../data/shipped-proposals.js");
+
+var _useBuiltInsEntryPlugin = _interopRequireDefault(require("./use-built-ins-entry-plugin"));
+
+var _useBuiltInsPlugin = _interopRequireDefault(require("./use-built-ins-plugin"));
+
+var _targetsParser = _interopRequireDefault(require("./targets-parser"));
+
+var _availablePlugins = _interopRequireDefault(require("./available-plugins"));
+
+var _utils = require("./utils");
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const getPlugin = pluginName => {
+  const plugin = _availablePlugins.default[pluginName];
+
+  if (!plugin) {
+    throw new Error(`Could not find plugin "${pluginName}". Ensure there is an entry in ./available-plugins.js for it.`);
+  }
+
+  return plugin;
+};
+
+const builtInsListWithoutProposals = (0, _utils.filterStageFromList)(_builtIns.default, _shippedProposals.builtIns);
+const pluginListWithoutProposals = (0, _utils.filterStageFromList)(_plugins.default, _shippedProposals.features);
+
+const isPluginRequired = (supportedEnvironments, plugin) => {
+  const targetEnvironments = Object.keys(supportedEnvironments);
+
+  if (targetEnvironments.length === 0) {
+    return true;
+  }
+
+  const isRequiredForEnvironments = targetEnvironments.filter(environment => {
+    if (!plugin[environment]) {
+      return true;
+    }
+
+    const lowestImplementedVersion = plugin[environment];
+    const lowestTargetedVersion = supportedEnvironments[environment];
+
+    if ((0, _utils.isUnreleasedVersion)(lowestTargetedVersion, environment)) {
+      return false;
+    } else if ((0, _utils.isUnreleasedVersion)(lowestImplementedVersion, environment)) {
+      return true;
+    }
+
+    if (!_semver().default.valid(lowestTargetedVersion)) {
+      throw new Error(`Invalid version passed for target "${environment}": "${lowestTargetedVersion}". ` + "Versions must be in semver format (major.minor.patch)");
+    }
+
+    return _semver().default.gt((0, _utils.semverify)(lowestImplementedVersion), lowestTargetedVersion);
+  });
+  return isRequiredForEnvironments.length > 0;
+};
+
+exports.isPluginRequired = isPluginRequired;
+
+const getBuiltInTargets = targets => {
+  const builtInTargets = Object.assign({}, targets);
+
+  if (builtInTargets.uglify != null) {
+    delete builtInTargets.uglify;
+  }
+
+  return builtInTargets;
+};
+
+const transformIncludesAndExcludes = opts => {
+  return opts.reduce((result, opt) => {
+    const target = opt.match(/^(es\d+|web)\./) ? "builtIns" : "plugins";
+    result[target].add(opt);
+    return result;
+  }, {
+    all: opts,
+    plugins: new Set(),
+    builtIns: new Set()
+  });
+};
+
+exports.transformIncludesAndExcludes = transformIncludesAndExcludes;
+
+const filterItems = (list, includes, excludes, targets, defaultIncludes, defaultExcludes) => {
+  const result = new Set();
+
+  for (const item in list) {
+    if (!excludes.has(item) && (isPluginRequired(targets, list[item]) || includes.has(item))) {
+      result.add(item);
+    } else {
+      const shippedProposalsSyntax = _shippedProposals.pluginSyntaxMap.get(item);
+
+      if (shippedProposalsSyntax) {
+        result.add(shippedProposalsSyntax);
+      }
+    }
+  }
+
+  if (defaultIncludes) {
+    defaultIncludes.forEach(item => !excludes.has(item) && result.add(item));
+  }
+
+  if (defaultExcludes) {
+    defaultExcludes.forEach(item => !includes.has(item) && result.delete(item));
+  }
+
+  return result;
+};
+
+var _default = (0, _helperPluginUtils().declare)((api, opts) => {
+  api.assertVersion(7);
+
+  const _normalizeOptions = (0, _normalizeOptions2.default)(opts),
+        configPath = _normalizeOptions.configPath,
+        debug = _normalizeOptions.debug,
+        optionsExclude = _normalizeOptions.exclude,
+        forceAllTransforms = _normalizeOptions.forceAllTransforms,
+        ignoreBrowserslistConfig = _normalizeOptions.ignoreBrowserslistConfig,
+        optionsInclude = _normalizeOptions.include,
+        loose = _normalizeOptions.loose,
+        modules = _normalizeOptions.modules,
+        shippedProposals = _normalizeOptions.shippedProposals,
+        spec = _normalizeOptions.spec,
+        optionsTargets = _normalizeOptions.targets,
+        useBuiltIns = _normalizeOptions.useBuiltIns;
+
+  let hasUglifyTarget = false;
+
+  if (optionsTargets && optionsTargets.uglify) {
+    hasUglifyTarget = true;
+    delete optionsTargets.uglify;
+    console.log("");
+    console.log("The uglify target has been deprecated. Set the top level");
+    console.log("option `forceAllTransforms: true` instead.");
+    console.log("");
+  }
+
+  if (optionsTargets && optionsTargets.esmodules && optionsTargets.browsers) {
+    console.log("");
+    console.log("@babel/preset-env: esmodules and browsers targets have been specified together.");
+    console.log(`\`browsers\` target, \`${optionsTargets.browsers}\` will be ignored.`);
+    console.log("");
+  }
+
+  const targets = (0, _targetsParser.default)(optionsTargets, {
+    ignoreBrowserslistConfig,
+    configPath
+  });
+  const include = transformIncludesAndExcludes(optionsInclude);
+  const exclude = transformIncludesAndExcludes(optionsExclude);
+  const transformTargets = forceAllTransforms || hasUglifyTarget ? {} : targets;
+  const transformations = filterItems(shippedProposals ? _plugins.default : pluginListWithoutProposals, include.plugins, exclude.plugins, transformTargets, null, (0, _defaults.getOptionSpecificExcludesFor)({
+    loose
+  }));
+  let polyfills;
+  let polyfillTargets;
+
+  if (useBuiltIns) {
+    polyfillTargets = getBuiltInTargets(targets);
+    polyfills = filterItems(shippedProposals ? _builtIns.default : builtInsListWithoutProposals, include.builtIns, exclude.builtIns, polyfillTargets, (0, _defaults.getPlatformSpecificDefaultFor)(polyfillTargets));
+  }
+
+  const plugins = [];
+  const pluginUseBuiltIns = useBuiltIns !== false;
+
+  if (modules !== false && _moduleTransformations.default[modules]) {
+    plugins.push([getPlugin(_moduleTransformations.default[modules]), {
+      loose
+    }]);
+  }
+
+  transformations.forEach(pluginName => plugins.push([getPlugin(pluginName), {
+    spec,
+    loose,
+    useBuiltIns: pluginUseBuiltIns
+  }]));
+  const regenerator = transformations.has("transform-regenerator");
+
+  if (debug) {
+    console.log("@babel/preset-env: `DEBUG` option");
+    console.log("\nUsing targets:");
+    console.log(JSON.stringify((0, _utils.prettifyTargets)(targets), null, 2));
+    console.log(`\nUsing modules transform: ${modules.toString()}`);
+    console.log("\nUsing plugins:");
+    transformations.forEach(transform => {
+      (0, _debug.logPlugin)(transform, targets, _plugins.default);
+    });
+
+    if (!useBuiltIns) {
+      console.log("\nUsing polyfills: No polyfills were added, since the `useBuiltIns` option was not set.");
+    } else {
+      console.log(`
+Using polyfills with \`${useBuiltIns}\` option:`);
+    }
+  }
+
+  if (useBuiltIns === "usage" || useBuiltIns === "entry") {
+    const pluginOptions = {
+      debug,
+      polyfills,
+      regenerator,
+      onDebug: (polyfills, context) => {
+        polyfills.forEach(polyfill => (0, _debug.logPlugin)(polyfill, polyfillTargets, _builtIns.default, context));
+      }
+    };
+    plugins.push([useBuiltIns === "usage" ? _useBuiltInsPlugin.default : _useBuiltInsEntryPlugin.default, pluginOptions]);
+  }
+
+  return {
+    plugins
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/preset-env/lib/module-transformations.js b/node_modules/@babel/preset-env/lib/module-transformations.js
new file mode 100644
index 00000000..f565785a
--- /dev/null
+++ b/node_modules/@babel/preset-env/lib/module-transformations.js
@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = {
+  amd: "transform-modules-amd",
+  commonjs: "transform-modules-commonjs",
+  cjs: "transform-modules-commonjs",
+  systemjs: "transform-modules-systemjs",
+  umd: "transform-modules-umd"
+};
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/preset-env/lib/normalize-options.js b/node_modules/@babel/preset-env/lib/normalize-options.js
new file mode 100644
index 00000000..178795a3
--- /dev/null
+++ b/node_modules/@babel/preset-env/lib/normalize-options.js
@@ -0,0 +1,152 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = normalizeOptions;
+exports.validateUseBuiltInsOption = exports.objectToBrowserslist = exports.validateModulesOption = exports.validateIgnoreBrowserslistConfig = exports.validateBoolOption = exports.validateConfigPathOption = exports.checkDuplicateIncludeExcludes = exports.normalizePluginName = void 0;
+
+function _invariant() {
+  const data = _interopRequireDefault(require("invariant"));
+
+  _invariant = function _invariant() {
+    return data;
+  };
+
+  return data;
+}
+
+function _browserslist() {
+  const data = _interopRequireDefault(require("browserslist"));
+
+  _browserslist = function _browserslist() {
+    return data;
+  };
+
+  return data;
+}
+
+var _builtIns = _interopRequireDefault(require("../data/built-ins.json"));
+
+var _defaultIncludes = require("./default-includes");
+
+var _moduleTransformations = _interopRequireDefault(require("./module-transformations"));
+
+var _plugins = _interopRequireDefault(require("../data/plugins.json"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const validIncludesAndExcludes = new Set([...Object.keys(_plugins.default), ...Object.keys(_moduleTransformations.default).map(m => _moduleTransformations.default[m]), ...Object.keys(_builtIns.default), ..._defaultIncludes.defaultWebIncludes]);
+
+const pluginToRegExp = plugin => {
+  if (plugin instanceof RegExp) return plugin;
+
+  try {
+    return new RegExp(`^${normalizePluginName(plugin)}$`);
+  } catch (e) {
+    return null;
+  }
+};
+
+const selectPlugins = regexp => Array.from(validIncludesAndExcludes).filter(item => regexp instanceof RegExp && regexp.test(item));
+
+const flatten = array => [].concat(...array);
+
+const expandIncludesAndExcludes = (plugins = [], type) => {
+  if (plugins.length === 0) return [];
+  const selectedPlugins = plugins.map(plugin => selectPlugins(pluginToRegExp(plugin)));
+  const invalidRegExpList = plugins.filter((p, i) => selectedPlugins[i].length === 0);
+  (0, _invariant().default)(invalidRegExpList.length === 0, `Invalid Option: The plugins/built-ins '${invalidRegExpList.join(", ")}' passed to the '${type}' option are not
+    valid. Please check data/[plugin-features|built-in-features].js in babel-preset-env`);
+  return flatten(selectedPlugins);
+};
+
+const validBrowserslistTargets = [...Object.keys(_browserslist().default.data), ...Object.keys(_browserslist().default.aliases)];
+
+const normalizePluginName = plugin => plugin.replace(/^babel-plugin-/, "");
+
+exports.normalizePluginName = normalizePluginName;
+
+const checkDuplicateIncludeExcludes = (include = [], exclude = []) => {
+  const duplicates = include.filter(opt => exclude.indexOf(opt) >= 0);
+  (0, _invariant().default)(duplicates.length === 0, `Invalid Option: The plugins/built-ins '${duplicates.join(", ")}' were found in both the "include" and
+    "exclude" options.`);
+};
+
+exports.checkDuplicateIncludeExcludes = checkDuplicateIncludeExcludes;
+
+const validateConfigPathOption = (configPath = process.cwd()) => {
+  (0, _invariant().default)(typeof configPath === "string", `Invalid Option: The configPath option '${configPath}' is invalid, only strings are allowed.`);
+  return configPath;
+};
+
+exports.validateConfigPathOption = validateConfigPathOption;
+
+const validateBoolOption = (name, value, defaultValue) => {
+  if (typeof value === "undefined") {
+    value = defaultValue;
+  }
+
+  if (typeof value !== "boolean") {
+    throw new Error(`Preset env: '${name}' option must be a boolean.`);
+  }
+
+  return value;
+};
+
+exports.validateBoolOption = validateBoolOption;
+
+const validateIgnoreBrowserslistConfig = ignoreBrowserslistConfig => validateBoolOption("ignoreBrowserslistConfig", ignoreBrowserslistConfig, false);
+
+exports.validateIgnoreBrowserslistConfig = validateIgnoreBrowserslistConfig;
+
+const validateModulesOption = (modulesOpt = "commonjs") => {
+  (0, _invariant().default)(modulesOpt === false || Object.keys(_moduleTransformations.default).indexOf(modulesOpt) > -1, `Invalid Option: The 'modules' option must be either 'false' to indicate no modules, or a
+    module type which can be be one of: 'commonjs' (default), 'amd', 'umd', 'systemjs'.`);
+  return modulesOpt;
+};
+
+exports.validateModulesOption = validateModulesOption;
+
+const objectToBrowserslist = object => {
+  return Object.keys(object).reduce((list, targetName) => {
+    if (validBrowserslistTargets.indexOf(targetName) >= 0) {
+      const targetVersion = object[targetName];
+      return list.concat(`${targetName} ${targetVersion}`);
+    }
+
+    return list;
+  }, []);
+};
+
+exports.objectToBrowserslist = objectToBrowserslist;
+
+const validateUseBuiltInsOption = (builtInsOpt = false) => {
+  (0, _invariant().default)(builtInsOpt === "usage" || builtInsOpt === false || builtInsOpt === "entry", `Invalid Option: The 'useBuiltIns' option must be either
+    'false' (default) to indicate no polyfill,
+    '"entry"' to indicate replacing the entry polyfill, or
+    '"usage"' to import only used polyfills per file`);
+  return builtInsOpt;
+};
+
+exports.validateUseBuiltInsOption = validateUseBuiltInsOption;
+
+function normalizeOptions(opts) {
+  const include = expandIncludesAndExcludes(opts.include, "include");
+  const exclude = expandIncludesAndExcludes(opts.exclude, "exclude");
+  checkDuplicateIncludeExcludes(include, exclude);
+  return {
+    configPath: validateConfigPathOption(opts.configPath),
+    debug: opts.debug,
+    include,
+    exclude,
+    forceAllTransforms: validateBoolOption("forceAllTransforms", opts.forceAllTransforms, false),
+    ignoreBrowserslistConfig: validateIgnoreBrowserslistConfig(opts.ignoreBrowserslistConfig),
+    loose: validateBoolOption("loose", opts.loose, false),
+    modules: validateModulesOption(opts.modules),
+    shippedProposals: validateBoolOption("shippedProposals", opts.shippedProposals, false),
+    spec: validateBoolOption("loose", opts.spec, false),
+    targets: Object.assign({}, opts.targets),
+    useBuiltIns: validateUseBuiltInsOption(opts.useBuiltIns)
+  };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/preset-env/lib/targets-parser.js b/node_modules/@babel/preset-env/lib/targets-parser.js
new file mode 100644
index 00000000..5202a4a4
--- /dev/null
+++ b/node_modules/@babel/preset-env/lib/targets-parser.js
@@ -0,0 +1,172 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.semverMin = void 0;
+
+function _browserslist() {
+  const data = _interopRequireDefault(require("browserslist"));
+
+  _browserslist = function _browserslist() {
+    return data;
+  };
+
+  return data;
+}
+
+function _semver() {
+  const data = _interopRequireDefault(require("semver"));
+
+  _semver = function _semver() {
+    return data;
+  };
+
+  return data;
+}
+
+var _utils = require("./utils");
+
+var _normalizeOptions = require("./normalize-options");
+
+var _builtInModules = _interopRequireDefault(require("../data/built-in-modules.json"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const browserNameMap = {
+  android: "android",
+  chrome: "chrome",
+  and_chr: "chrome",
+  edge: "edge",
+  firefox: "firefox",
+  ie: "ie",
+  ios_saf: "ios",
+  safari: "safari"
+};
+
+const isBrowsersQueryValid = browsers => typeof browsers === "string" || Array.isArray(browsers);
+
+const semverMin = (first, second) => {
+  return first && _semver().default.lt(first, second) ? first : second;
+};
+
+exports.semverMin = semverMin;
+
+const mergeBrowsers = (fromQuery, fromTarget) => {
+  return Object.keys(fromTarget).reduce((queryObj, targKey) => {
+    if (targKey !== "browsers") {
+      queryObj[targKey] = fromTarget[targKey];
+    }
+
+    return queryObj;
+  }, fromQuery);
+};
+
+const getLowestVersions = browsers => {
+  return browsers.reduce((all, browser) => {
+    const _browser$split = browser.split(" "),
+          browserName = _browser$split[0],
+          browserVersion = _browser$split[1];
+
+    const normalizedBrowserName = browserNameMap[browserName];
+
+    if (!normalizedBrowserName) {
+      return all;
+    }
+
+    try {
+      const splitVersion = browserVersion.split("-")[0].toLowerCase();
+
+      if ((0, _utils.isUnreleasedVersion)(splitVersion, browserName)) {
+        all[normalizedBrowserName] = (0, _utils.getLowestUnreleased)(all[normalizedBrowserName], splitVersion, browserName);
+      }
+
+      const parsedBrowserVersion = (0, _utils.semverify)(splitVersion);
+      all[normalizedBrowserName] = semverMin(all[normalizedBrowserName], parsedBrowserVersion);
+    } catch (e) {}
+
+    return all;
+  }, {});
+};
+
+const outputDecimalWarning = decimalTargets => {
+  if (!decimalTargets || !decimalTargets.length) {
+    return;
+  }
+
+  console.log("Warning, the following targets are using a decimal version:");
+  console.log("");
+  decimalTargets.forEach(({
+    target,
+    value
+  }) => console.log(`  ${target}: ${value}`));
+  console.log("");
+  console.log("We recommend using a string for minor/patch versions to avoid numbers like 6.10");
+  console.log("getting parsed as 6.1, which can lead to unexpected behavior.");
+  console.log("");
+};
+
+const targetParserMap = {
+  __default: (target, value) => {
+    const version = (0, _utils.isUnreleasedVersion)(value, target) ? value.toLowerCase() : (0, _utils.semverify)(value);
+    return [target, version];
+  },
+  node: (target, value) => {
+    const parsed = value === true || value === "current" ? process.versions.node : (0, _utils.semverify)(value);
+    return [target, parsed];
+  }
+};
+
+const getTargets = (targets = {}, options = {}) => {
+  const targetOpts = {};
+
+  if (targets.esmodules) {
+    const supportsESModules = _builtInModules.default["es6.module"];
+    targets.browsers = Object.keys(supportsESModules).map(browser => `${browser} ${supportsESModules[browser]}`).join(", ");
+  }
+
+  const queryIsValid = isBrowsersQueryValid(targets.browsers);
+  const browsersquery = queryIsValid ? targets.browsers : null;
+
+  if (queryIsValid || !options.ignoreBrowserslistConfig) {
+    _browserslist().default.defaults = (0, _normalizeOptions.objectToBrowserslist)(targets);
+    const browsers = (0, _browserslist().default)(browsersquery, {
+      path: options.configPath
+    });
+    const queryBrowsers = getLowestVersions(browsers);
+    targets = mergeBrowsers(queryBrowsers, targets);
+  }
+
+  const parsed = Object.keys(targets).filter(value => value !== "esmodules").sort().reduce((results, target) => {
+    if (target !== "browsers") {
+      const value = targets[target];
+
+      if (typeof value === "number" && value % 1 !== 0) {
+        results.decimalWarnings.push({
+          target,
+          value
+        });
+      }
+
+      const parser = targetParserMap[target] || targetParserMap.__default;
+
+      const _parser = parser(target, value),
+            parsedTarget = _parser[0],
+            parsedValue = _parser[1];
+
+      if (parsedValue) {
+        results.targets[parsedTarget] = parsedValue;
+      }
+    }
+
+    return results;
+  }, {
+    targets: targetOpts,
+    decimalWarnings: []
+  });
+  outputDecimalWarning(parsed.decimalWarnings);
+  return parsed.targets;
+};
+
+var _default = getTargets;
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/preset-env/lib/use-built-ins-entry-plugin.js b/node_modules/@babel/preset-env/lib/use-built-ins-entry-plugin.js
new file mode 100644
index 00000000..27cbe952
--- /dev/null
+++ b/node_modules/@babel/preset-env/lib/use-built-ins-entry-plugin.js
@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+var _debug = require("./debug");
+
+var _utils = require("./utils");
+
+function _default({
+  types: t
+}) {
+  function replaceWithPolyfillImports(path, polyfills, regenerator) {
+    if (regenerator) {
+      (0, _utils.createImport)(path, "regenerator-runtime");
+    }
+
+    const items = Array.isArray(polyfills) ? new Set(polyfills) : polyfills;
+
+    for (var _iterator = Array.from(items).reverse(), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i >= _iterator.length) break;
+        _ref = _iterator[_i++];
+      } else {
+        _i = _iterator.next();
+        if (_i.done) break;
+        _ref = _i.value;
+      }
+
+      const p = _ref;
+      (0, _utils.createImport)(path, p);
+    }
+
+    path.remove();
+  }
+
+  const isPolyfillImport = {
+    ImportDeclaration(path, state) {
+      if (path.node.specifiers.length === 0 && (0, _utils.isPolyfillSource)(path.node.source.value)) {
+        this.importPolyfillIncluded = true;
+        replaceWithPolyfillImports(path, state.opts.polyfills, state.opts.regenerator);
+      }
+    },
+
+    Program(path, state) {
+      path.get("body").forEach(bodyPath => {
+        if ((0, _utils.isRequire)(t, bodyPath)) {
+          replaceWithPolyfillImports(bodyPath, state.opts.polyfills, state.opts.regenerator);
+        }
+      });
+    }
+
+  };
+  return {
+    name: "transform-polyfill-require",
+    visitor: isPolyfillImport,
+
+    pre() {
+      this.numPolyfillImports = 0;
+      this.importPolyfillIncluded = false;
+    },
+
+    post() {
+      const _this$opts = this.opts,
+            debug = _this$opts.debug,
+            onDebug = _this$opts.onDebug,
+            polyfills = _this$opts.polyfills;
+
+      if (debug) {
+        (0, _debug.logEntryPolyfills)(this.importPolyfillIncluded, polyfills, this.file.opts.filename, onDebug);
+      }
+    }
+
+  };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/preset-env/lib/use-built-ins-plugin.js b/node_modules/@babel/preset-env/lib/use-built-ins-plugin.js
new file mode 100644
index 00000000..cf00b794
--- /dev/null
+++ b/node_modules/@babel/preset-env/lib/use-built-ins-plugin.js
@@ -0,0 +1,245 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+var _builtInDefinitions = require("./built-in-definitions");
+
+var _debug = require("./debug");
+
+var _utils = require("./utils");
+
+function has(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+function getType(target) {
+  if (Array.isArray(target)) return "array";
+  return typeof target;
+}
+
+function _default({
+  types: t
+}) {
+  function addImport(path, builtIn, builtIns) {
+    if (builtIn && !builtIns.has(builtIn)) {
+      builtIns.add(builtIn);
+      (0, _utils.createImport)(path, builtIn);
+    }
+  }
+
+  function addUnsupported(path, polyfills, builtIn, builtIns) {
+    if (Array.isArray(builtIn)) {
+      for (var _iterator = builtIn, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+        var _ref;
+
+        if (_isArray) {
+          if (_i >= _iterator.length) break;
+          _ref = _iterator[_i++];
+        } else {
+          _i = _iterator.next();
+          if (_i.done) break;
+          _ref = _i.value;
+        }
+
+        const i = _ref;
+
+        if (polyfills.has(i)) {
+          addImport(path, i, builtIns);
+        }
+      }
+    } else {
+      if (polyfills.has(builtIn)) {
+        addImport(path, builtIn, builtIns);
+      }
+    }
+  }
+
+  const addAndRemovePolyfillImports = {
+    ImportDeclaration(path) {
+      if (path.node.specifiers.length === 0 && (0, _utils.isPolyfillSource)(path.node.source.value)) {
+        console.warn(`
+  When setting \`useBuiltIns: 'usage'\`, polyfills are automatically imported when needed.
+  Please remove the \`import '@babel/polyfill'\` call or use \`useBuiltIns: 'entry'\` instead.`);
+        path.remove();
+      }
+    },
+
+    Program: {
+      enter(path) {
+        path.get("body").forEach(bodyPath => {
+          if ((0, _utils.isRequire)(t, bodyPath)) {
+            console.warn(`
+  When setting \`useBuiltIns: 'usage'\`, polyfills are automatically imported when needed.
+  Please remove the \`require('@babel/polyfill')\` call or use \`useBuiltIns: 'entry'\` instead.`);
+            bodyPath.remove();
+          }
+        });
+      }
+
+    },
+
+    ReferencedIdentifier(path, state) {
+      const node = path.node,
+            parent = path.parent,
+            scope = path.scope;
+      if (t.isMemberExpression(parent)) return;
+      if (!has(_builtInDefinitions.definitions.builtins, node.name)) return;
+      if (scope.getBindingIdentifier(node.name)) return;
+      const builtIn = _builtInDefinitions.definitions.builtins[node.name];
+      addUnsupported(path, state.opts.polyfills, builtIn, this.builtIns);
+    },
+
+    CallExpression(path) {
+      if (path.node.arguments.length) return;
+      const callee = path.node.callee;
+      if (!t.isMemberExpression(callee)) return;
+      if (!callee.computed) return;
+
+      if (!path.get("callee.property").matchesPattern("Symbol.iterator")) {
+        return;
+      }
+
+      addImport(path, "web.dom.iterable", this.builtIns);
+    },
+
+    BinaryExpression(path) {
+      if (path.node.operator !== "in") return;
+      if (!path.get("left").matchesPattern("Symbol.iterator")) return;
+      addImport(path, "web.dom.iterable", this.builtIns);
+    },
+
+    YieldExpression(path) {
+      if (!path.node.delegate) return;
+      addImport(path, "web.dom.iterable", this.builtIns);
+    },
+
+    MemberExpression: {
+      enter(path, state) {
+        if (!path.isReferenced()) return;
+        const node = path.node;
+        const obj = node.object;
+        const prop = node.property;
+        if (!t.isReferenced(obj, node)) return;
+        let instanceType;
+        let evaluatedPropType = obj.name;
+        let propName = prop.name;
+
+        if (node.computed) {
+          if (t.isStringLiteral(prop)) {
+            propName = prop.value;
+          } else {
+            const res = path.get("property").evaluate();
+
+            if (res.confident && res.value) {
+              propName = res.value;
+            }
+          }
+        }
+
+        if (path.scope.getBindingIdentifier(obj.name)) {
+          const result = path.get("object").evaluate();
+
+          if (result.value) {
+            instanceType = getType(result.value);
+          } else if (result.deopt && result.deopt.isIdentifier()) {
+            evaluatedPropType = result.deopt.node.name;
+          }
+        }
+
+        if (has(_builtInDefinitions.definitions.staticMethods, evaluatedPropType)) {
+          const staticMethods = _builtInDefinitions.definitions.staticMethods[evaluatedPropType];
+
+          if (has(staticMethods, propName)) {
+            const builtIn = staticMethods[propName];
+            addUnsupported(path, state.opts.polyfills, builtIn, this.builtIns);
+          }
+        }
+
+        if (has(_builtInDefinitions.definitions.instanceMethods, propName)) {
+          let builtIn = _builtInDefinitions.definitions.instanceMethods[propName];
+
+          if (instanceType) {
+            builtIn = builtIn.filter(item => item.includes(instanceType));
+          }
+
+          addUnsupported(path, state.opts.polyfills, builtIn, this.builtIns);
+        }
+      },
+
+      exit(path, state) {
+        if (!path.isReferenced()) return;
+        const node = path.node;
+        const obj = node.object;
+        if (!has(_builtInDefinitions.definitions.builtins, obj.name)) return;
+        if (path.scope.getBindingIdentifier(obj.name)) return;
+        const builtIn = _builtInDefinitions.definitions.builtins[obj.name];
+        addUnsupported(path, state.opts.polyfills, builtIn, this.builtIns);
+      }
+
+    },
+
+    VariableDeclarator(path, state) {
+      if (!path.isReferenced()) return;
+      const node = path.node;
+      const obj = node.init;
+      if (!t.isObjectPattern(node.id)) return;
+      if (!t.isReferenced(obj, node)) return;
+      if (obj && path.scope.getBindingIdentifier(obj.name)) return;
+
+      for (var _iterator2 = node.id.properties, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+        var _ref2;
+
+        if (_isArray2) {
+          if (_i2 >= _iterator2.length) break;
+          _ref2 = _iterator2[_i2++];
+        } else {
+          _i2 = _iterator2.next();
+          if (_i2.done) break;
+          _ref2 = _i2.value;
+        }
+
+        let prop = _ref2;
+        prop = prop.key;
+
+        if (!node.computed && t.isIdentifier(prop) && has(_builtInDefinitions.definitions.instanceMethods, prop.name)) {
+          const builtIn = _builtInDefinitions.definitions.instanceMethods[prop.name];
+          addUnsupported(path, state.opts.polyfills, builtIn, this.builtIns);
+        }
+      }
+    },
+
+    Function(path, state) {
+      if (!this.usesRegenerator && (path.node.generator || path.node.async)) {
+        this.usesRegenerator = true;
+
+        if (state.opts.regenerator) {
+          addImport(path, "regenerator-runtime", this.builtIns);
+        }
+      }
+    }
+
+  };
+  return {
+    name: "use-built-ins",
+
+    pre() {
+      this.builtIns = new Set();
+      this.usesRegenerator = false;
+    },
+
+    post() {
+      const _this$opts = this.opts,
+            debug = _this$opts.debug,
+            onDebug = _this$opts.onDebug;
+
+      if (debug) {
+        (0, _debug.logUsagePolyfills)(this.builtIns, this.file.opts.filename, onDebug);
+      }
+    },
+
+    visitor: addAndRemovePolyfillImports
+  };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/preset-env/lib/utils.js b/node_modules/@babel/preset-env/lib/utils.js
new file mode 100644
index 00000000..f09c4da5
--- /dev/null
+++ b/node_modules/@babel/preset-env/lib/utils.js
@@ -0,0 +1,139 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isRequire = exports.createImport = exports.getModulePath = exports.isPolyfillSource = exports.filterStageFromList = exports.getLowestUnreleased = exports.isUnreleasedVersion = exports.prettifyTargets = exports.prettifyVersion = exports.semverify = void 0;
+
+function _semver() {
+  const data = _interopRequireDefault(require("semver"));
+
+  _semver = function _semver() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperModuleImports() {
+  const data = require("@babel/helper-module-imports");
+
+  _helperModuleImports = function _helperModuleImports() {
+    return data;
+  };
+
+  return data;
+}
+
+var _unreleasedLabels = _interopRequireDefault(require("../data/unreleased-labels"));
+
+var _targetsParser = require("./targets-parser");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const semverify = version => {
+  if (typeof version === "string" && _semver().default.valid(version)) {
+    return version;
+  }
+
+  const split = version.toString().split(".");
+
+  while (split.length < 3) {
+    split.push("0");
+  }
+
+  return split.join(".");
+};
+
+exports.semverify = semverify;
+
+const prettifyVersion = version => {
+  if (typeof version !== "string") {
+    return version;
+  }
+
+  const parts = [_semver().default.major(version)];
+
+  const minor = _semver().default.minor(version);
+
+  const patch = _semver().default.patch(version);
+
+  if (minor || patch) {
+    parts.push(minor);
+  }
+
+  if (patch) {
+    parts.push(patch);
+  }
+
+  return parts.join(".");
+};
+
+exports.prettifyVersion = prettifyVersion;
+
+const prettifyTargets = targets => {
+  return Object.keys(targets).reduce((results, target) => {
+    let value = targets[target];
+    const unreleasedLabel = _unreleasedLabels.default[target];
+
+    if (typeof value === "string" && unreleasedLabel !== value) {
+      value = prettifyVersion(value);
+    }
+
+    results[target] = value;
+    return results;
+  }, {});
+};
+
+exports.prettifyTargets = prettifyTargets;
+
+const isUnreleasedVersion = (version, env) => {
+  const unreleasedLabel = _unreleasedLabels.default[env];
+  return !!unreleasedLabel && unreleasedLabel === version.toString().toLowerCase();
+};
+
+exports.isUnreleasedVersion = isUnreleasedVersion;
+
+const getLowestUnreleased = (a, b, env) => {
+  const unreleasedLabel = _unreleasedLabels.default[env];
+  const hasUnreleased = [a, b].some(item => item === unreleasedLabel);
+
+  if (hasUnreleased) {
+    return a === hasUnreleased ? b : a || b;
+  }
+
+  return (0, _targetsParser.semverMin)(a, b);
+};
+
+exports.getLowestUnreleased = getLowestUnreleased;
+
+const filterStageFromList = (list, stageList) => {
+  return Object.keys(list).reduce((result, item) => {
+    if (!stageList[item]) {
+      result[item] = list[item];
+    }
+
+    return result;
+  }, {});
+};
+
+exports.filterStageFromList = filterStageFromList;
+
+const isPolyfillSource = source => source === "@babel/polyfill" || source === "core-js";
+
+exports.isPolyfillSource = isPolyfillSource;
+const modulePathMap = {
+  "regenerator-runtime": "regenerator-runtime/runtime"
+};
+
+const getModulePath = mod => modulePathMap[mod] || `core-js/modules/${mod}`;
+
+exports.getModulePath = getModulePath;
+
+const createImport = (path, mod) => (0, _helperModuleImports().addSideEffect)(path, getModulePath(mod));
+
+exports.createImport = createImport;
+
+const isRequire = (t, path) => t.isExpressionStatement(path.node) && t.isCallExpression(path.node.expression) && t.isIdentifier(path.node.expression.callee) && path.node.expression.callee.name === "require" && path.node.expression.arguments.length === 1 && t.isStringLiteral(path.node.expression.arguments[0]) && isPolyfillSource(path.node.expression.arguments[0].value);
+
+exports.isRequire = isRequire;
\ No newline at end of file
diff --git a/node_modules/@babel/preset-env/node_modules/.bin/browserslist b/node_modules/@babel/preset-env/node_modules/.bin/browserslist
new file mode 120000
index 00000000..3cd991b2
--- /dev/null
+++ b/node_modules/@babel/preset-env/node_modules/.bin/browserslist
@@ -0,0 +1 @@
+../browserslist/cli.js
\ No newline at end of file
diff --git a/node_modules/@babel/preset-env/node_modules/.bin/semver b/node_modules/@babel/preset-env/node_modules/.bin/semver
new file mode 120000
index 00000000..7a17f06e
--- /dev/null
+++ b/node_modules/@babel/preset-env/node_modules/.bin/semver
@@ -0,0 +1 @@
+../../../../semver/bin/semver
\ No newline at end of file
diff --git a/node_modules/@babel/preset-env/node_modules/browserslist/.bin/browserslist b/node_modules/@babel/preset-env/node_modules/browserslist/.bin/browserslist
new file mode 120000
index 00000000..9fbea327
--- /dev/null
+++ b/node_modules/@babel/preset-env/node_modules/browserslist/.bin/browserslist
@@ -0,0 +1 @@
+../cli.js
\ No newline at end of file
diff --git a/node_modules/@babel/preset-env/node_modules/browserslist/CHANGELOG.md b/node_modules/@babel/preset-env/node_modules/browserslist/CHANGELOG.md
new file mode 100644
index 00000000..5d67c0f8
--- /dev/null
+++ b/node_modules/@babel/preset-env/node_modules/browserslist/CHANGELOG.md
@@ -0,0 +1,288 @@
+# Change Log
+This project adheres to [Semantic Versioning](http://semver.org/).
+
+## 3.2.8
+* Add IE 9-5.5 to dead browsers.
+* Remove development configs from npm package.
+
+## 3.2.7
+* Add Firefox 60 as Firefox ESR.
+
+## 3.2.6
+* Add Opera Mini 12 to dead browsers.
+* Update docs (by Jamie Kyle).
+
+## 3.2.5
+* Fix excluding Opera Mini and other browsers with `all` version.
+
+## 3.2.4
+* Resolve shareable config from current working directory.
+
+## 3.2.3
+* Fix `package.json` config validation for single string case.
+* Fix CLI error reporting.
+
+## 3.2.2
+* Add `package.json` config validation.
+* Move project to `browserlist` GitHub organization.
+
+## 3.2.1
+* Fix error text (by Steve Schrab).
+
+## 3.2
+* Add `cover 99%` query (by Vasily Fedoseyev).
+* Add `cover 99% in US` query (by Vasily Fedoseyev).
+* Add `cover 99% in my stats` query (by Vasily Fedoseyev).
+* Add `"my stats"` support to `browserlist.coverage()` (by Vasily Fedoseyev).
+
+## 3.1.2
+* Add more clear error on missed browser version.
+
+## 3.1.1
+* Fix JSDoc (by Sylvain Pollet-Villard).
+
+## 3.1
+* Add `ignoreUnknownVersions` option.
+* Fix docs (by Pascal Duez).
+
+## 3.0
+* Remove country statistics from client-side build of Browserslist.
+* Change `> 1%` to `> 0.5%` in default query.
+* Add `not dead` to default query.
+* Change default environment to `production` (by Marco Fugaro).
+* Add `dead` query support with IE 10 and BlackBerry browser.
+* Add multiple environments in one section support (by Evilebot Tnawi).
+* Add custom statistics support to `browserlist.coverage()`.
+* Fix `path` option check.
+
+## 2.11.3
+* Fix for `path: undefined` option.
+
+## 2.11.2
+* Remove Node.js specific code from webpack build.
+
+## 2.11.1
+* Fix using Browserslist in browser with `path` but without `fs`.
+
+## 2.11
+* Add `last 2 years` query support (by James Harris).
+
+## 2.10.2
+* Fix Browserify support.
+
+## 2.10.1
+* Fix using Browserslist without `process` (by Andrew Patton).
+
+## 2.10
+* Add `< 1%` and `<= 1%` queries support (by August Kaiser).
+
+## 2.9.1
+* Fix unknown query on trailing spaces in query.
+
+## 2.9
+* Add `last Electron versions` and `last Electron major versions` queries
+  (by Louis Mouhat).
+
+## 2.8
+* Add `since 2016-03` and `since 2016-03-20` queries support (by Andrew Blick).
+
+## 2.7
+* Add `since 2016` queries support (by Igor Deryabin).
+
+## 2.6.1
+* Fix `Path must be a string` error.
+
+## 2.6
+* By default load config from current directory in CLI tool.
+
+## 2.5.1
+* Allow `@scope/browserlist-config` config name (by Jamie Connolly).
+
+## 2.5
+* Add `extends` query (by YellowKirby).
+
+## 2.4.1
+* Throw error if `package.json` contain `browserlist` instead of `browserslist`.
+
+## 2.4
+* Add `last n major versions` query (by John Sanders).
+
+## 2.3.3
+* Fix browsers support.
+
+## 2.3.2
+* Fix `> 0` query for browsers with one version (by Nikolay Solovyov).
+
+## 2.3.1
+* Reduce library size.
+
+## 2.3
+* Add `unreleased versions` and `unreleased Chrome versions` queries.
+
+## 2.2.2
+* Fix `Path must be a string` error (by Pieter Beulque).
+
+## 2.2.1
+* Fix security issue with regions dynamic `require`.
+
+## 2.2
+* Add region usage statistics support (by Clément P).
+
+## 2.1.5
+* Remove Firefox 45 from Firefox ESR.
+
+## 2.1.4
+* Use both ESR versions when they actual.
+
+## 2.1.3
+* Add warning on first exclude query.
+
+## 2.1.2
+* Fix non-Node.js environments support.
+
+## 2.1.1
+* Fix CLI arguments parsing.
+
+## 2.1
+* Add `>= 5%`, `>= 5% in US` and `>= 5% in my stats` queries.
+
+## 2.0
+* `last n versions` returns versions for all browsers, not only main browsers.
+* Cache file system operations (by Aarni Koskela).
+* Use `caniuse-lite` 1 MB instead of `caniuse-db` 7 MB (by Ben Briggs).
+* Add `.browserslistrc` config support.
+* Add QQ Browser for Android support.
+* Add tests for CLI (by Zhulduz Zhankenova).
+
+## 1.7.7
+* Update Firefox ESR.
+
+## 1.7.6
+* Fix Android Chrome selection.
+
+## 1.7.5
+* Fix combining `not` query with country based statistics.
+* Fix `--env` argument in CLI (by Tuure Savuoja).
+
+## 1.7.4
+* Speed up browser sorting (by Aarni Koskela).
+
+## 1.7.3
+* Fix config finding when directory was passed to `path` (by Aarni Koskela).
+
+## 1.7.2
+* Fix config finding algorithm (by Aarni Koskela).
+
+## 1.7.1
+* Fix unreleased browsers version detection.
+
+## 1.7
+* Add `--config` and `--env` arguments to CLI (by Jarek Rencz).
+
+## 1.6
+* Convert Electron version to Chrome (by Kilian Valkhof).
+* Fix `0` version mistake in Can I Use data.
+
+## 1.5.2
+* Fix browser versions ordering (by Marco Massarotto).
+
+## 1.5.1
+* Fix error on `package.json` and `browserslist` in same directory.
+
+## 1.5
+* Add `package.json` support (by Stepan Kuzmin).
+* Add environments support (by Maksim Semenov and openlibser).
+* Add `browserslist-stats.json` file support (by Oleh Aloshkin).
+* Add `config` option to CLI (by Evilebot Tnawi).
+* Add JSDoc.
+* Fix tests on Windows (by Anna Stoliar).
+* Don’t set custom usage statistics globally.
+
+## 1.4
+* Add `defaults` keyword.
+
+## 1.3.6
+* Add `UCAndroid` alias to `and_uc` (by Evilebot Tnawi).
+
+## 1.3.5
+* Fix Opera Mini support. Use `op_mini all`.
+
+## 1.3.4
+* Add space-less `>1%` and `>.5%` syntax support (by Andreas Lind).
+
+## 1.3.3
+* Clean `0` versions in some country-based requests.
+
+## 1.3.2
+* Update Firefox ESR.
+
+## 1.3.1
+* Add Safari TP support.
+
+## 1.3
+* Add coverage for specific country (by Joshua Wise).
+
+## 1.2
+* Add `browserslist.coverage()` method.
+* Add `--coverage` and `-c` argument to CLI.
+* Add `-v` argument support to CLI.
+* Better error handling in CLI.
+
+## 1.1.3
+* Fix jspm support (by Sean Anderson).
+
+## 1.1.2
+* Fix jspm support (by Sean Anderson).
+
+## 1.1.1
+* Fix space-less `>10%` and `>10% in my stats` queries.
+* Normalize error messages.
+* Remove development files from npm package.
+
+## 1.1
+* Added query against custom browser usage data (by Daniel Rey).
+
+## 1.0.1
+* Update Firefox ESR (by Rouven Weßling).
+
+## 1.0
+* Remove Opera 12.1 from default query.
+* Add `not` keyword and exclude browsers by query.
+* Add Microsoft Edge support (by Andrey Polischuk).
+* Add CLI for debug and non-JS usage (by Luke Horvat).
+* Use own class in Browserslist errors.
+
+## 0.5
+* Add version ranges `IE 6-9` (by Ben Briggs).
+
+## 0.4
+* Add `config` option and `BROWSERSLIST_CONFIG` environment variable support.
+* Add symlink config support.
+
+## 0.3.3
+* Fix DynJS compatibility (by Nick Howes).
+
+## 0.3.2
+* Fix joined versions on versions query (by Vincent De Oliveira).
+
+## 0.3.1
+* Fix global variable leak (by Peter Müller).
+
+## 0.3
+* Takes queries from `BROWSERSLIST` environment variable.
+
+## 0.2
+* Return Can I Use joined versions as `ios_saf 7.0-7.1`.
+
+## 0.1.3
+* Better work with Can I Use joined versions like `ios_saf 7.0-7.1`.
+* Browserslist now understands `ios_saf 7.0` or `ios_saf 7`.
+
+## 0.1.2
+* Do not create global `browserslist` var (by Maxime Thirouin).
+
+## 0.1.1
+* Sort browsers by name and version.
+
+## 0.1
+* Initial release.
diff --git a/node_modules/@babel/preset-env/node_modules/browserslist/LICENSE b/node_modules/@babel/preset-env/node_modules/browserslist/LICENSE
new file mode 100644
index 00000000..1ae47a20
--- /dev/null
+++ b/node_modules/@babel/preset-env/node_modules/browserslist/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright 2014 Andrey Sitnik <andrey@sitnik.ru>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/@babel/preset-env/node_modules/browserslist/README.md b/node_modules/@babel/preset-env/node_modules/browserslist/README.md
new file mode 100644
index 00000000..da204c1b
--- /dev/null
+++ b/node_modules/@babel/preset-env/node_modules/browserslist/README.md
@@ -0,0 +1,516 @@
+# Browserslist [![Cult Of Martians][cult-img]][cult]
+
+<img align="right" width="120" height="120"
+     src="./logo.svg" alt="Browserslist logo by Anton Lovchikov">
+
+Library to share target browsers between different front-end tools.
+It is used in:
+
+* [Autoprefixer]
+* [Babel]
+  (external config in `package.json` or `browserslist` will be supported in 7.0)
+* [postcss-preset-env]
+* [eslint-plugin-compat]
+* [stylelint-no-unsupported-browser-features]
+* [postcss-normalize]
+
+[Browserslist Example] shows how every tool uses Browserslist.
+All tools will find target browsers automatically,
+when you add the following to `package.json`:
+
+```json
+{
+  "browserslist": [
+    "> 1%",
+    "IE 10"
+  ]
+}
+```
+
+Or in `.browserslistrc` config:
+
+```yaml
+# Browsers that we support
+
+> 1%
+IE 10 # sorry
+```
+
+Developers set browsers list in queries like `last 2 version`
+to be free from updating browser versions manually.
+Browserslist will use [Can I Use] data for this queries.
+
+Browserslist will take browsers queries from tool option,
+`browserslist` config, `.browserslistrc` config,
+`browserslist` section in `package.json` or environment variables.
+
+You can test Browserslist queries in [online demo].
+
+[cult-img]: http://cultofmartians.com/assets/badges/badge.svg
+[cult]: http://cultofmartians.com/done.html
+
+<a href="https://evilmartians.com/?utm_source=browserslist">
+  <img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg"
+       alt="Sponsored by Evil Martians" width="236" height="54">
+</a>
+
+[stylelint-no-unsupported-browser-features]: https://github.com/ismay/stylelint-no-unsupported-browser-features
+[eslint-plugin-compat]:                      https://github.com/amilajack/eslint-plugin-compat
+[Browserslist Example]:                       https://github.com/browserslist/browserslist-example
+[postcss-preset-env]:                        https://github.com/jonathantneal/postcss-preset-env
+[postcss-normalize]:                         https://github.com/jonathantneal/postcss-normalize
+[Autoprefixer]:                              https://github.com/postcss/autoprefixer
+[online demo]:                               http://browserl.ist/
+[Can I Use]:                                 http://caniuse.com/
+[Babel]:                          https://github.com/babel/babel/tree/master/packages/babel-preset-env
+
+## Tools
+
+* [`browserslist-ga`] downloads your website browsers statistics
+  to use it in `> 0.5% in my stats` query.
+* [`browserslist-useragent`] checks browser by user agent string
+  to match Browserslist target browsers query.
+* [`browserslist-useragent-ruby`] is a Ruby library to checks browser
+  by user agent string to match Browserslist.
+* [`caniuse-api`] returns browsers which support some specific feature.
+* Run `npx browserslist` in your project directory to see project’s
+  target browsers. This CLI tool is built-in and available in any project
+  with Autoprefixer.
+
+[`browserslist-useragent-ruby`]: https://github.com/browserslist/browserslist-useragent-ruby
+[`browserslist-useragent`]:      https://github.com/pastelsky/browserslist-useragent
+[`browserslist-ga`]:             https://github.com/browserslist/browserslist-ga
+[`caniuse-api`]:                 https://github.com/Nyalab/caniuse-api
+
+
+## Queries
+
+Browserslist will use browsers query from one of this sources:
+
+1. Tool options. For example `browsers` option in Autoprefixer.
+2. `BROWSERSLIST` environment variable.
+3. `browserslist` config file in current or parent directories.
+3. `.browserslistrc` config file in current or parent directories.
+4. `browserslist` key in `package.json` file in current or parent directories.
+   **We recommend this way.**
+5. If the above methods did not produce a valid result
+   Browserslist will use defaults:
+   `> 0.5%, last 2 versions, Firefox ESR, not dead`.
+
+
+### Best Practices
+
+* Select browsers directly (`last 2 Chrome versions`) only if you are making
+  web app for kiosk with one browser. There are a lot browsers on the market.
+  If you are making general web app you should respect browsers diversity.
+* If you want to change the default set of browsers we recommend to combine
+  `last 1 version`, `not dead` with `> 0.2%` (or `> 1% in US`,
+  `> 1% in my stats`). Just `last n versions` adds to many dead browsers
+  and do not add popular old versions. Just `> 0.2%` make popular browsers even
+  more popular, so we will have a monopoly and stagnation, as we had
+  with Internet Explorer 6.
+* Don’t remove browsers just because you don’t know them. Opera Mini has
+  100 million users in Africa and it is more popular in global market,
+  than Microsoft Edge. Chinese QQ Browsers has more market share than Firefox
+  and desktop Safari altogether.
+
+
+### Full List
+
+You can specify the versions by queries (case insensitive):
+
+* `> 5%`: versions selected by global usage statistics.
+  `>=`, `<` and `<=` work too.
+* `> 5% in US`: uses USA usage statistics. It accepts [two-letter country code].
+* `> 5% in alt-AS`: uses Asia region usage statistics. List of all region codes
+  can be found at [`caniuse-lite/data/regions`].
+* `> 5% in my stats`: uses [custom usage data].
+* `cover 99.5%`: most popular browsers that provide coverage.
+* `cover 99.5% in US`: same as above, with [two-letter country code].
+* `cover 99.5% in my stats`: uses [custom usage data].
+* `extends browserslist-config-mycompany`: take queries from
+  `browserslist-config-mycompany` npm package.
+* `ie 6-8`: selects an inclusive range of versions.
+* `Firefox > 20`: versions of Firefox newer than 20.
+  `>=`, `<` and `<=` work too.
+* `iOS 7`: the iOS browser version 7 directly.
+* `Firefox ESR`: the latest [Firefox ESR] version.
+* `unreleased versions` or `unreleased Chrome versions`:
+  alpha and beta versions.
+* `last 2 major versions` or `last 2 iOS major versions`:
+  all minor/patch releases of last 2 major versions.
+* `since 2015` or `last 2 years`: all versions released since year 2015
+  (also `since 2015-03` and `since 2015-03-10`).
+* `dead`: browsers from `last 2 version` query, but with less than 0.5%
+  in global usage statistics and without official support or updates
+  for 24 months. Right now it is `IE 10`, `IE_Mob 10`, `BlackBerry 10`,
+  `BlackBerry 7`, and `OperaMobile 12.1`.
+* `last 2 versions`: the last 2 versions for *each* browser.
+* `last 2 Chrome versions`: the last 2 versions of Chrome browser.
+* `defaults`: Browserslist’s default browsers
+  (`> 0.5%, last 2 versions, Firefox ESR, not dead`).
+* `not ie <= 8`: exclude browsers selected by previous queries.
+
+You can add `not ` to any query.
+
+
+### Debug
+
+Run `npx browserslist` in project directory to see what browsers was selected
+by your queries.
+
+```sh
+$ npx browserslist
+and_chr 61
+and_ff 56
+and_qq 1.2
+and_uc 11.4
+android 56
+baidu 7.12
+bb 10
+chrome 62
+edge 16
+firefox 56
+ios_saf 11
+opera 48
+safari 11
+samsung 5
+```
+
+
+### Notes
+
+Browserslist works with separated versions of browsers.
+You should avoid queries like `Firefox > 0`.
+
+Multiple criteria are combined as a boolean `OR`. A browser version must match
+at least one of the criteria to be selected.
+
+All queries are based on the [Can I Use] support table,
+e.g. `last 3 iOS versions` might select `8.4, 9.2, 9.3` (mixed major and minor),
+whereas `last 3 Chrome versions` might select `50, 49, 48` (major only).
+
+[`caniuse-lite/data/regions`]: https://github.com/ben-eb/caniuse-lite/tree/master/data/regions
+[two-letter country code]:     http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2#Officially_assigned_code_elements
+[custom usage data]:           #custom-usage-data
+[Can I Use]:                   http://caniuse.com/
+
+
+### Browsers
+
+Names are case insensitive:
+
+* `Android` for Android WebView.
+* `Baidu` for Baidu Browser.
+* `BlackBerry` or `bb` for Blackberry browser.
+* `Chrome` for Google Chrome.
+* `ChromeAndroid` or `and_chr` for Chrome for Android
+* `Edge` for Microsoft Edge.
+* `Electron` for Electron framework. It will be converted to Chrome version.
+* `Explorer` or `ie` for Internet Explorer.
+* `ExplorerMobile` or `ie_mob` for Internet Explorer Mobile.
+* `Firefox` or `ff` for Mozilla Firefox.
+* `FirefoxAndroid` or `and_ff` for Firefox for Android.
+* `iOS` or `ios_saf` for iOS Safari.
+* `Opera` for Opera.
+* `OperaMini` or `op_mini` for Opera Mini.
+* `OperaMobile` or `op_mob` for Opera Mobile.
+* `QQAndroid` or `and_qq` for QQ Browser for Android.
+* `Safari` for desktop Safari.
+* `Samsung` for Samsung Internet.
+* `UCAndroid` or `and_uc` for UC Browser for Android.
+
+
+## `package.json`
+
+If you want to reduce config files in project root, you can specify
+browsers in `package.json` with `browserslist` key:
+
+```json
+{
+  "private": true,
+  "dependencies": {
+    "autoprefixer": "^6.5.4"
+  },
+  "browserslist": [
+    "> 1%",
+    "IE 10"
+  ]
+}
+```
+
+
+## Config File
+
+Browserslist config should be named `.browserslistrc` or `browserslist`
+and have browsers queries split by a new line. Comments starts with `#` symbol:
+
+```yaml
+# Browsers that we support
+
+> 1%
+IE 10 # sorry
+```
+
+Browserslist will check config in every directory in `path`.
+So, if tool process `app/styles/main.css`, you can put config to root,
+`app/` or `app/styles`.
+
+You can specify direct path in `BROWSERSLIST_CONFIG` environment variables.
+
+
+## Shareable Configs
+
+You can use the following query to reference an exported Browserslist config
+from another package:
+
+```json
+  "browserslist": [
+    "extends browserslist-config-mycompany"
+  ]
+```
+
+For security reasons, external configuration only supports packages that have
+the `browserslist-config-` prefix. npm scoped packages are also supported, by
+naming or prefixing the module with `@scope/browserslist-config`, such as
+`@scope/browserslist-config` or `@scope/browserslist-config-mycompany`.
+
+If you don’t accept Browserslist queries from users, you can disable the
+validation by using the `dangerousExtend` option:
+
+```js
+browserslist(queries, { path, dangerousExtend: true })
+```
+
+Because this uses `npm`'s resolution, you can also reference specific files
+in a package:
+
+```json
+  "browserslist": [
+    "extends browserslist-config-mycompany/desktop",
+    "extends browserslist-config-mycompany/mobile"
+  ]
+```
+
+When writing a shared Browserslist package, just export an array.
+`browserslist-config-mycompany/index.js`:
+
+```js
+module.exports = [
+  '> 1%',
+  'ie 10'
+]
+```
+
+
+## Environment Variables
+
+If some tool use Browserslist inside, you can change browsers settings
+by [environment variables]:
+
+* `BROWSERSLIST` with browsers queries.
+
+   ```sh
+  BROWSERSLIST="> 5%" gulp css
+   ```
+
+* `BROWSERSLIST_CONFIG` with path to config file.
+
+   ```sh
+  BROWSERSLIST_CONFIG=./config/browserslist gulp css
+   ```
+
+* `BROWSERSLIST_ENV` with environments string.
+
+   ```sh
+  BROWSERSLIST_ENV="development" gulp css
+   ```
+
+* `BROWSERSLIST_STATS` with path to the custom usage data
+  for `> 1% in my stats` query.
+
+   ```sh
+  BROWSERSLIST_STATS=./config/usage_data.json gulp css
+   ```
+
+* `BROWSERSLIST_DISABLE_CACHE` if you want to disable config reading cache.
+
+   ```sh
+  BROWSERSLIST_DISABLE_CACHE=1 gulp css
+   ```
+
+[environment variables]: https://en.wikipedia.org/wiki/Environment_variable
+
+
+## Environments
+
+You can also specify different browser queries for various environments.
+Browserslist will choose query according to `BROWSERSLIST_ENV` or `NODE_ENV`
+variables. If none of them is declared, Browserslist will firstly look
+for `production` queries and then use defaults.
+
+In `package.json`:
+
+```js
+  "browserslist": {
+    "production": [
+      "> 1%",
+      "ie 10"
+    ],
+    "development": [
+      "last 1 chrome version",
+      "last 1 firefox version"
+    ]
+  }
+```
+
+In `.browserslistrc` config:
+
+```ini
+[production staging]
+> 1%
+ie 10
+
+[development]
+last 1 chrome version
+last 1 firefox version
+```
+
+
+## Custom Usage Data
+
+If you have a website, you can query against the usage statistics of your site.
+[`browserslist-ga`] will ask access to Google Analytics and then generate
+`browserslist-stats.json`:
+
+```
+npx browserslist-ga
+```
+
+Of course, you can generate usage statistics file by any other method.
+File format should be like:
+
+```js
+{
+  "ie": {
+    "6": 0.01,
+    "7": 0.4,
+    "8": 1.5
+  },
+  "chrome": {
+    …
+  },
+  …
+}
+```
+
+Note that you can query against your custom usage data
+while also querying against global or regional data.
+For example, the query `> 1% in my stats, > 5% in US, 10%` is permitted.
+
+[`browserslist-ga`]: https://github.com/browserslist/browserslist-ga
+[Can I Use]:         http://caniuse.com/
+
+
+## JS API
+
+```js
+var browserslist = require('browserslist');
+
+// Your CSS/JS build tool code
+var process = function (source, opts) {
+    var browsers = browserslist(opts.browsers, {
+        stats: opts.stats,
+        path:  opts.file,
+        env:   opts.env
+    });
+    // Your code to add features for selected browsers
+}
+```
+
+Queries can be a string `"> 1%, IE 10"`
+or an array `['> 1%', 'IE 10']`.
+
+If a query is missing, Browserslist will look for a config file.
+You can provide a `path` option (that can be a file) to find the config file
+relatively to it.
+
+Options:
+
+* `path`: file or a directory path to look for config file. Default is `.`.
+* `env`: what environment section use from config. Default is `production`.
+* `stats`: custom usage statistics data.
+* `config`: path to config if you want to set it manually.
+* `ignoreUnknownVersions`: do not throw on direct query (like `ie 12`).
+  Default is `false.`
+* `dangerousExtend`: Disable security checks for `extend` query.
+  Default is `false.`
+
+For non-JS environment and debug purpose you can use CLI tool:
+
+```sh
+browserslist "> 1%, IE 10"
+```
+
+
+## Coverage
+
+You can get total users coverage for selected browsers by JS API:
+
+```js
+browserslist.coverage(browserslist('> 1%'))
+//=> 81.4
+```
+
+```js
+browserslist.coverage(browserslist('> 1% in US'), 'US')
+//=> 83.1
+```
+
+```js
+browserslist.coverage(browserslist('> 1% in my stats'), 'my stats')
+//=> 83.1
+```
+
+```js
+browserslist.coverage(browserslist('> 1% in my stats', { stats }), stats)
+//=> 82.2
+```
+
+Or by CLI:
+
+```sh
+$ browserslist --coverage "> 1%"
+These browsers account for 81.4% of all users globally
+```
+
+```sh
+$ browserslist --coverage=US "> 1% in US"
+These browsers account for 83.1% of all users in the US
+```
+
+```sh
+$ browserslist --coverage "> 1% in my stats"
+These browsers account for 83.1% of all users in custom statistics
+```
+
+```sh
+$ browserslist --coverage "> 1% in my stats" --stats=./stats.json
+These browsers account for 83.1% of all users in custom statistics
+```
+
+
+## Cache
+
+Browserslist caches the configuration it reads from `package.json` and
+`browserslist` files, as well as knowledge about the existence of files,
+for the duration of the hosting process.
+
+To clear these caches, use:
+
+```js
+browserslist.clearCaches();
+```
+
+To disable the caching altogether, set the `BROWSERSLIST_DISABLE_CACHE`
+environment variable.
diff --git a/node_modules/@babel/preset-env/node_modules/browserslist/browser.js b/node_modules/@babel/preset-env/node_modules/browserslist/browser.js
new file mode 100644
index 00000000..75657e59
--- /dev/null
+++ b/node_modules/@babel/preset-env/node_modules/browserslist/browser.js
@@ -0,0 +1,35 @@
+var BrowserslistError = require('./error')
+
+function noop () { }
+
+module.exports = {
+  loadQueries: function loadQueries () {
+    throw new BrowserslistError(
+      'Sharable configs are not supported in client-side build of Browserslist')
+  },
+
+  getStat: function getStat (opts) {
+    return opts.stats
+  },
+
+  loadConfig: function loadConfig (opts) {
+    if (opts.config) {
+      throw new BrowserslistError(
+        'Browserslist config are not supported in client-side build')
+    }
+  },
+
+  loadCountry: function loadCountry () {
+    throw new BrowserslistError(
+      'Country statistics is not supported ' +
+      'in client-side build of Browserslist')
+  },
+
+  parseConfig: noop,
+
+  readConfig: noop,
+
+  findConfig: noop,
+
+  clearCaches: noop
+}
diff --git a/node_modules/@babel/preset-env/node_modules/browserslist/cli.js b/node_modules/@babel/preset-env/node_modules/browserslist/cli.js
new file mode 100755
index 00000000..fc6149d9
--- /dev/null
+++ b/node_modules/@babel/preset-env/node_modules/browserslist/cli.js
@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+
+var fs = require('fs')
+
+var browserslist = require('./')
+var pkg = require('./package.json')
+var args = process.argv.slice(2)
+
+var USAGE = 'Usage:\n' +
+            '  ' + pkg.name + '\n' +
+            '  ' + pkg.name + ' "QUERIES"\n' +
+            '  ' + pkg.name + ' --config="path/to/browserlist/file"\n' +
+            '  ' + pkg.name + ' --coverage "QUERIES"\n' +
+            '  ' + pkg.name + ' --coverage=US "QUERIES"\n' +
+            '  ' + pkg.name + ' --env="environment name defined in config"\n' +
+            '  ' + pkg.name + ' --stats="path/to/browserlist/stats/file"'
+
+function isArg (arg) {
+  return args.some(function (str) {
+    return str === arg || str.indexOf(arg + '=') === 0
+  })
+}
+
+function error (msg) {
+  process.stderr.write(pkg.name + ': ' + msg + '\n')
+  process.exit(1)
+}
+
+if (isArg('--help') || isArg('-h')) {
+  process.stdout.write(pkg.description + '.\n\n' + USAGE + '\n')
+} else if (isArg('--version') || isArg('-v')) {
+  process.stdout.write(pkg.name + ' ' + pkg.version + '\n')
+} else {
+  var mode = 'browsers'
+  var opts = { }
+  var queries
+  var country
+
+  for (var i = 0; i < args.length; i++) {
+    if (args[i][0] !== '-') {
+      queries = args[i].replace(/^["']|["']$/g, '')
+      continue
+    }
+
+    var arg = args[i].split('=')
+    var name = arg[0]
+    var value = arg[1]
+
+    if (value) value = value.replace(/^["']|["']$/g, '')
+
+    if (name === '--config' || name === '-b') {
+      opts.config = value
+    } else if (name === '--env' || name === '-e') {
+      opts.env = value
+    } else if (name === '--stats' || name === '-s') {
+      opts.stats = value
+    } else if (name === '--coverage' || name === '-c') {
+      mode = 'coverage'
+      if (value) country = value
+    } else {
+      error('Unknown arguments ' + args[i] + '.\n\n' + USAGE)
+    }
+  }
+
+  var browsers
+  try {
+    if (!queries && !opts.config) {
+      if (browserslist.findConfig(process.cwd())) {
+        opts.path = process.cwd()
+      } else {
+        error(
+          'Browserslist config was not found. ' +
+          'Define queries or config path.' +
+          '\n\n' + USAGE
+        )
+      }
+    }
+    browsers = browserslist(queries, opts)
+  } catch (e) {
+    if (e.name === 'BrowserslistError') {
+      error(e.message)
+    } else {
+      throw e
+    }
+  }
+
+  if (mode === 'browsers') {
+    browsers.forEach(function (browser) {
+      process.stdout.write(browser + '\n')
+    })
+  } else {
+    var stats
+    if (country) {
+      stats = country
+    } else if (opts.stats) {
+      stats = JSON.parse(fs.readFileSync(opts.stats))
+    }
+    var result = browserslist.coverage(browsers, stats)
+    var round = Math.round(result * 100) / 100.0
+
+    var end = 'globally'
+    if (country && country !== 'global') {
+      end = 'in the ' + country.toUpperCase()
+    } else if (opts.stats) {
+      end = 'in custom statistics'
+    }
+
+    process.stdout.write(
+      'These browsers account for ' + round + '% of all users ' +
+            end + '\n')
+  }
+}
diff --git a/node_modules/@babel/preset-env/node_modules/browserslist/error.js b/node_modules/@babel/preset-env/node_modules/browserslist/error.js
new file mode 100644
index 00000000..b3bc0fe9
--- /dev/null
+++ b/node_modules/@babel/preset-env/node_modules/browserslist/error.js
@@ -0,0 +1,12 @@
+function BrowserslistError (message) {
+  this.name = 'BrowserslistError'
+  this.message = message
+  this.browserslist = true
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this, BrowserslistError)
+  }
+}
+
+BrowserslistError.prototype = Error.prototype
+
+module.exports = BrowserslistError
diff --git a/node_modules/@babel/preset-env/node_modules/browserslist/index.js b/node_modules/@babel/preset-env/node_modules/browserslist/index.js
new file mode 100644
index 00000000..67692907
--- /dev/null
+++ b/node_modules/@babel/preset-env/node_modules/browserslist/index.js
@@ -0,0 +1,758 @@
+var path = require('path')
+var e2c = require('electron-to-chromium/versions')
+
+var agents = require('caniuse-lite/dist/unpacker/agents').agents
+
+var BrowserslistError = require('./error')
+var env = require('./node') // Will load browser.js in webpack
+
+var FLOAT_RANGE = /^\d+(\.\d+)?(-\d+(\.\d+)?)*$/
+
+function normalize (versions) {
+  return versions.filter(function (version) {
+    return typeof version === 'string'
+  })
+}
+
+function nameMapper (name) {
+  return function mapName (version) {
+    return name + ' ' + version
+  }
+}
+
+function getMajor (version) {
+  return parseInt(version.split('.')[0])
+}
+
+function getMajorVersions (released, number) {
+  if (released.length === 0) return []
+  var minimum = getMajor(released[released.length - 1]) - parseInt(number) + 1
+  var selected = []
+  for (var i = released.length - 1; i >= 0; i--) {
+    if (minimum > getMajor(released[i])) break
+    selected.unshift(released[i])
+  }
+  return selected
+}
+
+function uniq (array) {
+  var filtered = []
+  for (var i = 0; i < array.length; i++) {
+    if (filtered.indexOf(array[i]) === -1) filtered.push(array[i])
+  }
+  return filtered
+}
+
+// Helpers
+
+function fillUsage (result, name, data) {
+  for (var i in data) {
+    result[name + ' ' + i] = data[i]
+  }
+}
+
+function generateFilter (sign, version) {
+  version = parseFloat(version)
+  if (sign === '>') {
+    return function (v) {
+      return parseFloat(v) > version
+    }
+  } else if (sign === '>=') {
+    return function (v) {
+      return parseFloat(v) >= version
+    }
+  } else if (sign === '<') {
+    return function (v) {
+      return parseFloat(v) < version
+    }
+  } else {
+    return function (v) {
+      return parseFloat(v) <= version
+    }
+  }
+}
+
+function compareStrings (a, b) {
+  if (a < b) return -1
+  if (a > b) return +1
+  return 0
+}
+
+function normalizeVersion (data, version) {
+  if (data.versions.indexOf(version) !== -1) {
+    return version
+  } else if (browserslist.versionAliases[data.name][version]) {
+    return browserslist.versionAliases[data.name][version]
+  } else if (data.versions.length === 1) {
+    return data.versions[0]
+  } else {
+    return false
+  }
+}
+
+function filterByYear (since) {
+  return Object.keys(agents).reduce(function (selected, name) {
+    var data = byName(name)
+    if (!data) return selected
+    var versions = Object.keys(data.releaseDate).filter(function (v) {
+      return data.releaseDate[v] >= since
+    })
+    return selected.concat(versions.map(nameMapper(data.name)))
+  }, [])
+}
+
+function byName (name) {
+  name = name.toLowerCase()
+  name = browserslist.aliases[name] || name
+  return browserslist.data[name]
+}
+
+function checkName (name) {
+  var data = byName(name)
+  if (!data) throw new BrowserslistError('Unknown browser ' + name)
+  return data
+}
+
+function unknownQuery (query) {
+  return new BrowserslistError('Unknown browser query `' + query + '`')
+}
+
+function resolve (queries, context) {
+  return queries.reduce(function (result, selection, index) {
+    selection = selection.trim()
+    if (selection === '') return result
+
+    var isExclude = selection.indexOf('not ') === 0
+    if (isExclude) {
+      if (index === 0) {
+        throw new BrowserslistError(
+          'Write any browsers query (for instance, `defaults`) ' +
+          'before `' + selection + '`')
+      }
+      selection = selection.slice(4)
+    }
+
+    for (var i = 0; i < QUERIES.length; i++) {
+      var type = QUERIES[i]
+      var match = selection.match(type.regexp)
+      if (match) {
+        var args = [context].concat(match.slice(1))
+        var array = type.select.apply(browserslist, args)
+        if (isExclude) {
+          array = array.concat(array.map(function (j) {
+            return j.replace(/\s\S+/, ' 0')
+          }))
+          return result.filter(function (j) {
+            return array.indexOf(j) === -1
+          })
+        }
+        return result.concat(array)
+      }
+    }
+
+    throw unknownQuery(selection)
+  }, [])
+}
+
+/**
+ * Return array of browsers by selection queries.
+ *
+ * @param {(string|string[])} [queries=browserslist.defaults] Browser queries.
+ * @param {object} [opts] Options.
+ * @param {string} [opts.path="."] Path to processed file.
+ *                                 It will be used to find config files.
+ * @param {string} [opts.env="production"] Processing environment.
+ *                                         It will be used to take right
+ *                                         queries from config file.
+ * @param {string} [opts.config] Path to config file with queries.
+ * @param {object} [opts.stats] Custom browser usage statistics
+ *                              for "> 1% in my stats" query.
+ * @param {boolean} [opts.ignoreUnknownVersions=false] Do not throw on unknown
+ *                                                     version in direct query.
+ * @param {boolean} [opts.dangerousExtend] Disable security checks
+ *                                         for extend query.
+ * @return {string[]} Array with browser names in Can I Use.
+ *
+ * @example
+ * browserslist('IE >= 10, IE 8') //=> ['ie 11', 'ie 10', 'ie 8']
+ */
+function browserslist (queries, opts) {
+  if (typeof opts === 'undefined') opts = { }
+
+  if (typeof opts.path === 'undefined') {
+    opts.path = path.resolve ? path.resolve('.') : '.'
+  }
+
+  if (typeof queries === 'undefined' || queries === null) {
+    var config = browserslist.loadConfig(opts)
+    if (config) {
+      queries = config
+    } else {
+      queries = browserslist.defaults
+    }
+  }
+
+  if (typeof queries === 'string') {
+    queries = queries.split(/,\s*/)
+  }
+
+  if (!Array.isArray(queries)) {
+    throw new BrowserslistError(
+      'Browser queries must be an array. Got ' + typeof queries + '.')
+  }
+
+  var context = {
+    ignoreUnknownVersions: opts.ignoreUnknownVersions,
+    dangerousExtend: opts.dangerousExtend
+  }
+
+  var stats = env.getStat(opts)
+  if (stats) {
+    context.customUsage = { }
+    for (var browser in stats) {
+      fillUsage(context.customUsage, browser, stats[browser])
+    }
+  }
+
+  var result = resolve(queries, context).map(function (i) {
+    var parts = i.split(' ')
+    var name = parts[0]
+    var version = parts[1]
+    if (version === '0') {
+      return name + ' ' + byName(name).versions[0]
+    } else {
+      return i
+    }
+  }).sort(function (name1, name2) {
+    name1 = name1.split(' ')
+    name2 = name2.split(' ')
+    if (name1[0] === name2[0]) {
+      if (FLOAT_RANGE.test(name1[1]) && FLOAT_RANGE.test(name2[1])) {
+        return parseFloat(name2[1]) - parseFloat(name1[1])
+      } else {
+        return compareStrings(name2[1], name1[1])
+      }
+    } else {
+      return compareStrings(name1[0], name2[0])
+    }
+  })
+
+  return uniq(result)
+}
+
+// Will be filled by Can I Use data below
+browserslist.data = { }
+browserslist.usage = {
+  global: { },
+  custom: null
+}
+
+// Default browsers query
+browserslist.defaults = [
+  '> 0.5%',
+  'last 2 versions',
+  'Firefox ESR',
+  'not dead'
+]
+
+// Browser names aliases
+browserslist.aliases = {
+  fx: 'firefox',
+  ff: 'firefox',
+  ios: 'ios_saf',
+  explorer: 'ie',
+  blackberry: 'bb',
+  explorermobile: 'ie_mob',
+  operamini: 'op_mini',
+  operamobile: 'op_mob',
+  chromeandroid: 'and_chr',
+  firefoxandroid: 'and_ff',
+  ucandroid: 'and_uc',
+  qqandroid: 'and_qq'
+}
+
+// Aliases to work with joined versions like `ios_saf 7.0-7.1`
+browserslist.versionAliases = { }
+
+browserslist.clearCaches = env.clearCaches
+browserslist.parseConfig = env.parseConfig
+browserslist.readConfig = env.readConfig
+browserslist.findConfig = env.findConfig
+browserslist.loadConfig = env.loadConfig
+
+/**
+ * Return browsers market coverage.
+ *
+ * @param {string[]} browsers Browsers names in Can I Use.
+ * @param {string|object} [stats="global"] Which statistics should be used.
+ *                                         Country code or custom statistics.
+ *                                         Pass `"my stats"` to load statistics
+ *                                         from Browserslist files.
+ *
+ * @return {number} Total market coverage for all selected browsers.
+ *
+ * @example
+ * browserslist.coverage(browserslist('> 1% in US'), 'US') //=> 83.1
+ */
+browserslist.coverage = function (browsers, stats) {
+  var data
+  if (typeof stats === 'undefined') {
+    data = browserslist.usage.global
+  } else if (stats === 'my stats') {
+    var opts = {}
+    opts.path = path.resolve ? path.resolve('.') : '.'
+    var customStats = env.getStat(opts)
+    if (!customStats) {
+      throw new BrowserslistError('Custom usage statistics was not provided')
+    }
+    data = {}
+    for (var browser in customStats) {
+      fillUsage(data, browser, customStats[browser])
+    }
+  } else if (typeof stats === 'string') {
+    if (stats.length > 2) {
+      stats = stats.toLowerCase()
+    } else {
+      stats = stats.toUpperCase()
+    }
+    env.loadCountry(browserslist.usage, stats)
+    data = browserslist.usage[stats]
+  } else {
+    if ('dataByBrowser' in stats) {
+      stats = stats.dataByBrowser
+    }
+    data = { }
+    for (var name in stats) {
+      for (var version in stats[name]) {
+        data[name + ' ' + version] = stats[name][version]
+      }
+    }
+  }
+
+  return browsers.reduce(function (all, i) {
+    var usage = data[i]
+    if (usage === undefined) {
+      usage = data[i.replace(/ \S+$/, ' 0')]
+    }
+    return all + (usage || 0)
+  }, 0)
+}
+
+var QUERIES = [
+  {
+    regexp: /^last\s+(\d+)\s+major versions?$/i,
+    select: function (context, versions) {
+      return Object.keys(agents).reduce(function (selected, name) {
+        var data = byName(name)
+        if (!data) return selected
+        var array = getMajorVersions(data.released, versions)
+
+        array = array.map(nameMapper(data.name))
+        return selected.concat(array)
+      }, [])
+    }
+  },
+  {
+    regexp: /^last\s+(\d+)\s+versions?$/i,
+    select: function (context, versions) {
+      return Object.keys(agents).reduce(function (selected, name) {
+        var data = byName(name)
+        if (!data) return selected
+        var array = data.released.slice(-versions)
+
+        array = array.map(nameMapper(data.name))
+        return selected.concat(array)
+      }, [])
+    }
+  },
+  {
+    regexp: /^last\s+(\d+)\s+electron\s+major versions?$/i,
+    select: function (context, versions) {
+      var validVersions = getMajorVersions(Object.keys(e2c).reverse(), versions)
+      return validVersions.map(function (i) {
+        return 'chrome ' + e2c[i]
+      })
+    }
+  },
+  {
+    regexp: /^last\s+(\d+)\s+(\w+)\s+major versions?$/i,
+    select: function (context, versions, name) {
+      var data = checkName(name)
+      var validVersions = getMajorVersions(data.released, versions)
+      return validVersions.map(nameMapper(data.name))
+    }
+  },
+  {
+    regexp: /^last\s+(\d+)\s+electron\s+versions?$/i,
+    select: function (context, versions) {
+      return Object.keys(e2c).reverse().slice(-versions).map(function (i) {
+        return 'chrome ' + e2c[i]
+      })
+    }
+  },
+  {
+    regexp: /^last\s+(\d+)\s+(\w+)\s+versions?$/i,
+    select: function (context, versions, name) {
+      var data = checkName(name)
+      return data.released.slice(-versions).map(nameMapper(data.name))
+    }
+  },
+  {
+    regexp: /^unreleased\s+versions$/i,
+    select: function () {
+      return Object.keys(agents).reduce(function (selected, name) {
+        var data = byName(name)
+        if (!data) return selected
+        var array = data.versions.filter(function (v) {
+          return data.released.indexOf(v) === -1
+        })
+
+        array = array.map(nameMapper(data.name))
+        return selected.concat(array)
+      }, [])
+    }
+  },
+  {
+    regexp: /^unreleased\s+electron\s+versions?$/i,
+    select: function () {
+      return []
+    }
+  },
+  {
+    regexp: /^unreleased\s+(\w+)\s+versions?$/i,
+    select: function (context, name) {
+      var data = checkName(name)
+      return data.versions.filter(function (v) {
+        return data.released.indexOf(v) === -1
+      }).map(nameMapper(data.name))
+    }
+  },
+  {
+    regexp: /^last\s+(\d+)\s+years?$/i,
+    select: function (context, years) {
+      var date = new Date()
+      var since = date.setFullYear(date.getFullYear() - years) / 1000
+
+      return filterByYear(since)
+    }
+  },
+  {
+    regexp: /^since (\d+)(?:-(\d+))?(?:-(\d+))?$/i,
+    select: function (context, year, month, date) {
+      year = parseInt(year)
+      month = parseInt(month || '01') - 1
+      date = parseInt(date || '01')
+      var since = Date.UTC(year, month, date, 0, 0, 0) / 1000
+
+      return filterByYear(since)
+    }
+  },
+  {
+    regexp: /^(>=?|<=?)\s*(\d*\.?\d+)%$/,
+    select: function (context, sign, popularity) {
+      popularity = parseFloat(popularity)
+      var usage = browserslist.usage.global
+
+      return Object.keys(usage).reduce(function (result, version) {
+        if (sign === '>') {
+          if (usage[version] > popularity) {
+            result.push(version)
+          }
+        } else if (sign === '<') {
+          if (usage[version] < popularity) {
+            result.push(version)
+          }
+        } else if (sign === '<=') {
+          if (usage[version] <= popularity) {
+            result.push(version)
+          }
+        } else if (usage[version] >= popularity) {
+          result.push(version)
+        }
+        return result
+      }, [])
+    }
+  },
+  {
+    regexp: /^(>=?|<=?)\s*(\d*\.?\d+)%\s+in\s+my\s+stats$/,
+    select: function (context, sign, popularity) {
+      popularity = parseFloat(popularity)
+
+      if (!context.customUsage) {
+        throw new BrowserslistError('Custom usage statistics was not provided')
+      }
+
+      var usage = context.customUsage
+
+      return Object.keys(usage).reduce(function (result, version) {
+        if (sign === '>') {
+          if (usage[version] > popularity) {
+            result.push(version)
+          }
+        } else if (sign === '<') {
+          if (usage[version] < popularity) {
+            result.push(version)
+          }
+        } else if (sign === '<=') {
+          if (usage[version] <= popularity) {
+            result.push(version)
+          }
+        } else if (usage[version] >= popularity) {
+          result.push(version)
+        }
+        return result
+      }, [])
+    }
+  },
+  {
+    regexp: /^(>=?|<=?)\s*(\d*\.?\d+)%\s+in\s+((alt-)?\w\w)$/,
+    select: function (context, sign, popularity, place) {
+      popularity = parseFloat(popularity)
+
+      if (place.length === 2) {
+        place = place.toUpperCase()
+      } else {
+        place = place.toLowerCase()
+      }
+
+      env.loadCountry(browserslist.usage, place)
+      var usage = browserslist.usage[place]
+
+      return Object.keys(usage).reduce(function (result, version) {
+        if (sign === '>') {
+          if (usage[version] > popularity) {
+            result.push(version)
+          }
+        } else if (sign === '<') {
+          if (usage[version] < popularity) {
+            result.push(version)
+          }
+        } else if (sign === '<=') {
+          if (usage[version] <= popularity) {
+            result.push(version)
+          }
+        } else if (usage[version] >= popularity) {
+          result.push(version)
+        }
+        return result
+      }, [])
+    }
+  },
+  {
+    regexp: /^cover\s+(\d*\.?\d+)%(\s+in\s+(my\s+stats|(alt-)?\w\w))?$/,
+    select: function (context, coverage, statMode) {
+      coverage = parseFloat(coverage)
+
+      var usage = browserslist.usage.global
+      if (statMode) {
+        if (statMode.match(/^\s+in\s+my\s+stats$/)) {
+          if (!context.customUsage) {
+            throw new BrowserslistError(
+              'Custom usage statistics was not provided'
+            )
+          }
+          usage = context.customUsage
+        } else {
+          var match = statMode.match(/\s+in\s+((alt-)?\w\w)/)
+          var place = match[1]
+          if (place.length === 2) {
+            place = place.toUpperCase()
+          } else {
+            place = place.toLowerCase()
+          }
+          env.loadCountry(browserslist.usage, place)
+          usage = browserslist.usage[place]
+        }
+      }
+
+      var versions = Object.keys(usage).sort(function (a, b) {
+        return usage[b] - usage[a]
+      })
+
+      var coveraged = 0
+      var result = []
+      var version
+      for (var i = 0; i <= versions.length; i++) {
+        version = versions[i]
+        if (usage[version] === 0) break
+
+        coveraged += usage[version]
+        result.push(version)
+        if (coveraged >= coverage) break
+      }
+
+      return result
+    }
+  },
+  {
+    regexp: /^electron\s+([\d.]+)\s*-\s*([\d.]+)$/i,
+    select: function (context, from, to) {
+      if (!e2c[from]) {
+        throw new BrowserslistError('Unknown version ' + from + ' of electron')
+      }
+      if (!e2c[to]) {
+        throw new BrowserslistError('Unknown version ' + to + ' of electron')
+      }
+
+      from = parseFloat(from)
+      to = parseFloat(to)
+
+      return Object.keys(e2c).filter(function (i) {
+        var parsed = parseFloat(i)
+        return parsed >= from && parsed <= to
+      }).map(function (i) {
+        return 'chrome ' + e2c[i]
+      })
+    }
+  },
+  {
+    regexp: /^(\w+)\s+([\d.]+)\s*-\s*([\d.]+)$/i,
+    select: function (context, name, from, to) {
+      var data = checkName(name)
+      from = parseFloat(normalizeVersion(data, from) || from)
+      to = parseFloat(normalizeVersion(data, to) || to)
+
+      function filter (v) {
+        var parsed = parseFloat(v)
+        return parsed >= from && parsed <= to
+      }
+
+      return data.released.filter(filter).map(nameMapper(data.name))
+    }
+  },
+  {
+    regexp: /^electron\s*(>=?|<=?)\s*([\d.]+)$/i,
+    select: function (context, sign, version) {
+      return Object.keys(e2c)
+        .filter(generateFilter(sign, version))
+        .map(function (i) {
+          return 'chrome ' + e2c[i]
+        })
+    }
+  },
+  {
+    regexp: /^(\w+)\s*(>=?|<=?)\s*([\d.]+)$/,
+    select: function (context, name, sign, version) {
+      var data = checkName(name)
+      var alias = browserslist.versionAliases[data.name][version]
+      if (alias) {
+        version = alias
+      }
+      return data.released
+        .filter(generateFilter(sign, version))
+        .map(function (v) {
+          return data.name + ' ' + v
+        })
+    }
+  },
+  {
+    regexp: /^(firefox|ff|fx)\s+esr$/i,
+    select: function () {
+      return ['firefox 52', 'firefox 60']
+    }
+  },
+  {
+    regexp: /(operamini|op_mini)\s+all/i,
+    select: function () {
+      return ['op_mini all']
+    }
+  },
+  {
+    regexp: /^electron\s+([\d.]+)$/i,
+    select: function (context, version) {
+      var chrome = e2c[version]
+      if (!chrome) {
+        throw new BrowserslistError(
+          'Unknown version ' + version + ' of electron')
+      }
+      return ['chrome ' + chrome]
+    }
+  },
+  {
+    regexp: /^(\w+)\s+(tp|[\d.]+)$/i,
+    select: function (context, name, version) {
+      if (/^tp$/i.test(version)) version = 'TP'
+      var data = checkName(name)
+      var alias = normalizeVersion(data, version)
+      if (alias) {
+        version = alias
+      } else {
+        if (version.indexOf('.') === -1) {
+          alias = version + '.0'
+        } else {
+          alias = version.replace(/\.0$/, '')
+        }
+        alias = normalizeVersion(data, alias)
+        if (alias) {
+          version = alias
+        } else if (context.ignoreUnknownVersions) {
+          return []
+        } else {
+          throw new BrowserslistError(
+            'Unknown version ' + version + ' of ' + name)
+        }
+      }
+      return [data.name + ' ' + version]
+    }
+  },
+  {
+    regexp: /^extends (.+)$/i,
+    select: function (context, name) {
+      return resolve(env.loadQueries(context, name), context)
+    }
+  },
+  {
+    regexp: /^defaults$/i,
+    select: function () {
+      return browserslist(browserslist.defaults)
+    }
+  },
+  {
+    regexp: /^dead$/i,
+    select: function (context) {
+      var dead = ['ie <= 10', 'ie_mob <= 10', 'bb <= 10', 'op_mob <= 12.1']
+      return resolve(dead, context)
+    }
+  },
+  {
+    regexp: /^(\w+)$/i,
+    select: function (context, name) {
+      if (byName(name)) {
+        throw new BrowserslistError(
+          'Specify versions in Browserslist query for browser ' + name)
+      } else {
+        throw unknownQuery(name)
+      }
+    }
+  }
+];
+
+// Get and convert Can I Use data
+
+(function () {
+  for (var name in agents) {
+    var browser = agents[name]
+    browserslist.data[name] = {
+      name: name,
+      versions: normalize(agents[name].versions),
+      released: normalize(agents[name].versions.slice(0, -3)),
+      releaseDate: agents[name].release_date
+    }
+    fillUsage(browserslist.usage.global, name, browser.usage_global)
+
+    browserslist.versionAliases[name] = { }
+    for (var i = 0; i < browser.versions.length; i++) {
+      var full = browser.versions[i]
+      if (!full) continue
+
+      if (full.indexOf('-') !== -1) {
+        var interval = full.split('-')
+        for (var j = 0; j < interval.length; j++) {
+          browserslist.versionAliases[name][interval[j]] = full
+        }
+      }
+    }
+  }
+}())
+
+module.exports = browserslist
diff --git a/node_modules/@babel/preset-env/node_modules/browserslist/node.js b/node_modules/@babel/preset-env/node_modules/browserslist/node.js
new file mode 100644
index 00000000..b46da136
--- /dev/null
+++ b/node_modules/@babel/preset-env/node_modules/browserslist/node.js
@@ -0,0 +1,262 @@
+var region = require('caniuse-lite/dist/unpacker/region').default
+var path = require('path')
+var fs = require('fs')
+
+var BrowserslistError = require('./error')
+
+var IS_SECTION = /^\s*\[(.+)\]\s*$/
+var CONFIG_PATTERN = /^browserslist-config-/
+var SCOPED_CONFIG__PATTERN = /@[^./]+\/browserslist-config(-|$)/
+var FORMAT = 'Browserslist config should be a string or an array ' +
+             'of strings with browser queries'
+
+var filenessCache = { }
+var configCache = { }
+
+function checkExtend (name) {
+  var use = ' Use `dangerousExtend` option to disable.'
+  if (!CONFIG_PATTERN.test(name) && !SCOPED_CONFIG__PATTERN.test(name)) {
+    throw new BrowserslistError(
+      'Browserslist config needs `browserslist-config-` prefix. ' + use)
+  }
+  if (name.indexOf('.') !== -1) {
+    throw new BrowserslistError(
+      '`.` not allowed in Browserslist config name. ' + use)
+  }
+  if (name.indexOf('node_modules') !== -1) {
+    throw new BrowserslistError(
+      '`node_modules` not allowed in Browserslist config.' + use)
+  }
+}
+
+function isFile (file) {
+  if (file in filenessCache) {
+    return filenessCache[file]
+  }
+  var result = fs.existsSync(file) && fs.statSync(file).isFile()
+  if (!process.env.BROWSERSLIST_DISABLE_CACHE) {
+    filenessCache[file] = result
+  }
+  return result
+}
+
+function eachParent (file, callback) {
+  var loc = path.resolve(file)
+  do {
+    var result = callback(loc)
+    if (typeof result !== 'undefined') return result
+  } while (loc !== (loc = path.dirname(loc)))
+  return undefined
+}
+
+function check (section) {
+  if (Array.isArray(section)) {
+    for (var i = 0; i < section.length; i++) {
+      if (typeof section[i] !== 'string') {
+        throw new BrowserslistError(FORMAT)
+      }
+    }
+  } else if (typeof section !== 'string') {
+    throw new BrowserslistError(FORMAT)
+  }
+}
+
+function pickEnv (config, opts) {
+  if (typeof config !== 'object') return config
+
+  var name
+  if (typeof opts.env === 'string') {
+    name = opts.env
+  } else if (process.env.BROWSERSLIST_ENV) {
+    name = process.env.BROWSERSLIST_ENV
+  } else if (process.env.NODE_ENV) {
+    name = process.env.NODE_ENV
+  } else {
+    name = 'production'
+  }
+
+  return config[name] || config.defaults
+}
+
+function parsePackage (file) {
+  var config = JSON.parse(fs.readFileSync(file))
+  if (config.browserlist && !config.browserslist) {
+    throw new BrowserslistError(
+      '`browserlist` key instead of `browserslist` in ' + file)
+  }
+  var list = config.browserslist
+  if (Array.isArray(list)) {
+    list = { defaults: list }
+  }
+
+  for (var i in list) {
+    check(list[i])
+  }
+
+  return list
+}
+
+module.exports = {
+  loadQueries: function loadQueries (context, name) {
+    if (!context.dangerousExtend) checkExtend(name)
+    // eslint-disable-next-line security/detect-non-literal-require
+    var queries = require(require.resolve(name, { paths: ['.'] }))
+    if (!Array.isArray(queries)) {
+      throw new BrowserslistError(
+        '`' + name + '` config exports not an array of queries')
+    }
+    return queries
+  },
+
+  getStat: function getStat (opts) {
+    var stats
+    if (opts.stats) {
+      stats = opts.stats
+    } else if (process.env.BROWSERSLIST_STATS) {
+      stats = process.env.BROWSERSLIST_STATS
+    } else if (opts.path && path.resolve && fs.existsSync) {
+      stats = eachParent(opts.path, function (dir) {
+        var file = path.join(dir, 'browserslist-stats.json')
+        return isFile(file) ? file : undefined
+      })
+    }
+
+    if (typeof stats === 'string') {
+      try {
+        stats = JSON.parse(fs.readFileSync(stats))
+      } catch (e) {
+        throw new BrowserslistError('Can\'t read ' + stats)
+      }
+    }
+
+    if (stats && 'dataByBrowser' in stats) {
+      stats = stats.dataByBrowser
+    }
+
+    return stats
+  },
+
+  loadConfig: function loadConfig (opts) {
+    if (process.env.BROWSERSLIST) {
+      return process.env.BROWSERSLIST
+    } else if (opts.config || process.env.BROWSERSLIST_CONFIG) {
+      var file = opts.config || process.env.BROWSERSLIST_CONFIG
+      if (path.basename(file) === 'package.json') {
+        return pickEnv(parsePackage(file), opts)
+      } else {
+        return pickEnv(module.exports.readConfig(file), opts)
+      }
+    } else if (opts.path) {
+      return pickEnv(module.exports.findConfig(opts.path), opts)
+    } else {
+      return undefined
+    }
+  },
+
+  loadCountry: function loadCountry (usage, country) {
+    var code = country.replace(/[^\w-]/g, '')
+    if (!usage[code]) {
+      // eslint-disable-next-line security/detect-non-literal-require
+      var compressed = require('caniuse-lite/data/regions/' + code + '.js')
+      var data = region(compressed)
+      usage[country] = { }
+      for (var i in data) {
+        for (var j in data[i]) {
+          usage[country][i + ' ' + j] = data[i][j]
+        }
+      }
+    }
+  },
+
+  parseConfig: function parseConfig (string) {
+    var result = { defaults: [] }
+    var sections = ['defaults']
+
+    string.toString()
+      .replace(/#[^\n]*/g, '')
+      .split(/\n/)
+      .map(function (line) {
+        return line.trim()
+      })
+      .filter(function (line) {
+        return line !== ''
+      })
+      .forEach(function (line) {
+        if (IS_SECTION.test(line)) {
+          sections = line.match(IS_SECTION)[1].trim().split(' ')
+          sections.forEach(function (section) {
+            if (result[section]) {
+              throw new BrowserslistError(
+                'Dublicate section ' + section + ' in Browserslist config')
+            }
+            result[section] = []
+          })
+        } else {
+          sections.forEach(function (section) {
+            result[section].push(line)
+          })
+        }
+      })
+
+    return result
+  },
+
+  readConfig: function readConfig (file) {
+    if (!isFile(file)) {
+      throw new BrowserslistError('Can\'t read ' + file + ' config')
+    }
+    return module.exports.parseConfig(fs.readFileSync(file))
+  },
+
+  findConfig: function findConfig (from) {
+    from = path.resolve(from)
+
+    var cacheKey = isFile(from) ? path.dirname(from) : from
+    if (cacheKey in configCache) {
+      return configCache[cacheKey]
+    }
+
+    var resolved = eachParent(from, function (dir) {
+      var config = path.join(dir, 'browserslist')
+      var pkg = path.join(dir, 'package.json')
+      var rc = path.join(dir, '.browserslistrc')
+
+      var pkgBrowserslist
+      if (isFile(pkg)) {
+        try {
+          pkgBrowserslist = parsePackage(pkg)
+        } catch (e) {
+          if (e.name === 'BrowserslistError') throw e
+          console.warn(
+            '[Browserslist] Could not parse ' + pkg + '. Ignoring it.')
+        }
+      }
+
+      if (isFile(config) && pkgBrowserslist) {
+        throw new BrowserslistError(
+          dir + ' contains both browserslist and package.json with browsers')
+      } else if (isFile(rc) && pkgBrowserslist) {
+        throw new BrowserslistError(
+          dir + ' contains both .browserslistrc and package.json with browsers')
+      } else if (isFile(config) && isFile(rc)) {
+        throw new BrowserslistError(
+          dir + ' contains both .browserslistrc and browserslist')
+      } else if (isFile(config)) {
+        return module.exports.readConfig(config)
+      } else if (isFile(rc)) {
+        return module.exports.readConfig(rc)
+      } else {
+        return pkgBrowserslist
+      }
+    })
+    if (!process.env.BROWSERSLIST_DISABLE_CACHE) {
+      configCache[cacheKey] = resolved
+    }
+    return resolved
+  },
+
+  clearCaches: function clearCaches () {
+    filenessCache = { }
+    configCache = { }
+  }
+}
diff --git a/node_modules/@babel/preset-env/node_modules/browserslist/package.json b/node_modules/@babel/preset-env/node_modules/browserslist/package.json
new file mode 100644
index 00000000..f4ea934a
--- /dev/null
+++ b/node_modules/@babel/preset-env/node_modules/browserslist/package.json
@@ -0,0 +1,62 @@
+{
+  "name": "browserslist",
+  "version": "3.2.8",
+  "description": "Share target browsers between different front-end tools, like Autoprefixer, Stylelint and babel-env-preset",
+  "keywords": [
+    "caniuse",
+    "browsers",
+    "target"
+  ],
+  "author": "Andrey Sitnik <andrey@sitnik.ru>",
+  "license": "MIT",
+  "repository": "browserslist/browserslist",
+  "dependencies": {
+    "caniuse-lite": "^1.0.30000844",
+    "electron-to-chromium": "^1.3.47"
+  },
+  "bin": "./cli.js",
+  "devDependencies": {
+    "cross-spawn": "^6.0.5",
+    "eslint": "^4.19.1",
+    "eslint-ci": "^0.1.1",
+    "eslint-config-logux": "^22.1.0",
+    "eslint-config-standard": "^11.0.0",
+    "eslint-plugin-es5": "^1.3.1",
+    "eslint-plugin-import": "^2.12.0",
+    "eslint-plugin-jest": "^21.15.1",
+    "eslint-plugin-node": "^6.0.1",
+    "eslint-plugin-promise": "^3.7.0",
+    "eslint-plugin-security": "^1.4.0",
+    "eslint-plugin-standard": "^3.1.0",
+    "fs-extra": "^5.0.0",
+    "jest": "^22.4.4",
+    "lint-staged": "^7.1.2",
+    "pre-commit": "^1.1.3",
+    "size-limit": "^0.18.0",
+    "yaspeller-ci": "^1.0.0"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "coverageThreshold": {
+      "global": {
+        "statements": 100
+      }
+    },
+    "modulePathIgnorePatterns": [
+      "<rootDir>/test/fixtures"
+    ]
+  },
+  "scripts": {
+    "lint-staged": "lint-staged",
+    "spellcheck": "yaspeller-ci README.md CHANGELOG.md",
+    "lint": "eslint-ci *.js test/*.js benchmark/*.js",
+    "test": "jest --coverage && yarn lint && yarn spellcheck && size-limit"
+  },
+  "browser": {
+    "./node.js": "./browser.js",
+    "path": false
+  },
+  "pre-commit": [
+    "lint-staged"
+  ]
+}
diff --git a/node_modules/@babel/preset-env/package.json b/node_modules/@babel/preset-env/package.json
new file mode 100644
index 00000000..775e3af0
--- /dev/null
+++ b/node_modules/@babel/preset-env/package.json
@@ -0,0 +1,66 @@
+{
+  "name": "@babel/preset-env",
+  "version": "7.0.0-beta.47",
+  "description": "A Babel preset for each environment.",
+  "author": "Henry Zhu <hi@henryzoo.com>",
+  "homepage": "https://babeljs.io/",
+  "license": "MIT",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-preset-env",
+  "main": "lib/index.js",
+  "scripts": {
+    "build-data": "node ./scripts/build-data.js; node ./scripts/build-modules-support.js"
+  },
+  "dependencies": {
+    "@babel/helper-module-imports": "7.0.0-beta.47",
+    "@babel/helper-plugin-utils": "7.0.0-beta.47",
+    "@babel/plugin-proposal-async-generator-functions": "7.0.0-beta.47",
+    "@babel/plugin-proposal-object-rest-spread": "7.0.0-beta.47",
+    "@babel/plugin-proposal-optional-catch-binding": "7.0.0-beta.47",
+    "@babel/plugin-proposal-unicode-property-regex": "7.0.0-beta.47",
+    "@babel/plugin-syntax-async-generators": "7.0.0-beta.47",
+    "@babel/plugin-syntax-object-rest-spread": "7.0.0-beta.47",
+    "@babel/plugin-syntax-optional-catch-binding": "7.0.0-beta.47",
+    "@babel/plugin-transform-arrow-functions": "7.0.0-beta.47",
+    "@babel/plugin-transform-async-to-generator": "7.0.0-beta.47",
+    "@babel/plugin-transform-block-scoped-functions": "7.0.0-beta.47",
+    "@babel/plugin-transform-block-scoping": "7.0.0-beta.47",
+    "@babel/plugin-transform-classes": "7.0.0-beta.47",
+    "@babel/plugin-transform-computed-properties": "7.0.0-beta.47",
+    "@babel/plugin-transform-destructuring": "7.0.0-beta.47",
+    "@babel/plugin-transform-dotall-regex": "7.0.0-beta.47",
+    "@babel/plugin-transform-duplicate-keys": "7.0.0-beta.47",
+    "@babel/plugin-transform-exponentiation-operator": "7.0.0-beta.47",
+    "@babel/plugin-transform-for-of": "7.0.0-beta.47",
+    "@babel/plugin-transform-function-name": "7.0.0-beta.47",
+    "@babel/plugin-transform-literals": "7.0.0-beta.47",
+    "@babel/plugin-transform-modules-amd": "7.0.0-beta.47",
+    "@babel/plugin-transform-modules-commonjs": "7.0.0-beta.47",
+    "@babel/plugin-transform-modules-systemjs": "7.0.0-beta.47",
+    "@babel/plugin-transform-modules-umd": "7.0.0-beta.47",
+    "@babel/plugin-transform-new-target": "7.0.0-beta.47",
+    "@babel/plugin-transform-object-super": "7.0.0-beta.47",
+    "@babel/plugin-transform-parameters": "7.0.0-beta.47",
+    "@babel/plugin-transform-regenerator": "7.0.0-beta.47",
+    "@babel/plugin-transform-shorthand-properties": "7.0.0-beta.47",
+    "@babel/plugin-transform-spread": "7.0.0-beta.47",
+    "@babel/plugin-transform-sticky-regex": "7.0.0-beta.47",
+    "@babel/plugin-transform-template-literals": "7.0.0-beta.47",
+    "@babel/plugin-transform-typeof-symbol": "7.0.0-beta.47",
+    "@babel/plugin-transform-unicode-regex": "7.0.0-beta.47",
+    "browserslist": "^3.0.0",
+    "invariant": "^2.2.2",
+    "semver": "^5.3.0"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/cli": "7.0.0-beta.47",
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-fixtures": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47",
+    "compat-table": "kangax/compat-table#90d02e486227d179d2ce9b850dbb3f9846443cab",
+    "electron-to-chromium": "^1.3.27",
+    "request": "^2.83.0"
+  }
+}
diff --git a/node_modules/@babel/preset-stage-2/README.md b/node_modules/@babel/preset-stage-2/README.md
new file mode 100644
index 00000000..10342ad4
--- /dev/null
+++ b/node_modules/@babel/preset-stage-2/README.md
@@ -0,0 +1,69 @@
+# @babel/preset-stage-2
+
+> Babel preset for stage 2 plugins.
+
+The gist of Stage 2 is:
+
+> **Stage 2:** draft
+>
+> **What is it?** A first version of what will be in the specification. At this point, an eventual inclusion of the feature in the standard is likely.
+>
+> **What’s required?** The proposal must now additionally have a formal description of the syntax and semantics of the feature (using the formal language of the ECMAScript specification). The description should be as complete as possible, but can contain todos and placeholders. Two experimental implementations of the feature are needed, but one of them can be in a transpiler such as Babel.
+>
+> **What’s next?** Only incremental changes are expected from now on.
+
+## Install
+
+```sh
+npm install --save-dev @babel/preset-stage-2
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "presets": ["@babel/preset-stage-2"]
+}
+```
+
+### Via CLI
+
+```sh
+babel script.js --presets @babel/preset-stage-2
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  presets: ["@babel/preset-stage-2"]
+});
+```
+
+## Options
+
+### `loose`
+
+`boolean`, defaults to `false`.
+
+Enable "loose" transformations for any plugins in this preset that allow them.
+
+### `useBuiltIns`
+
+`boolean`, defaults to `false`.
+
+Will use the native built-in instead of trying to polyfill behavior for any plugins that require one.
+
+### `decoratorsLegacy`
+
+`boolean`, defaults to `false`.
+
+Use the legacy (stage 1) decorators syntax and behavior.
+
+## References
+
+- Chapter "[The TC39 process for ECMAScript features](http://exploringjs.com/es2016-es2017/ch_tc39-process.html)" in "Exploring ES2016 and ES2017" by Axel Rauschmayer
diff --git a/node_modules/@babel/preset-stage-2/lib/index.js b/node_modules/@babel/preset-stage-2/lib/index.js
new file mode 100644
index 00000000..0d573a1c
--- /dev/null
+++ b/node_modules/@babel/preset-stage-2/lib/index.js
@@ -0,0 +1,116 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _presetStage() {
+  const data = _interopRequireDefault(require("@babel/preset-stage-3"));
+
+  _presetStage = function _presetStage() {
+    return data;
+  };
+
+  return data;
+}
+
+function _pluginProposalDecorators() {
+  const data = _interopRequireDefault(require("@babel/plugin-proposal-decorators"));
+
+  _pluginProposalDecorators = function _pluginProposalDecorators() {
+    return data;
+  };
+
+  return data;
+}
+
+function _pluginProposalFunctionSent() {
+  const data = _interopRequireDefault(require("@babel/plugin-proposal-function-sent"));
+
+  _pluginProposalFunctionSent = function _pluginProposalFunctionSent() {
+    return data;
+  };
+
+  return data;
+}
+
+function _pluginProposalExportNamespaceFrom() {
+  const data = _interopRequireDefault(require("@babel/plugin-proposal-export-namespace-from"));
+
+  _pluginProposalExportNamespaceFrom = function _pluginProposalExportNamespaceFrom() {
+    return data;
+  };
+
+  return data;
+}
+
+function _pluginProposalNumericSeparator() {
+  const data = _interopRequireDefault(require("@babel/plugin-proposal-numeric-separator"));
+
+  _pluginProposalNumericSeparator = function _pluginProposalNumericSeparator() {
+    return data;
+  };
+
+  return data;
+}
+
+function _pluginProposalThrowExpressions() {
+  const data = _interopRequireDefault(require("@babel/plugin-proposal-throw-expressions"));
+
+  _pluginProposalThrowExpressions = function _pluginProposalThrowExpressions() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _helperPluginUtils().declare)((api, opts = {}) => {
+  api.assertVersion(7);
+  const _opts$loose = opts.loose,
+        loose = _opts$loose === void 0 ? false : _opts$loose,
+        _opts$useBuiltIns = opts.useBuiltIns,
+        useBuiltIns = _opts$useBuiltIns === void 0 ? false : _opts$useBuiltIns,
+        _opts$decoratorsLegac = opts.decoratorsLegacy,
+        decoratorsLegacy = _opts$decoratorsLegac === void 0 ? false : _opts$decoratorsLegac;
+
+  if (typeof loose !== "boolean") {
+    throw new Error("@babel/preset-stage-2 'loose' option must be a boolean.");
+  }
+
+  if (typeof useBuiltIns !== "boolean") {
+    throw new Error("@babel/preset-stage-2 'useBuiltIns' option must be a boolean.");
+  }
+
+  if (typeof decoratorsLegacy !== "boolean") {
+    throw new Error("@babel/preset-stage-2 'decoratorsLegacy' option must be a boolean.");
+  }
+
+  if (decoratorsLegacy !== true) {
+    throw new Error("The new decorators proposal is not supported yet." + ' You must pass the `"decoratorsLegacy": true` option to' + " @babel/preset-stage-2");
+  }
+
+  return {
+    presets: [[_presetStage().default, {
+      loose,
+      useBuiltIns
+    }]],
+    plugins: [[_pluginProposalDecorators().default, {
+      legacy: decoratorsLegacy
+    }], _pluginProposalFunctionSent().default, _pluginProposalExportNamespaceFrom().default, _pluginProposalNumericSeparator().default, _pluginProposalThrowExpressions().default]
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/preset-stage-2/package.json b/node_modules/@babel/preset-stage-2/package.json
new file mode 100644
index 00000000..5b2c3bd0
--- /dev/null
+++ b/node_modules/@babel/preset-stage-2/package.json
@@ -0,0 +1,25 @@
+{
+  "name": "@babel/preset-stage-2",
+  "version": "7.0.0-beta.47",
+  "description": "Babel preset for stage 2 plugins",
+  "author": "Sebastian McKenzie <sebmck@gmail.com>",
+  "homepage": "https://babeljs.io/",
+  "license": "MIT",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-preset-stage-2",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47",
+    "@babel/plugin-proposal-decorators": "7.0.0-beta.47",
+    "@babel/plugin-proposal-export-namespace-from": "7.0.0-beta.47",
+    "@babel/plugin-proposal-function-sent": "7.0.0-beta.47",
+    "@babel/plugin-proposal-numeric-separator": "7.0.0-beta.47",
+    "@babel/plugin-proposal-throw-expressions": "7.0.0-beta.47",
+    "@babel/preset-stage-3": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/preset-stage-3/README.md b/node_modules/@babel/preset-stage-3/README.md
new file mode 100644
index 00000000..ea52dedc
--- /dev/null
+++ b/node_modules/@babel/preset-stage-3/README.md
@@ -0,0 +1,63 @@
+# @babel/preset-stage-3
+
+> Babel preset for stage 3 plugins.
+
+The gist of Stage 3 is:
+
+> **Stage 3**: candidate
+>
+> **What is it?** The proposal is mostly finished and now needs feedback from implementations and users to progress further.
+
+> **What’s required?** The spec text must be complete. Designated reviewers (appointed by TC39, not by the champion) and the ECMAScript spec editor must sign off on the spec text. There must be at least two spec-compliant implementations (which don’t have to be enabled by default).
+>
+> **What’s next?** Henceforth, changes should only be made in response to critical issues raised by the implementations and their use.
+
+## Install
+
+```sh
+npm install --save-dev @babel/preset-stage-3
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "presets": ["@babel/preset-stage-3"]
+}
+```
+
+### Via CLI
+
+```sh
+babel script.js --presets @babel/preset-stage-3
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  presets: ["@babel/preset-stage-3"]
+});
+```
+
+## Options
+
+### `loose`
+
+`boolean`, defaults to `false`.
+
+Enable "loose" transformations for any plugins in this preset that allow them.
+
+### `useBuiltIns`
+
+`boolean`, defaults to `false`.
+
+Will use the native built-in instead of trying to polyfill behavior for any plugins that require one.
+
+## References
+
+- Chapter "[The TC39 process for ECMAScript features](http://exploringjs.com/es2016-es2017/ch_tc39-process.html)" in "Exploring ES2016 and ES2017" by Axel Rauschmayer
diff --git a/node_modules/@babel/preset-stage-3/lib/index.js b/node_modules/@babel/preset-stage-3/lib/index.js
new file mode 100644
index 00000000..fa5cdbaa
--- /dev/null
+++ b/node_modules/@babel/preset-stage-3/lib/index.js
@@ -0,0 +1,118 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _pluginSyntaxDynamicImport() {
+  const data = _interopRequireDefault(require("@babel/plugin-syntax-dynamic-import"));
+
+  _pluginSyntaxDynamicImport = function _pluginSyntaxDynamicImport() {
+    return data;
+  };
+
+  return data;
+}
+
+function _pluginSyntaxImportMeta() {
+  const data = _interopRequireDefault(require("@babel/plugin-syntax-import-meta"));
+
+  _pluginSyntaxImportMeta = function _pluginSyntaxImportMeta() {
+    return data;
+  };
+
+  return data;
+}
+
+function _pluginProposalAsyncGeneratorFunctions() {
+  const data = _interopRequireDefault(require("@babel/plugin-proposal-async-generator-functions"));
+
+  _pluginProposalAsyncGeneratorFunctions = function _pluginProposalAsyncGeneratorFunctions() {
+    return data;
+  };
+
+  return data;
+}
+
+function _pluginProposalClassProperties() {
+  const data = _interopRequireDefault(require("@babel/plugin-proposal-class-properties"));
+
+  _pluginProposalClassProperties = function _pluginProposalClassProperties() {
+    return data;
+  };
+
+  return data;
+}
+
+function _pluginProposalObjectRestSpread() {
+  const data = _interopRequireDefault(require("@babel/plugin-proposal-object-rest-spread"));
+
+  _pluginProposalObjectRestSpread = function _pluginProposalObjectRestSpread() {
+    return data;
+  };
+
+  return data;
+}
+
+function _pluginProposalOptionalCatchBinding() {
+  const data = _interopRequireDefault(require("@babel/plugin-proposal-optional-catch-binding"));
+
+  _pluginProposalOptionalCatchBinding = function _pluginProposalOptionalCatchBinding() {
+    return data;
+  };
+
+  return data;
+}
+
+function _pluginProposalUnicodePropertyRegex() {
+  const data = _interopRequireDefault(require("@babel/plugin-proposal-unicode-property-regex"));
+
+  _pluginProposalUnicodePropertyRegex = function _pluginProposalUnicodePropertyRegex() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _helperPluginUtils().declare)((api, opts) => {
+  api.assertVersion(7);
+  let loose = false;
+  let useBuiltIns = false;
+
+  if (opts !== undefined) {
+    if (opts.loose !== undefined) loose = opts.loose;
+    if (opts.useBuiltIns !== undefined) useBuiltIns = opts.useBuiltIns;
+  }
+
+  if (typeof loose !== "boolean") {
+    throw new Error("@babel/preset-stage-3 'loose' option must be a boolean.");
+  }
+
+  if (typeof useBuiltIns !== "boolean") {
+    throw new Error("@babel/preset-stage-3 'useBuiltIns' option must be a boolean.");
+  }
+
+  return {
+    plugins: [_pluginSyntaxDynamicImport().default, _pluginSyntaxImportMeta().default, _pluginProposalAsyncGeneratorFunctions().default, [_pluginProposalClassProperties().default, {
+      loose
+    }], [_pluginProposalObjectRestSpread().default, {
+      loose,
+      useBuiltIns
+    }], _pluginProposalOptionalCatchBinding().default, _pluginProposalUnicodePropertyRegex().default]
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/preset-stage-3/package.json b/node_modules/@babel/preset-stage-3/package.json
new file mode 100644
index 00000000..0cfced9d
--- /dev/null
+++ b/node_modules/@babel/preset-stage-3/package.json
@@ -0,0 +1,26 @@
+{
+  "name": "@babel/preset-stage-3",
+  "version": "7.0.0-beta.47",
+  "description": "Babel preset for stage 3 plugins",
+  "author": "Sebastian McKenzie <sebmck@gmail.com>",
+  "homepage": "https://babeljs.io/",
+  "license": "MIT",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-preset-stage-3",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/helper-plugin-utils": "7.0.0-beta.47",
+    "@babel/plugin-proposal-async-generator-functions": "7.0.0-beta.47",
+    "@babel/plugin-proposal-class-properties": "7.0.0-beta.47",
+    "@babel/plugin-proposal-object-rest-spread": "7.0.0-beta.47",
+    "@babel/plugin-proposal-optional-catch-binding": "7.0.0-beta.47",
+    "@babel/plugin-proposal-unicode-property-regex": "7.0.0-beta.47",
+    "@babel/plugin-syntax-dynamic-import": "7.0.0-beta.47",
+    "@babel/plugin-syntax-import-meta": "7.0.0-beta.47"
+  },
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/runtime/README.md b/node_modules/@babel/runtime/README.md
new file mode 100644
index 00000000..778da2b0
--- /dev/null
+++ b/node_modules/@babel/runtime/README.md
@@ -0,0 +1,2 @@
+# @babel/runtime
+
diff --git a/node_modules/@babel/runtime/core-js.js b/node_modules/@babel/runtime/core-js.js
new file mode 100644
index 00000000..709f7e32
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library");
diff --git a/node_modules/@babel/runtime/core-js/array/copy-within.js b/node_modules/@babel/runtime/core-js/array/copy-within.js
new file mode 100644
index 00000000..f6a0f629
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/array/copy-within.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/array/copy-within");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/array/entries.js b/node_modules/@babel/runtime/core-js/array/entries.js
new file mode 100644
index 00000000..ad04b68b
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/array/entries.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/array/entries");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/array/every.js b/node_modules/@babel/runtime/core-js/array/every.js
new file mode 100644
index 00000000..44eb1b1c
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/array/every.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/array/every");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/array/fill.js b/node_modules/@babel/runtime/core-js/array/fill.js
new file mode 100644
index 00000000..a9a09376
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/array/fill.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/array/fill");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/array/filter.js b/node_modules/@babel/runtime/core-js/array/filter.js
new file mode 100644
index 00000000..09fbf387
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/array/filter.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/array/filter");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/array/find-index.js b/node_modules/@babel/runtime/core-js/array/find-index.js
new file mode 100644
index 00000000..0cb225ac
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/array/find-index.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/array/find-index");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/array/find.js b/node_modules/@babel/runtime/core-js/array/find.js
new file mode 100644
index 00000000..5b1a296d
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/array/find.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/array/find");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/array/for-each.js b/node_modules/@babel/runtime/core-js/array/for-each.js
new file mode 100644
index 00000000..dbeaed7d
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/array/for-each.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/array/for-each");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/array/from.js b/node_modules/@babel/runtime/core-js/array/from.js
new file mode 100644
index 00000000..221bfbc1
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/array/from.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/array/from");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/array/includes.js b/node_modules/@babel/runtime/core-js/array/includes.js
new file mode 100644
index 00000000..1ba1fb7a
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/array/includes.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/array/includes");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/array/index-of.js b/node_modules/@babel/runtime/core-js/array/index-of.js
new file mode 100644
index 00000000..fff66921
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/array/index-of.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/array/index-of");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/array/join.js b/node_modules/@babel/runtime/core-js/array/join.js
new file mode 100644
index 00000000..7bb911ad
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/array/join.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/array/join");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/array/keys.js b/node_modules/@babel/runtime/core-js/array/keys.js
new file mode 100644
index 00000000..6ab66a6a
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/array/keys.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/array/keys");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/array/last-index-of.js b/node_modules/@babel/runtime/core-js/array/last-index-of.js
new file mode 100644
index 00000000..e58608f3
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/array/last-index-of.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/array/last-index-of");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/array/map.js b/node_modules/@babel/runtime/core-js/array/map.js
new file mode 100644
index 00000000..40fc3aa4
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/array/map.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/array/map");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/array/of.js b/node_modules/@babel/runtime/core-js/array/of.js
new file mode 100644
index 00000000..e5e15570
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/array/of.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/array/of");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/array/reduce-right.js b/node_modules/@babel/runtime/core-js/array/reduce-right.js
new file mode 100644
index 00000000..a6d004d2
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/array/reduce-right.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/array/reduce-right");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/array/reduce.js b/node_modules/@babel/runtime/core-js/array/reduce.js
new file mode 100644
index 00000000..49f5eee5
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/array/reduce.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/array/reduce");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/array/some.js b/node_modules/@babel/runtime/core-js/array/some.js
new file mode 100644
index 00000000..17740bc5
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/array/some.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/array/some");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/array/sort.js b/node_modules/@babel/runtime/core-js/array/sort.js
new file mode 100644
index 00000000..45e79b1f
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/array/sort.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/array/sort");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/array/splice.js b/node_modules/@babel/runtime/core-js/array/splice.js
new file mode 100644
index 00000000..b413b1ba
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/array/splice.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/array/splice");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/array/values.js b/node_modules/@babel/runtime/core-js/array/values.js
new file mode 100644
index 00000000..9e67d2a2
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/array/values.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/array/values");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/asap.js b/node_modules/@babel/runtime/core-js/asap.js
new file mode 100644
index 00000000..56f4b237
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/asap.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/asap");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/clear-immediate.js b/node_modules/@babel/runtime/core-js/clear-immediate.js
new file mode 100644
index 00000000..87c0bf0a
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/clear-immediate.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/clear-immediate");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/get-iterator.js b/node_modules/@babel/runtime/core-js/get-iterator.js
new file mode 100644
index 00000000..4fa43730
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/get-iterator.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/get-iterator");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/is-iterable.js b/node_modules/@babel/runtime/core-js/is-iterable.js
new file mode 100644
index 00000000..44a6ea7b
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/is-iterable.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/is-iterable");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/json/stringify.js b/node_modules/@babel/runtime/core-js/json/stringify.js
new file mode 100644
index 00000000..13f0b892
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/json/stringify.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/json/stringify");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/map.js b/node_modules/@babel/runtime/core-js/map.js
new file mode 100644
index 00000000..7dd2ac72
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/map.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/map");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/math/acosh.js b/node_modules/@babel/runtime/core-js/math/acosh.js
new file mode 100644
index 00000000..63fed819
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/math/acosh.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/math/acosh");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/math/asinh.js b/node_modules/@babel/runtime/core-js/math/asinh.js
new file mode 100644
index 00000000..c33959c5
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/math/asinh.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/math/asinh");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/math/atanh.js b/node_modules/@babel/runtime/core-js/math/atanh.js
new file mode 100644
index 00000000..0afd91c5
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/math/atanh.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/math/atanh");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/math/cbrt.js b/node_modules/@babel/runtime/core-js/math/cbrt.js
new file mode 100644
index 00000000..5b719e15
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/math/cbrt.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/math/cbrt");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/math/clz32.js b/node_modules/@babel/runtime/core-js/math/clz32.js
new file mode 100644
index 00000000..b136838b
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/math/clz32.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/math/clz32");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/math/cosh.js b/node_modules/@babel/runtime/core-js/math/cosh.js
new file mode 100644
index 00000000..5628fd44
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/math/cosh.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/math/cosh");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/math/expm1.js b/node_modules/@babel/runtime/core-js/math/expm1.js
new file mode 100644
index 00000000..cddacc5c
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/math/expm1.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/math/expm1");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/math/fround.js b/node_modules/@babel/runtime/core-js/math/fround.js
new file mode 100644
index 00000000..83de174b
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/math/fround.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/math/fround");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/math/hypot.js b/node_modules/@babel/runtime/core-js/math/hypot.js
new file mode 100644
index 00000000..8179ff21
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/math/hypot.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/math/hypot");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/math/iaddh.js b/node_modules/@babel/runtime/core-js/math/iaddh.js
new file mode 100644
index 00000000..7988e5ad
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/math/iaddh.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/math/iaddh");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/math/imul.js b/node_modules/@babel/runtime/core-js/math/imul.js
new file mode 100644
index 00000000..013fb763
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/math/imul.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/math/imul");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/math/imulh.js b/node_modules/@babel/runtime/core-js/math/imulh.js
new file mode 100644
index 00000000..28cd62bc
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/math/imulh.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/math/imulh");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/math/isubh.js b/node_modules/@babel/runtime/core-js/math/isubh.js
new file mode 100644
index 00000000..a947cb7c
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/math/isubh.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/math/isubh");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/math/log10.js b/node_modules/@babel/runtime/core-js/math/log10.js
new file mode 100644
index 00000000..d12e53d2
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/math/log10.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/math/log10");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/math/log1p.js b/node_modules/@babel/runtime/core-js/math/log1p.js
new file mode 100644
index 00000000..56689751
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/math/log1p.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/math/log1p");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/math/log2.js b/node_modules/@babel/runtime/core-js/math/log2.js
new file mode 100644
index 00000000..40bd8ab8
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/math/log2.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/math/log2");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/math/sign.js b/node_modules/@babel/runtime/core-js/math/sign.js
new file mode 100644
index 00000000..0d07f688
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/math/sign.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/math/sign");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/math/sinh.js b/node_modules/@babel/runtime/core-js/math/sinh.js
new file mode 100644
index 00000000..6327c508
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/math/sinh.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/math/sinh");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/math/tanh.js b/node_modules/@babel/runtime/core-js/math/tanh.js
new file mode 100644
index 00000000..b8495290
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/math/tanh.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/math/tanh");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/math/trunc.js b/node_modules/@babel/runtime/core-js/math/trunc.js
new file mode 100644
index 00000000..b26b0cb8
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/math/trunc.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/math/trunc");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/math/umulh.js b/node_modules/@babel/runtime/core-js/math/umulh.js
new file mode 100644
index 00000000..de2c50b5
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/math/umulh.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/math/umulh");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/number/epsilon.js b/node_modules/@babel/runtime/core-js/number/epsilon.js
new file mode 100644
index 00000000..1f21deda
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/number/epsilon.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/number/epsilon");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/number/is-finite.js b/node_modules/@babel/runtime/core-js/number/is-finite.js
new file mode 100644
index 00000000..a5fca163
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/number/is-finite.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/number/is-finite");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/number/is-integer.js b/node_modules/@babel/runtime/core-js/number/is-integer.js
new file mode 100644
index 00000000..44e66628
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/number/is-integer.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/number/is-integer");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/number/is-nan.js b/node_modules/@babel/runtime/core-js/number/is-nan.js
new file mode 100644
index 00000000..c2d6f918
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/number/is-nan.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/number/is-nan");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/number/is-safe-integer.js b/node_modules/@babel/runtime/core-js/number/is-safe-integer.js
new file mode 100644
index 00000000..dc406230
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/number/is-safe-integer.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/number/is-safe-integer");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/number/max-safe-integer.js b/node_modules/@babel/runtime/core-js/number/max-safe-integer.js
new file mode 100644
index 00000000..7e2388c6
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/number/max-safe-integer.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/number/max-safe-integer");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/number/min-safe-integer.js b/node_modules/@babel/runtime/core-js/number/min-safe-integer.js
new file mode 100644
index 00000000..51ea6df6
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/number/min-safe-integer.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/number/min-safe-integer");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/number/parse-float.js b/node_modules/@babel/runtime/core-js/number/parse-float.js
new file mode 100644
index 00000000..564c0b54
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/number/parse-float.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/number/parse-float");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/number/parse-int.js b/node_modules/@babel/runtime/core-js/number/parse-int.js
new file mode 100644
index 00000000..355f3f49
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/number/parse-int.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/number/parse-int");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/object/assign.js b/node_modules/@babel/runtime/core-js/object/assign.js
new file mode 100644
index 00000000..1d3fd547
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/object/assign.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/object/assign");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/object/create.js b/node_modules/@babel/runtime/core-js/object/create.js
new file mode 100644
index 00000000..339ad362
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/object/create.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/object/create");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/object/define-properties.js b/node_modules/@babel/runtime/core-js/object/define-properties.js
new file mode 100644
index 00000000..11dd2c4f
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/object/define-properties.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/object/define-properties");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/object/define-property.js b/node_modules/@babel/runtime/core-js/object/define-property.js
new file mode 100644
index 00000000..9d4457d7
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/object/define-property.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/object/define-property");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/object/entries.js b/node_modules/@babel/runtime/core-js/object/entries.js
new file mode 100644
index 00000000..48453a0f
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/object/entries.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/object/entries");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/object/freeze.js b/node_modules/@babel/runtime/core-js/object/freeze.js
new file mode 100644
index 00000000..784673c2
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/object/freeze.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/object/freeze");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/object/get-own-property-descriptor.js b/node_modules/@babel/runtime/core-js/object/get-own-property-descriptor.js
new file mode 100644
index 00000000..fd1ebc2c
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/object/get-own-property-descriptor.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/object/get-own-property-descriptor");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/object/get-own-property-descriptors.js b/node_modules/@babel/runtime/core-js/object/get-own-property-descriptors.js
new file mode 100644
index 00000000..7b400a29
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/object/get-own-property-descriptors.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/object/get-own-property-descriptors");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/object/get-own-property-names.js b/node_modules/@babel/runtime/core-js/object/get-own-property-names.js
new file mode 100644
index 00000000..60f04450
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/object/get-own-property-names.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/object/get-own-property-names");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/object/get-own-property-symbols.js b/node_modules/@babel/runtime/core-js/object/get-own-property-symbols.js
new file mode 100644
index 00000000..475f0582
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/object/get-own-property-symbols.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/object/get-own-property-symbols");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/object/get-prototype-of.js b/node_modules/@babel/runtime/core-js/object/get-prototype-of.js
new file mode 100644
index 00000000..42ac77ef
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/object/get-prototype-of.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/object/get-prototype-of");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/object/is-extensible.js b/node_modules/@babel/runtime/core-js/object/is-extensible.js
new file mode 100644
index 00000000..a0030fcf
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/object/is-extensible.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/object/is-extensible");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/object/is-frozen.js b/node_modules/@babel/runtime/core-js/object/is-frozen.js
new file mode 100644
index 00000000..3fb89b1a
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/object/is-frozen.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/object/is-frozen");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/object/is-sealed.js b/node_modules/@babel/runtime/core-js/object/is-sealed.js
new file mode 100644
index 00000000..23bca992
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/object/is-sealed.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/object/is-sealed");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/object/is.js b/node_modules/@babel/runtime/core-js/object/is.js
new file mode 100644
index 00000000..ced00d71
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/object/is.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/object/is");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/object/keys.js b/node_modules/@babel/runtime/core-js/object/keys.js
new file mode 100644
index 00000000..80fff31c
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/object/keys.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/object/keys");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/object/prevent-extensions.js b/node_modules/@babel/runtime/core-js/object/prevent-extensions.js
new file mode 100644
index 00000000..40f7278e
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/object/prevent-extensions.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/object/prevent-extensions");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/object/seal.js b/node_modules/@babel/runtime/core-js/object/seal.js
new file mode 100644
index 00000000..6cd61832
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/object/seal.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/object/seal");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/object/set-prototype-of.js b/node_modules/@babel/runtime/core-js/object/set-prototype-of.js
new file mode 100644
index 00000000..7169e259
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/object/set-prototype-of.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/object/set-prototype-of");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/object/values.js b/node_modules/@babel/runtime/core-js/object/values.js
new file mode 100644
index 00000000..928ec1ac
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/object/values.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/object/values");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/observable.js b/node_modules/@babel/runtime/core-js/observable.js
new file mode 100644
index 00000000..07a59634
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/observable.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/observable");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/promise.js b/node_modules/@babel/runtime/core-js/promise.js
new file mode 100644
index 00000000..e62e14b5
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/promise.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/promise");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/reflect/apply.js b/node_modules/@babel/runtime/core-js/reflect/apply.js
new file mode 100644
index 00000000..1e5a1656
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/reflect/apply.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/reflect/apply");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/reflect/construct.js b/node_modules/@babel/runtime/core-js/reflect/construct.js
new file mode 100644
index 00000000..25c0e462
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/reflect/construct.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/reflect/construct");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/reflect/define-metadata.js b/node_modules/@babel/runtime/core-js/reflect/define-metadata.js
new file mode 100644
index 00000000..1c58e4b7
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/reflect/define-metadata.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/reflect/define-metadata");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/reflect/define-property.js b/node_modules/@babel/runtime/core-js/reflect/define-property.js
new file mode 100644
index 00000000..bfce1e06
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/reflect/define-property.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/reflect/define-property");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/reflect/delete-metadata.js b/node_modules/@babel/runtime/core-js/reflect/delete-metadata.js
new file mode 100644
index 00000000..9bdfb267
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/reflect/delete-metadata.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/reflect/delete-metadata");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/reflect/delete-property.js b/node_modules/@babel/runtime/core-js/reflect/delete-property.js
new file mode 100644
index 00000000..fe1f052b
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/reflect/delete-property.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/reflect/delete-property");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/reflect/get-metadata-keys.js b/node_modules/@babel/runtime/core-js/reflect/get-metadata-keys.js
new file mode 100644
index 00000000..2f6d2345
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/reflect/get-metadata-keys.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/reflect/get-metadata-keys");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/reflect/get-metadata.js b/node_modules/@babel/runtime/core-js/reflect/get-metadata.js
new file mode 100644
index 00000000..e9aca91c
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/reflect/get-metadata.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/reflect/get-metadata");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/reflect/get-own-metadata-keys.js b/node_modules/@babel/runtime/core-js/reflect/get-own-metadata-keys.js
new file mode 100644
index 00000000..15f9a61b
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/reflect/get-own-metadata-keys.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/reflect/get-own-metadata-keys");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/reflect/get-own-metadata.js b/node_modules/@babel/runtime/core-js/reflect/get-own-metadata.js
new file mode 100644
index 00000000..06a8f72a
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/reflect/get-own-metadata.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/reflect/get-own-metadata");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/reflect/get-own-property-descriptor.js b/node_modules/@babel/runtime/core-js/reflect/get-own-property-descriptor.js
new file mode 100644
index 00000000..036d6069
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/reflect/get-own-property-descriptor.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/reflect/get-own-property-descriptor");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/reflect/get-prototype-of.js b/node_modules/@babel/runtime/core-js/reflect/get-prototype-of.js
new file mode 100644
index 00000000..7aec75d8
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/reflect/get-prototype-of.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/reflect/get-prototype-of");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/reflect/get.js b/node_modules/@babel/runtime/core-js/reflect/get.js
new file mode 100644
index 00000000..66273a08
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/reflect/get.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/reflect/get");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/reflect/has-metadata.js b/node_modules/@babel/runtime/core-js/reflect/has-metadata.js
new file mode 100644
index 00000000..b8a327e9
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/reflect/has-metadata.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/reflect/has-metadata");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/reflect/has-own-metadata.js b/node_modules/@babel/runtime/core-js/reflect/has-own-metadata.js
new file mode 100644
index 00000000..867ec8cd
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/reflect/has-own-metadata.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/reflect/has-own-metadata");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/reflect/has.js b/node_modules/@babel/runtime/core-js/reflect/has.js
new file mode 100644
index 00000000..faee9f92
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/reflect/has.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/reflect/has");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/reflect/is-extensible.js b/node_modules/@babel/runtime/core-js/reflect/is-extensible.js
new file mode 100644
index 00000000..d44c1e19
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/reflect/is-extensible.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/reflect/is-extensible");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/reflect/metadata.js b/node_modules/@babel/runtime/core-js/reflect/metadata.js
new file mode 100644
index 00000000..d90b2c23
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/reflect/metadata.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/reflect/metadata");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/reflect/own-keys.js b/node_modules/@babel/runtime/core-js/reflect/own-keys.js
new file mode 100644
index 00000000..1663aa98
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/reflect/own-keys.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/reflect/own-keys");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/reflect/prevent-extensions.js b/node_modules/@babel/runtime/core-js/reflect/prevent-extensions.js
new file mode 100644
index 00000000..45a577cb
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/reflect/prevent-extensions.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/reflect/prevent-extensions");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/reflect/set-prototype-of.js b/node_modules/@babel/runtime/core-js/reflect/set-prototype-of.js
new file mode 100644
index 00000000..7d07bff6
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/reflect/set-prototype-of.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/reflect/set-prototype-of");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/reflect/set.js b/node_modules/@babel/runtime/core-js/reflect/set.js
new file mode 100644
index 00000000..3105f352
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/reflect/set.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/reflect/set");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/set-immediate.js b/node_modules/@babel/runtime/core-js/set-immediate.js
new file mode 100644
index 00000000..6d5e0797
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/set-immediate.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/set-immediate");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/set.js b/node_modules/@babel/runtime/core-js/set.js
new file mode 100644
index 00000000..b0b97c73
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/set.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/set");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/string/at.js b/node_modules/@babel/runtime/core-js/string/at.js
new file mode 100644
index 00000000..60e684c7
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/string/at.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/string/at");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/string/code-point-at.js b/node_modules/@babel/runtime/core-js/string/code-point-at.js
new file mode 100644
index 00000000..e8b25a9c
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/string/code-point-at.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/string/code-point-at");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/string/ends-with.js b/node_modules/@babel/runtime/core-js/string/ends-with.js
new file mode 100644
index 00000000..5a6a869d
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/string/ends-with.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/string/ends-with");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/string/from-code-point.js b/node_modules/@babel/runtime/core-js/string/from-code-point.js
new file mode 100644
index 00000000..bbb97b88
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/string/from-code-point.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/string/from-code-point");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/string/includes.js b/node_modules/@babel/runtime/core-js/string/includes.js
new file mode 100644
index 00000000..696e3244
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/string/includes.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/string/includes");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/string/match-all.js b/node_modules/@babel/runtime/core-js/string/match-all.js
new file mode 100644
index 00000000..c4099fdf
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/string/match-all.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/string/match-all");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/string/pad-end.js b/node_modules/@babel/runtime/core-js/string/pad-end.js
new file mode 100644
index 00000000..7680d7a4
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/string/pad-end.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/string/pad-end");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/string/pad-start.js b/node_modules/@babel/runtime/core-js/string/pad-start.js
new file mode 100644
index 00000000..dab2264d
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/string/pad-start.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/string/pad-start");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/string/raw.js b/node_modules/@babel/runtime/core-js/string/raw.js
new file mode 100644
index 00000000..c0aa9748
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/string/raw.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/string/raw");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/string/repeat.js b/node_modules/@babel/runtime/core-js/string/repeat.js
new file mode 100644
index 00000000..c66008ce
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/string/repeat.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/string/repeat");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/string/starts-with.js b/node_modules/@babel/runtime/core-js/string/starts-with.js
new file mode 100644
index 00000000..27d1e7bb
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/string/starts-with.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/string/starts-with");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/string/trim-end.js b/node_modules/@babel/runtime/core-js/string/trim-end.js
new file mode 100644
index 00000000..89cf3dc7
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/string/trim-end.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/string/trim-end");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/string/trim-left.js b/node_modules/@babel/runtime/core-js/string/trim-left.js
new file mode 100644
index 00000000..0f00429e
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/string/trim-left.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/string/trim-left");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/string/trim-right.js b/node_modules/@babel/runtime/core-js/string/trim-right.js
new file mode 100644
index 00000000..0d55b0b0
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/string/trim-right.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/string/trim-right");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/string/trim-start.js b/node_modules/@babel/runtime/core-js/string/trim-start.js
new file mode 100644
index 00000000..9928be4b
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/string/trim-start.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/string/trim-start");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/string/trim.js b/node_modules/@babel/runtime/core-js/string/trim.js
new file mode 100644
index 00000000..1606f52b
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/string/trim.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/string/trim");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/symbol.js b/node_modules/@babel/runtime/core-js/symbol.js
new file mode 100644
index 00000000..b6340327
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/symbol.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/symbol");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/symbol/for.js b/node_modules/@babel/runtime/core-js/symbol/for.js
new file mode 100644
index 00000000..735827cb
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/symbol/for.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/symbol/for");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/symbol/has-instance.js b/node_modules/@babel/runtime/core-js/symbol/has-instance.js
new file mode 100644
index 00000000..b0b925d1
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/symbol/has-instance.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/symbol/has-instance");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/symbol/is-concat-spreadable.js b/node_modules/@babel/runtime/core-js/symbol/is-concat-spreadable.js
new file mode 100644
index 00000000..1cdeee47
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/symbol/is-concat-spreadable.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/symbol/is-concat-spreadable");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/symbol/iterator.js b/node_modules/@babel/runtime/core-js/symbol/iterator.js
new file mode 100644
index 00000000..b9f7f87e
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/symbol/iterator.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/symbol/iterator");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/symbol/key-for.js b/node_modules/@babel/runtime/core-js/symbol/key-for.js
new file mode 100644
index 00000000..b3de60d0
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/symbol/key-for.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/symbol/key-for");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/symbol/match.js b/node_modules/@babel/runtime/core-js/symbol/match.js
new file mode 100644
index 00000000..5993dcc5
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/symbol/match.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/symbol/match");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/symbol/replace.js b/node_modules/@babel/runtime/core-js/symbol/replace.js
new file mode 100644
index 00000000..c8d16b56
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/symbol/replace.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/symbol/replace");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/symbol/search.js b/node_modules/@babel/runtime/core-js/symbol/search.js
new file mode 100644
index 00000000..75341991
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/symbol/search.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/symbol/search");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/symbol/species.js b/node_modules/@babel/runtime/core-js/symbol/species.js
new file mode 100644
index 00000000..a79deb01
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/symbol/species.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/symbol/species");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/symbol/split.js b/node_modules/@babel/runtime/core-js/symbol/split.js
new file mode 100644
index 00000000..c7615094
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/symbol/split.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/symbol/split");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/symbol/to-primitive.js b/node_modules/@babel/runtime/core-js/symbol/to-primitive.js
new file mode 100644
index 00000000..6581cb6d
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/symbol/to-primitive.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/symbol/to-primitive");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/symbol/to-string-tag.js b/node_modules/@babel/runtime/core-js/symbol/to-string-tag.js
new file mode 100644
index 00000000..7991c9cf
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/symbol/to-string-tag.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/symbol/to-string-tag");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/symbol/unscopables.js b/node_modules/@babel/runtime/core-js/symbol/unscopables.js
new file mode 100644
index 00000000..69067955
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/symbol/unscopables.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/symbol/unscopables");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/system/global.js b/node_modules/@babel/runtime/core-js/system/global.js
new file mode 100644
index 00000000..fd35bdca
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/system/global.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/system/global");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/weak-map.js b/node_modules/@babel/runtime/core-js/weak-map.js
new file mode 100644
index 00000000..398a0496
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/weak-map.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/weak-map");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/core-js/weak-set.js b/node_modules/@babel/runtime/core-js/weak-set.js
new file mode 100644
index 00000000..9971a88a
--- /dev/null
+++ b/node_modules/@babel/runtime/core-js/weak-set.js
@@ -0,0 +1 @@
+module.exports = require("core-js/library/fn/weak-set");
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/AsyncGenerator.js b/node_modules/@babel/runtime/helpers/AsyncGenerator.js
new file mode 100644
index 00000000..0a023bf5
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/AsyncGenerator.js
@@ -0,0 +1,105 @@
+var _Symbol = require("../core-js/symbol");
+
+var _Promise = require("../core-js/promise");
+
+var AwaitValue = require("./AwaitValue");
+
+function AsyncGenerator(gen) {
+  var front, back;
+
+  function send(key, arg) {
+    return new _Promise(function (resolve, reject) {
+      var request = {
+        key: key,
+        arg: arg,
+        resolve: resolve,
+        reject: reject,
+        next: null
+      };
+
+      if (back) {
+        back = back.next = request;
+      } else {
+        front = back = request;
+        resume(key, arg);
+      }
+    });
+  }
+
+  function resume(key, arg) {
+    try {
+      var result = gen[key](arg);
+      var value = result.value;
+      var wrappedAwait = value instanceof AwaitValue;
+
+      _Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) {
+        if (wrappedAwait) {
+          resume("next", arg);
+          return;
+        }
+
+        settle(result.done ? "return" : "normal", arg);
+      }, function (err) {
+        resume("throw", err);
+      });
+    } catch (err) {
+      settle("throw", err);
+    }
+  }
+
+  function settle(type, value) {
+    switch (type) {
+      case "return":
+        front.resolve({
+          value: value,
+          done: true
+        });
+        break;
+
+      case "throw":
+        front.reject(value);
+        break;
+
+      default:
+        front.resolve({
+          value: value,
+          done: false
+        });
+        break;
+    }
+
+    front = front.next;
+
+    if (front) {
+      resume(front.key, front.arg);
+    } else {
+      back = null;
+    }
+  }
+
+  this._invoke = send;
+
+  if (typeof gen.return !== "function") {
+    this.return = undefined;
+  }
+}
+
+if (typeof _Symbol === "function" && _Symbol.asyncIterator) {
+  AsyncGenerator.prototype[_Symbol.asyncIterator] = function () {
+    return this;
+  };
+}
+
+AsyncGenerator.prototype.next = function (arg) {
+  return this._invoke("next", arg);
+};
+
+AsyncGenerator.prototype.throw = function (arg) {
+  return this._invoke("throw", arg);
+};
+
+AsyncGenerator.prototype.return = function (arg) {
+  return this._invoke("return", arg);
+};
+
+module.exports = AsyncGenerator;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/AwaitValue.js b/node_modules/@babel/runtime/helpers/AwaitValue.js
new file mode 100644
index 00000000..f9f41841
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/AwaitValue.js
@@ -0,0 +1,5 @@
+function _AwaitValue(value) {
+  this.wrapped = value;
+}
+
+module.exports = _AwaitValue;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/applyDecoratedDescriptor.js b/node_modules/@babel/runtime/helpers/applyDecoratedDescriptor.js
new file mode 100644
index 00000000..6f5cb091
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/applyDecoratedDescriptor.js
@@ -0,0 +1,30 @@
+function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
+  var desc = {};
+  Object['ke' + 'ys'](descriptor).forEach(function (key) {
+    desc[key] = descriptor[key];
+  });
+  desc.enumerable = !!desc.enumerable;
+  desc.configurable = !!desc.configurable;
+
+  if ('value' in desc || desc.initializer) {
+    desc.writable = true;
+  }
+
+  desc = decorators.slice().reverse().reduce(function (desc, decorator) {
+    return decorator(target, property, desc) || desc;
+  }, desc);
+
+  if (context && desc.initializer !== void 0) {
+    desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
+    desc.initializer = undefined;
+  }
+
+  if (desc.initializer === void 0) {
+    Object['define' + 'Property'](target, property, desc);
+    desc = null;
+  }
+
+  return desc;
+}
+
+module.exports = _applyDecoratedDescriptor;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/arrayWithHoles.js b/node_modules/@babel/runtime/helpers/arrayWithHoles.js
new file mode 100644
index 00000000..5a62a8ce
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/arrayWithHoles.js
@@ -0,0 +1,5 @@
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+
+module.exports = _arrayWithHoles;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js b/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js
new file mode 100644
index 00000000..3234017e
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js
@@ -0,0 +1,11 @@
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) {
+    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
+      arr2[i] = arr[i];
+    }
+
+    return arr2;
+  }
+}
+
+module.exports = _arrayWithoutHoles;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/assertThisInitialized.js b/node_modules/@babel/runtime/helpers/assertThisInitialized.js
new file mode 100644
index 00000000..98d29498
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/assertThisInitialized.js
@@ -0,0 +1,9 @@
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}
+
+module.exports = _assertThisInitialized;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/asyncGeneratorDelegate.js b/node_modules/@babel/runtime/helpers/asyncGeneratorDelegate.js
new file mode 100644
index 00000000..6773e60a
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/asyncGeneratorDelegate.js
@@ -0,0 +1,59 @@
+var _Symbol$iterator = require("../core-js/symbol/iterator");
+
+var _Symbol = require("../core-js/symbol");
+
+var _Promise = require("../core-js/promise");
+
+function _asyncGeneratorDelegate(inner, awaitWrap) {
+  var iter = {},
+      waiting = false;
+
+  function pump(key, value) {
+    waiting = true;
+    value = new _Promise(function (resolve) {
+      resolve(inner[key](value));
+    });
+    return {
+      done: false,
+      value: awaitWrap(value)
+    };
+  }
+
+  ;
+
+  if (typeof _Symbol === "function" && _Symbol$iterator) {
+    iter[_Symbol$iterator] = function () {
+      return this;
+    };
+  }
+
+  iter.next = function (value) {
+    if (waiting) {
+      waiting = false;
+      return value;
+    }
+
+    return pump("next", value);
+  };
+
+  if (typeof inner.throw === "function") {
+    iter.throw = function (value) {
+      if (waiting) {
+        waiting = false;
+        throw value;
+      }
+
+      return pump("throw", value);
+    };
+  }
+
+  if (typeof inner.return === "function") {
+    iter.return = function (value) {
+      return pump("return", value);
+    };
+  }
+
+  return iter;
+}
+
+module.exports = _asyncGeneratorDelegate;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/asyncIterator.js b/node_modules/@babel/runtime/helpers/asyncIterator.js
new file mode 100644
index 00000000..ac3f529d
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/asyncIterator.js
@@ -0,0 +1,23 @@
+var _Symbol$iterator = require("../core-js/symbol/iterator");
+
+var _Symbol = require("../core-js/symbol");
+
+function _asyncIterator(iterable) {
+  var method;
+
+  if (typeof _Symbol === "function") {
+    if (_Symbol.asyncIterator) {
+      method = iterable[_Symbol.asyncIterator];
+      if (method != null) return method.call(iterable);
+    }
+
+    if (_Symbol$iterator) {
+      method = iterable[_Symbol$iterator];
+      if (method != null) return method.call(iterable);
+    }
+  }
+
+  throw new TypeError("Object is not async iterable");
+}
+
+module.exports = _asyncIterator;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/asyncToGenerator.js b/node_modules/@babel/runtime/helpers/asyncToGenerator.js
new file mode 100644
index 00000000..81d6d1d2
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/asyncToGenerator.js
@@ -0,0 +1,39 @@
+var _Promise = require("../core-js/promise");
+
+function _asyncToGenerator(fn) {
+  return function () {
+    var self = this,
+        args = arguments;
+    return new _Promise(function (resolve, reject) {
+      var gen = fn.apply(self, args);
+
+      function step(key, arg) {
+        try {
+          var info = gen[key](arg);
+          var value = info.value;
+        } catch (error) {
+          reject(error);
+          return;
+        }
+
+        if (info.done) {
+          resolve(value);
+        } else {
+          _Promise.resolve(value).then(_next, _throw);
+        }
+      }
+
+      function _next(value) {
+        step("next", value);
+      }
+
+      function _throw(err) {
+        step("throw", err);
+      }
+
+      _next();
+    });
+  };
+}
+
+module.exports = _asyncToGenerator;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/awaitAsyncGenerator.js b/node_modules/@babel/runtime/helpers/awaitAsyncGenerator.js
new file mode 100644
index 00000000..59f797af
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/awaitAsyncGenerator.js
@@ -0,0 +1,7 @@
+var AwaitValue = require("./AwaitValue");
+
+function _awaitAsyncGenerator(value) {
+  return new AwaitValue(value);
+}
+
+module.exports = _awaitAsyncGenerator;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/AsyncGenerator.js b/node_modules/@babel/runtime/helpers/builtin/AsyncGenerator.js
new file mode 100644
index 00000000..4962efcd
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/AsyncGenerator.js
@@ -0,0 +1,100 @@
+var AwaitValue = require("./AwaitValue");
+
+function AsyncGenerator(gen) {
+  var front, back;
+
+  function send(key, arg) {
+    return new Promise(function (resolve, reject) {
+      var request = {
+        key: key,
+        arg: arg,
+        resolve: resolve,
+        reject: reject,
+        next: null
+      };
+
+      if (back) {
+        back = back.next = request;
+      } else {
+        front = back = request;
+        resume(key, arg);
+      }
+    });
+  }
+
+  function resume(key, arg) {
+    try {
+      var result = gen[key](arg);
+      var value = result.value;
+      var wrappedAwait = value instanceof AwaitValue;
+      Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) {
+        if (wrappedAwait) {
+          resume("next", arg);
+          return;
+        }
+
+        settle(result.done ? "return" : "normal", arg);
+      }, function (err) {
+        resume("throw", err);
+      });
+    } catch (err) {
+      settle("throw", err);
+    }
+  }
+
+  function settle(type, value) {
+    switch (type) {
+      case "return":
+        front.resolve({
+          value: value,
+          done: true
+        });
+        break;
+
+      case "throw":
+        front.reject(value);
+        break;
+
+      default:
+        front.resolve({
+          value: value,
+          done: false
+        });
+        break;
+    }
+
+    front = front.next;
+
+    if (front) {
+      resume(front.key, front.arg);
+    } else {
+      back = null;
+    }
+  }
+
+  this._invoke = send;
+
+  if (typeof gen.return !== "function") {
+    this.return = undefined;
+  }
+}
+
+if (typeof Symbol === "function" && Symbol.asyncIterator) {
+  AsyncGenerator.prototype[Symbol.asyncIterator] = function () {
+    return this;
+  };
+}
+
+AsyncGenerator.prototype.next = function (arg) {
+  return this._invoke("next", arg);
+};
+
+AsyncGenerator.prototype.throw = function (arg) {
+  return this._invoke("throw", arg);
+};
+
+AsyncGenerator.prototype.return = function (arg) {
+  return this._invoke("return", arg);
+};
+
+module.exports = AsyncGenerator;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/AwaitValue.js b/node_modules/@babel/runtime/helpers/builtin/AwaitValue.js
new file mode 100644
index 00000000..f9f41841
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/AwaitValue.js
@@ -0,0 +1,5 @@
+function _AwaitValue(value) {
+  this.wrapped = value;
+}
+
+module.exports = _AwaitValue;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/applyDecoratedDescriptor.js b/node_modules/@babel/runtime/helpers/builtin/applyDecoratedDescriptor.js
new file mode 100644
index 00000000..6f5cb091
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/applyDecoratedDescriptor.js
@@ -0,0 +1,30 @@
+function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
+  var desc = {};
+  Object['ke' + 'ys'](descriptor).forEach(function (key) {
+    desc[key] = descriptor[key];
+  });
+  desc.enumerable = !!desc.enumerable;
+  desc.configurable = !!desc.configurable;
+
+  if ('value' in desc || desc.initializer) {
+    desc.writable = true;
+  }
+
+  desc = decorators.slice().reverse().reduce(function (desc, decorator) {
+    return decorator(target, property, desc) || desc;
+  }, desc);
+
+  if (context && desc.initializer !== void 0) {
+    desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
+    desc.initializer = undefined;
+  }
+
+  if (desc.initializer === void 0) {
+    Object['define' + 'Property'](target, property, desc);
+    desc = null;
+  }
+
+  return desc;
+}
+
+module.exports = _applyDecoratedDescriptor;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/arrayWithHoles.js b/node_modules/@babel/runtime/helpers/builtin/arrayWithHoles.js
new file mode 100644
index 00000000..5a62a8ce
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/arrayWithHoles.js
@@ -0,0 +1,5 @@
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+
+module.exports = _arrayWithHoles;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/arrayWithoutHoles.js b/node_modules/@babel/runtime/helpers/builtin/arrayWithoutHoles.js
new file mode 100644
index 00000000..3234017e
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/arrayWithoutHoles.js
@@ -0,0 +1,11 @@
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) {
+    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
+      arr2[i] = arr[i];
+    }
+
+    return arr2;
+  }
+}
+
+module.exports = _arrayWithoutHoles;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/assertThisInitialized.js b/node_modules/@babel/runtime/helpers/builtin/assertThisInitialized.js
new file mode 100644
index 00000000..98d29498
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/assertThisInitialized.js
@@ -0,0 +1,9 @@
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}
+
+module.exports = _assertThisInitialized;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/asyncGeneratorDelegate.js b/node_modules/@babel/runtime/helpers/builtin/asyncGeneratorDelegate.js
new file mode 100644
index 00000000..3211e9da
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/asyncGeneratorDelegate.js
@@ -0,0 +1,53 @@
+function _asyncGeneratorDelegate(inner, awaitWrap) {
+  var iter = {},
+      waiting = false;
+
+  function pump(key, value) {
+    waiting = true;
+    value = new Promise(function (resolve) {
+      resolve(inner[key](value));
+    });
+    return {
+      done: false,
+      value: awaitWrap(value)
+    };
+  }
+
+  ;
+
+  if (typeof Symbol === "function" && Symbol.iterator) {
+    iter[Symbol.iterator] = function () {
+      return this;
+    };
+  }
+
+  iter.next = function (value) {
+    if (waiting) {
+      waiting = false;
+      return value;
+    }
+
+    return pump("next", value);
+  };
+
+  if (typeof inner.throw === "function") {
+    iter.throw = function (value) {
+      if (waiting) {
+        waiting = false;
+        throw value;
+      }
+
+      return pump("throw", value);
+    };
+  }
+
+  if (typeof inner.return === "function") {
+    iter.return = function (value) {
+      return pump("return", value);
+    };
+  }
+
+  return iter;
+}
+
+module.exports = _asyncGeneratorDelegate;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/asyncIterator.js b/node_modules/@babel/runtime/helpers/builtin/asyncIterator.js
new file mode 100644
index 00000000..c1a1b313
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/asyncIterator.js
@@ -0,0 +1,19 @@
+function _asyncIterator(iterable) {
+  var method;
+
+  if (typeof Symbol === "function") {
+    if (Symbol.asyncIterator) {
+      method = iterable[Symbol.asyncIterator];
+      if (method != null) return method.call(iterable);
+    }
+
+    if (Symbol.iterator) {
+      method = iterable[Symbol.iterator];
+      if (method != null) return method.call(iterable);
+    }
+  }
+
+  throw new TypeError("Object is not async iterable");
+}
+
+module.exports = _asyncIterator;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/asyncToGenerator.js b/node_modules/@babel/runtime/helpers/builtin/asyncToGenerator.js
new file mode 100644
index 00000000..60ef4048
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/asyncToGenerator.js
@@ -0,0 +1,37 @@
+function _asyncToGenerator(fn) {
+  return function () {
+    var self = this,
+        args = arguments;
+    return new Promise(function (resolve, reject) {
+      var gen = fn.apply(self, args);
+
+      function step(key, arg) {
+        try {
+          var info = gen[key](arg);
+          var value = info.value;
+        } catch (error) {
+          reject(error);
+          return;
+        }
+
+        if (info.done) {
+          resolve(value);
+        } else {
+          Promise.resolve(value).then(_next, _throw);
+        }
+      }
+
+      function _next(value) {
+        step("next", value);
+      }
+
+      function _throw(err) {
+        step("throw", err);
+      }
+
+      _next();
+    });
+  };
+}
+
+module.exports = _asyncToGenerator;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/awaitAsyncGenerator.js b/node_modules/@babel/runtime/helpers/builtin/awaitAsyncGenerator.js
new file mode 100644
index 00000000..59f797af
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/awaitAsyncGenerator.js
@@ -0,0 +1,7 @@
+var AwaitValue = require("./AwaitValue");
+
+function _awaitAsyncGenerator(value) {
+  return new AwaitValue(value);
+}
+
+module.exports = _awaitAsyncGenerator;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/classCallCheck.js b/node_modules/@babel/runtime/helpers/builtin/classCallCheck.js
new file mode 100644
index 00000000..f389f2e8
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/classCallCheck.js
@@ -0,0 +1,7 @@
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+
+module.exports = _classCallCheck;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/classNameTDZError.js b/node_modules/@babel/runtime/helpers/builtin/classNameTDZError.js
new file mode 100644
index 00000000..8c1bdf55
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/classNameTDZError.js
@@ -0,0 +1,5 @@
+function _classNameTDZError(name) {
+  throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys.");
+}
+
+module.exports = _classNameTDZError;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/construct.js b/node_modules/@babel/runtime/helpers/builtin/construct.js
new file mode 100644
index 00000000..7a997036
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/construct.js
@@ -0,0 +1,20 @@
+var setPrototypeOf = require("./setPrototypeOf");
+
+function _construct(Parent, args, Class) {
+  if (typeof Reflect !== "undefined" && Reflect.construct) {
+    module.exports = _construct = Reflect.construct;
+  } else {
+    module.exports = _construct = function _construct(Parent, args, Class) {
+      var a = [null];
+      a.push.apply(a, args);
+      var Constructor = Parent.bind.apply(Parent, a);
+      var instance = new Constructor();
+      if (Class) setPrototypeOf(instance, Class.prototype);
+      return instance;
+    };
+  }
+
+  return _construct.apply(null, arguments);
+}
+
+module.exports = _construct;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/createClass.js b/node_modules/@babel/runtime/helpers/builtin/createClass.js
new file mode 100644
index 00000000..f9d48410
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/createClass.js
@@ -0,0 +1,17 @@
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+
+module.exports = _createClass;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/defaults.js b/node_modules/@babel/runtime/helpers/builtin/defaults.js
new file mode 100644
index 00000000..55ba1feb
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/defaults.js
@@ -0,0 +1,16 @@
+function _defaults(obj, defaults) {
+  var keys = Object.getOwnPropertyNames(defaults);
+
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    var value = Object.getOwnPropertyDescriptor(defaults, key);
+
+    if (value && value.configurable && obj[key] === undefined) {
+      Object.defineProperty(obj, key, value);
+    }
+  }
+
+  return obj;
+}
+
+module.exports = _defaults;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/defineEnumerableProperties.js b/node_modules/@babel/runtime/helpers/builtin/defineEnumerableProperties.js
new file mode 100644
index 00000000..5d80ea1e
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/defineEnumerableProperties.js
@@ -0,0 +1,24 @@
+function _defineEnumerableProperties(obj, descs) {
+  for (var key in descs) {
+    var desc = descs[key];
+    desc.configurable = desc.enumerable = true;
+    if ("value" in desc) desc.writable = true;
+    Object.defineProperty(obj, key, desc);
+  }
+
+  if (Object.getOwnPropertySymbols) {
+    var objectSymbols = Object.getOwnPropertySymbols(descs);
+
+    for (var i = 0; i < objectSymbols.length; i++) {
+      var sym = objectSymbols[i];
+      var desc = descs[sym];
+      desc.configurable = desc.enumerable = true;
+      if ("value" in desc) desc.writable = true;
+      Object.defineProperty(obj, sym, desc);
+    }
+  }
+
+  return obj;
+}
+
+module.exports = _defineEnumerableProperties;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/defineProperty.js b/node_modules/@babel/runtime/helpers/builtin/defineProperty.js
new file mode 100644
index 00000000..32a8d73f
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/defineProperty.js
@@ -0,0 +1,16 @@
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+module.exports = _defineProperty;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/AsyncGenerator.js b/node_modules/@babel/runtime/helpers/builtin/es6/AsyncGenerator.js
new file mode 100644
index 00000000..9b774680
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/AsyncGenerator.js
@@ -0,0 +1,97 @@
+import AwaitValue from "./AwaitValue";
+export default function AsyncGenerator(gen) {
+  var front, back;
+
+  function send(key, arg) {
+    return new Promise(function (resolve, reject) {
+      var request = {
+        key: key,
+        arg: arg,
+        resolve: resolve,
+        reject: reject,
+        next: null
+      };
+
+      if (back) {
+        back = back.next = request;
+      } else {
+        front = back = request;
+        resume(key, arg);
+      }
+    });
+  }
+
+  function resume(key, arg) {
+    try {
+      var result = gen[key](arg);
+      var value = result.value;
+      var wrappedAwait = value instanceof AwaitValue;
+      Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) {
+        if (wrappedAwait) {
+          resume("next", arg);
+          return;
+        }
+
+        settle(result.done ? "return" : "normal", arg);
+      }, function (err) {
+        resume("throw", err);
+      });
+    } catch (err) {
+      settle("throw", err);
+    }
+  }
+
+  function settle(type, value) {
+    switch (type) {
+      case "return":
+        front.resolve({
+          value: value,
+          done: true
+        });
+        break;
+
+      case "throw":
+        front.reject(value);
+        break;
+
+      default:
+        front.resolve({
+          value: value,
+          done: false
+        });
+        break;
+    }
+
+    front = front.next;
+
+    if (front) {
+      resume(front.key, front.arg);
+    } else {
+      back = null;
+    }
+  }
+
+  this._invoke = send;
+
+  if (typeof gen.return !== "function") {
+    this.return = undefined;
+  }
+}
+
+if (typeof Symbol === "function" && Symbol.asyncIterator) {
+  AsyncGenerator.prototype[Symbol.asyncIterator] = function () {
+    return this;
+  };
+}
+
+AsyncGenerator.prototype.next = function (arg) {
+  return this._invoke("next", arg);
+};
+
+AsyncGenerator.prototype.throw = function (arg) {
+  return this._invoke("throw", arg);
+};
+
+AsyncGenerator.prototype.return = function (arg) {
+  return this._invoke("return", arg);
+};
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/AwaitValue.js b/node_modules/@babel/runtime/helpers/builtin/es6/AwaitValue.js
new file mode 100644
index 00000000..5237e18f
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/AwaitValue.js
@@ -0,0 +1,3 @@
+export default function _AwaitValue(value) {
+  this.wrapped = value;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/applyDecoratedDescriptor.js b/node_modules/@babel/runtime/helpers/builtin/es6/applyDecoratedDescriptor.js
new file mode 100644
index 00000000..74923717
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/applyDecoratedDescriptor.js
@@ -0,0 +1,28 @@
+export default function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
+  var desc = {};
+  Object['ke' + 'ys'](descriptor).forEach(function (key) {
+    desc[key] = descriptor[key];
+  });
+  desc.enumerable = !!desc.enumerable;
+  desc.configurable = !!desc.configurable;
+
+  if ('value' in desc || desc.initializer) {
+    desc.writable = true;
+  }
+
+  desc = decorators.slice().reverse().reduce(function (desc, decorator) {
+    return decorator(target, property, desc) || desc;
+  }, desc);
+
+  if (context && desc.initializer !== void 0) {
+    desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
+    desc.initializer = undefined;
+  }
+
+  if (desc.initializer === void 0) {
+    Object['define' + 'Property'](target, property, desc);
+    desc = null;
+  }
+
+  return desc;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/arrayWithHoles.js b/node_modules/@babel/runtime/helpers/builtin/es6/arrayWithHoles.js
new file mode 100644
index 00000000..be734fc3
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/arrayWithHoles.js
@@ -0,0 +1,3 @@
+export default function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/arrayWithoutHoles.js b/node_modules/@babel/runtime/helpers/builtin/es6/arrayWithoutHoles.js
new file mode 100644
index 00000000..cbcffa15
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/arrayWithoutHoles.js
@@ -0,0 +1,9 @@
+export default function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) {
+    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
+      arr2[i] = arr[i];
+    }
+
+    return arr2;
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/assertThisInitialized.js b/node_modules/@babel/runtime/helpers/builtin/es6/assertThisInitialized.js
new file mode 100644
index 00000000..bbf849ca
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/assertThisInitialized.js
@@ -0,0 +1,7 @@
+export default function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/asyncGeneratorDelegate.js b/node_modules/@babel/runtime/helpers/builtin/es6/asyncGeneratorDelegate.js
new file mode 100644
index 00000000..8cde993b
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/asyncGeneratorDelegate.js
@@ -0,0 +1,51 @@
+export default function _asyncGeneratorDelegate(inner, awaitWrap) {
+  var iter = {},
+      waiting = false;
+
+  function pump(key, value) {
+    waiting = true;
+    value = new Promise(function (resolve) {
+      resolve(inner[key](value));
+    });
+    return {
+      done: false,
+      value: awaitWrap(value)
+    };
+  }
+
+  ;
+
+  if (typeof Symbol === "function" && Symbol.iterator) {
+    iter[Symbol.iterator] = function () {
+      return this;
+    };
+  }
+
+  iter.next = function (value) {
+    if (waiting) {
+      waiting = false;
+      return value;
+    }
+
+    return pump("next", value);
+  };
+
+  if (typeof inner.throw === "function") {
+    iter.throw = function (value) {
+      if (waiting) {
+        waiting = false;
+        throw value;
+      }
+
+      return pump("throw", value);
+    };
+  }
+
+  if (typeof inner.return === "function") {
+    iter.return = function (value) {
+      return pump("return", value);
+    };
+  }
+
+  return iter;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/asyncIterator.js b/node_modules/@babel/runtime/helpers/builtin/es6/asyncIterator.js
new file mode 100644
index 00000000..c43366eb
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/asyncIterator.js
@@ -0,0 +1,17 @@
+export default function _asyncIterator(iterable) {
+  var method;
+
+  if (typeof Symbol === "function") {
+    if (Symbol.asyncIterator) {
+      method = iterable[Symbol.asyncIterator];
+      if (method != null) return method.call(iterable);
+    }
+
+    if (Symbol.iterator) {
+      method = iterable[Symbol.iterator];
+      if (method != null) return method.call(iterable);
+    }
+  }
+
+  throw new TypeError("Object is not async iterable");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/asyncToGenerator.js b/node_modules/@babel/runtime/helpers/builtin/es6/asyncToGenerator.js
new file mode 100644
index 00000000..bfe88265
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/asyncToGenerator.js
@@ -0,0 +1,35 @@
+export default function _asyncToGenerator(fn) {
+  return function () {
+    var self = this,
+        args = arguments;
+    return new Promise(function (resolve, reject) {
+      var gen = fn.apply(self, args);
+
+      function step(key, arg) {
+        try {
+          var info = gen[key](arg);
+          var value = info.value;
+        } catch (error) {
+          reject(error);
+          return;
+        }
+
+        if (info.done) {
+          resolve(value);
+        } else {
+          Promise.resolve(value).then(_next, _throw);
+        }
+      }
+
+      function _next(value) {
+        step("next", value);
+      }
+
+      function _throw(err) {
+        step("throw", err);
+      }
+
+      _next();
+    });
+  };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/awaitAsyncGenerator.js b/node_modules/@babel/runtime/helpers/builtin/es6/awaitAsyncGenerator.js
new file mode 100644
index 00000000..462f99cd
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/awaitAsyncGenerator.js
@@ -0,0 +1,4 @@
+import AwaitValue from "./AwaitValue";
+export default function _awaitAsyncGenerator(value) {
+  return new AwaitValue(value);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/classCallCheck.js b/node_modules/@babel/runtime/helpers/builtin/es6/classCallCheck.js
new file mode 100644
index 00000000..2f1738a3
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/classCallCheck.js
@@ -0,0 +1,5 @@
+export default function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/classNameTDZError.js b/node_modules/@babel/runtime/helpers/builtin/es6/classNameTDZError.js
new file mode 100644
index 00000000..f7b6dd57
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/classNameTDZError.js
@@ -0,0 +1,3 @@
+export default function _classNameTDZError(name) {
+  throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys.");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/construct.js b/node_modules/@babel/runtime/helpers/builtin/es6/construct.js
new file mode 100644
index 00000000..c0ff6eaa
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/construct.js
@@ -0,0 +1,17 @@
+import setPrototypeOf from "./setPrototypeOf";
+export default function _construct(Parent, args, Class) {
+  if (typeof Reflect !== "undefined" && Reflect.construct) {
+    _construct = Reflect.construct;
+  } else {
+    _construct = function _construct(Parent, args, Class) {
+      var a = [null];
+      a.push.apply(a, args);
+      var Constructor = Parent.bind.apply(Parent, a);
+      var instance = new Constructor();
+      if (Class) setPrototypeOf(instance, Class.prototype);
+      return instance;
+    };
+  }
+
+  return _construct.apply(null, arguments);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/createClass.js b/node_modules/@babel/runtime/helpers/builtin/es6/createClass.js
new file mode 100644
index 00000000..d6cf4122
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/createClass.js
@@ -0,0 +1,15 @@
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+
+export default function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/defaults.js b/node_modules/@babel/runtime/helpers/builtin/es6/defaults.js
new file mode 100644
index 00000000..3de1d8ec
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/defaults.js
@@ -0,0 +1,14 @@
+export default function _defaults(obj, defaults) {
+  var keys = Object.getOwnPropertyNames(defaults);
+
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    var value = Object.getOwnPropertyDescriptor(defaults, key);
+
+    if (value && value.configurable && obj[key] === undefined) {
+      Object.defineProperty(obj, key, value);
+    }
+  }
+
+  return obj;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/defineEnumerableProperties.js b/node_modules/@babel/runtime/helpers/builtin/es6/defineEnumerableProperties.js
new file mode 100644
index 00000000..7981acd4
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/defineEnumerableProperties.js
@@ -0,0 +1,22 @@
+export default function _defineEnumerableProperties(obj, descs) {
+  for (var key in descs) {
+    var desc = descs[key];
+    desc.configurable = desc.enumerable = true;
+    if ("value" in desc) desc.writable = true;
+    Object.defineProperty(obj, key, desc);
+  }
+
+  if (Object.getOwnPropertySymbols) {
+    var objectSymbols = Object.getOwnPropertySymbols(descs);
+
+    for (var i = 0; i < objectSymbols.length; i++) {
+      var sym = objectSymbols[i];
+      var desc = descs[sym];
+      desc.configurable = desc.enumerable = true;
+      if ("value" in desc) desc.writable = true;
+      Object.defineProperty(obj, sym, desc);
+    }
+  }
+
+  return obj;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/defineProperty.js b/node_modules/@babel/runtime/helpers/builtin/es6/defineProperty.js
new file mode 100644
index 00000000..7cf6e59f
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/defineProperty.js
@@ -0,0 +1,14 @@
+export default function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/extends.js b/node_modules/@babel/runtime/helpers/builtin/es6/extends.js
new file mode 100644
index 00000000..b9b138d8
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/extends.js
@@ -0,0 +1,17 @@
+export default function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/get.js b/node_modules/@babel/runtime/helpers/builtin/es6/get.js
new file mode 100644
index 00000000..c0b7bce6
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/get.js
@@ -0,0 +1,21 @@
+import getPrototypeOf from "./getPrototypeOf";
+import superPropBase from "./superPropBase";
+export default function _get(target, property, receiver) {
+  if (typeof Reflect !== "undefined" && Reflect.get) {
+    _get = Reflect.get;
+  } else {
+    _get = function _get(target, property, receiver) {
+      var base = superPropBase(target, property);
+      if (!base) return;
+      var desc = Object.getOwnPropertyDescriptor(base, property);
+
+      if (desc.get) {
+        return desc.get.call(receiver);
+      }
+
+      return desc.value;
+    };
+  }
+
+  return _get(target, property, receiver || target);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/getPrototypeOf.js b/node_modules/@babel/runtime/helpers/builtin/es6/getPrototypeOf.js
new file mode 100644
index 00000000..b4e6d0a6
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/getPrototypeOf.js
@@ -0,0 +1,7 @@
+export default function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) {
+    return o.__proto__;
+  };
+
+  return _getPrototypeOf(o);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/inherits.js b/node_modules/@babel/runtime/helpers/builtin/es6/inherits.js
new file mode 100644
index 00000000..a1024204
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/inherits.js
@@ -0,0 +1,9 @@
+import setPrototypeOf from "./setPrototypeOf";
+export default function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+
+  setPrototypeOf(subClass.prototype, superClass && superClass.prototype);
+  if (superClass) setPrototypeOf(subClass, superClass);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/inheritsLoose.js b/node_modules/@babel/runtime/helpers/builtin/es6/inheritsLoose.js
new file mode 100644
index 00000000..713d72c1
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/inheritsLoose.js
@@ -0,0 +1,4 @@
+export default function _inheritsLoose(subClass, superClass) {
+  subClass.prototype.__proto__ = superClass && superClass.prototype;
+  subClass.__proto__ = superClass;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/initializerDefineProperty.js b/node_modules/@babel/runtime/helpers/builtin/es6/initializerDefineProperty.js
new file mode 100644
index 00000000..26fdea08
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/initializerDefineProperty.js
@@ -0,0 +1,9 @@
+export default function _initializerDefineProperty(target, property, descriptor, context) {
+  if (!descriptor) return;
+  Object.defineProperty(target, property, {
+    enumerable: descriptor.enumerable,
+    configurable: descriptor.configurable,
+    writable: descriptor.writable,
+    value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
+  });
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/initializerWarningHelper.js b/node_modules/@babel/runtime/helpers/builtin/es6/initializerWarningHelper.js
new file mode 100644
index 00000000..d40ca01c
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/initializerWarningHelper.js
@@ -0,0 +1,3 @@
+export default function _initializerWarningHelper(descriptor, context) {
+  throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and set to use loose mode. ' + 'To use proposal-class-properties in spec mode with decorators, wait for ' + 'the next major version of decorators in stage 2.');
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/instanceof.js b/node_modules/@babel/runtime/helpers/builtin/es6/instanceof.js
new file mode 100644
index 00000000..51f1e67d
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/instanceof.js
@@ -0,0 +1,7 @@
+export default function _instanceof(left, right) {
+  if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+    return right[Symbol.hasInstance](left);
+  } else {
+    return left instanceof right;
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/interopRequireDefault.js b/node_modules/@babel/runtime/helpers/builtin/es6/interopRequireDefault.js
new file mode 100644
index 00000000..dd5e7815
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/interopRequireDefault.js
@@ -0,0 +1,5 @@
+export default function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/interopRequireWildcard.js b/node_modules/@babel/runtime/helpers/builtin/es6/interopRequireWildcard.js
new file mode 100644
index 00000000..c5065149
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/interopRequireWildcard.js
@@ -0,0 +1,24 @@
+export default function _interopRequireWildcard(obj) {
+  if (obj && obj.__esModule) {
+    return obj;
+  } else {
+    var newObj = {};
+
+    if (obj != null) {
+      for (var key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+          var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {};
+
+          if (desc.get || desc.set) {
+            Object.defineProperty(newObj, key, desc);
+          } else {
+            newObj[key] = obj[key];
+          }
+        }
+      }
+    }
+
+    newObj.default = obj;
+    return newObj;
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/iterableToArray.js b/node_modules/@babel/runtime/helpers/builtin/es6/iterableToArray.js
new file mode 100644
index 00000000..671e400d
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/iterableToArray.js
@@ -0,0 +1,3 @@
+export default function _iterableToArray(iter) {
+  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/iterableToArrayLimit.js b/node_modules/@babel/runtime/helpers/builtin/es6/iterableToArrayLimit.js
new file mode 100644
index 00000000..7234d8e6
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/iterableToArrayLimit.js
@@ -0,0 +1,25 @@
+export default function _iterableToArrayLimit(arr, i) {
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+  var _e = undefined;
+
+  try {
+    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+
+      if (i && _arr.length === i) break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) _i["return"]();
+    } finally {
+      if (_d) throw _e;
+    }
+  }
+
+  return _arr;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/iterableToArrayLimitLoose.js b/node_modules/@babel/runtime/helpers/builtin/es6/iterableToArrayLimitLoose.js
new file mode 100644
index 00000000..4261e294
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/iterableToArrayLimitLoose.js
@@ -0,0 +1,11 @@
+export default function _iterableToArrayLimitLoose(arr, i) {
+  var _arr = [];
+
+  for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) {
+    _arr.push(_step.value);
+
+    if (i && _arr.length === i) break;
+  }
+
+  return _arr;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/jsx.js b/node_modules/@babel/runtime/helpers/builtin/es6/jsx.js
new file mode 100644
index 00000000..e6f1bcb5
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/jsx.js
@@ -0,0 +1,46 @@
+var REACT_ELEMENT_TYPE;
+export default function _createRawReactElement(type, props, key, children) {
+  if (!REACT_ELEMENT_TYPE) {
+    REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol.for && Symbol.for("react.element") || 0xeac7;
+  }
+
+  var defaultProps = type && type.defaultProps;
+  var childrenLength = arguments.length - 3;
+
+  if (!props && childrenLength !== 0) {
+    props = {
+      children: void 0
+    };
+  }
+
+  if (props && defaultProps) {
+    for (var propName in defaultProps) {
+      if (props[propName] === void 0) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+  } else if (!props) {
+    props = defaultProps || {};
+  }
+
+  if (childrenLength === 1) {
+    props.children = children;
+  } else if (childrenLength > 1) {
+    var childArray = new Array(childrenLength);
+
+    for (var i = 0; i < childrenLength; i++) {
+      childArray[i] = arguments[i + 3];
+    }
+
+    props.children = childArray;
+  }
+
+  return {
+    $$typeof: REACT_ELEMENT_TYPE,
+    type: type,
+    key: key === undefined ? null : '' + key,
+    ref: null,
+    props: props,
+    _owner: null
+  };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/newArrowCheck.js b/node_modules/@babel/runtime/helpers/builtin/es6/newArrowCheck.js
new file mode 100644
index 00000000..d6cd8643
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/newArrowCheck.js
@@ -0,0 +1,5 @@
+export default function _newArrowCheck(innerThis, boundThis) {
+  if (innerThis !== boundThis) {
+    throw new TypeError("Cannot instantiate an arrow function");
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/nonIterableRest.js b/node_modules/@babel/runtime/helpers/builtin/es6/nonIterableRest.js
new file mode 100644
index 00000000..f94186da
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/nonIterableRest.js
@@ -0,0 +1,3 @@
+export default function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/nonIterableSpread.js b/node_modules/@babel/runtime/helpers/builtin/es6/nonIterableSpread.js
new file mode 100644
index 00000000..d6bc738a
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/nonIterableSpread.js
@@ -0,0 +1,3 @@
+export default function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/objectDestructuringEmpty.js b/node_modules/@babel/runtime/helpers/builtin/es6/objectDestructuringEmpty.js
new file mode 100644
index 00000000..82b67d2c
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/objectDestructuringEmpty.js
@@ -0,0 +1,3 @@
+export default function _objectDestructuringEmpty(obj) {
+  if (obj == null) throw new TypeError("Cannot destructure undefined");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/objectSpread.js b/node_modules/@babel/runtime/helpers/builtin/es6/objectSpread.js
new file mode 100644
index 00000000..918bc8e9
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/objectSpread.js
@@ -0,0 +1,19 @@
+import defineProperty from "./defineProperty";
+export default function _objectSpread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    var ownKeys = Object.keys(source);
+
+    if (typeof Object.getOwnPropertySymbols === 'function') {
+      ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
+        return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+      }));
+    }
+
+    ownKeys.forEach(function (key) {
+      defineProperty(target, key, source[key]);
+    });
+  }
+
+  return target;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/objectWithoutProperties.js b/node_modules/@babel/runtime/helpers/builtin/es6/objectWithoutProperties.js
new file mode 100644
index 00000000..5fb6631f
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/objectWithoutProperties.js
@@ -0,0 +1,25 @@
+export default function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+
+  return target;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/possibleConstructorReturn.js b/node_modules/@babel/runtime/helpers/builtin/es6/possibleConstructorReturn.js
new file mode 100644
index 00000000..7bb2ee63
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/possibleConstructorReturn.js
@@ -0,0 +1,9 @@
+import _typeof from "../../../helpers/builtin/es6/typeof";
+import assertThisInitialized from "./assertThisInitialized";
+export default function _possibleConstructorReturn(self, call) {
+  if (call && (_typeof(call) === "object" || typeof call === "function")) {
+    return call;
+  }
+
+  return assertThisInitialized(self);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/readOnlyError.js b/node_modules/@babel/runtime/helpers/builtin/es6/readOnlyError.js
new file mode 100644
index 00000000..45d01d72
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/readOnlyError.js
@@ -0,0 +1,3 @@
+export default function _readOnlyError(name) {
+  throw new Error("\"" + name + "\" is read-only");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/set.js b/node_modules/@babel/runtime/helpers/builtin/es6/set.js
new file mode 100644
index 00000000..b6a4c340
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/set.js
@@ -0,0 +1,52 @@
+import getPrototypeOf from "./getPrototypeOf";
+import superPropBase from "./superPropBase";
+import defineProperty from "./defineProperty";
+
+function set(target, property, value, receiver) {
+  if (typeof Reflect !== "undefined" && Reflect.set) {
+    set = Reflect.set;
+  } else {
+    set = function set(target, property, value, receiver) {
+      var base = superPropBase(target, property);
+      var desc;
+
+      if (base) {
+        desc = Object.getOwnPropertyDescriptor(base, property);
+
+        if (desc.set) {
+          desc.set.call(receiver, value);
+          return true;
+        } else if (!desc.writable) {
+          return false;
+        }
+      }
+
+      desc = Object.getOwnPropertyDescriptor(receiver, property);
+
+      if (desc) {
+        if (!desc.writable) {
+          return false;
+        }
+
+        desc.value = value;
+        Object.defineProperty(receiver, property, desc);
+      } else {
+        defineProperty(receiver, property, value);
+      }
+
+      return true;
+    };
+  }
+
+  return set(target, property, value, receiver);
+}
+
+export default function _set(target, property, value, receiver, isStrict) {
+  var s = set(target, property, value, receiver || target);
+
+  if (!s && isStrict) {
+    throw new Error('failed to set property');
+  }
+
+  return value;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/setPrototypeOf.js b/node_modules/@babel/runtime/helpers/builtin/es6/setPrototypeOf.js
new file mode 100644
index 00000000..e6ef03e5
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/setPrototypeOf.js
@@ -0,0 +1,8 @@
+export default function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+
+  return _setPrototypeOf(o, p);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/skipFirstGeneratorNext.js b/node_modules/@babel/runtime/helpers/builtin/es6/skipFirstGeneratorNext.js
new file mode 100644
index 00000000..cadd9bb5
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/skipFirstGeneratorNext.js
@@ -0,0 +1,7 @@
+export default function _skipFirstGeneratorNext(fn) {
+  return function () {
+    var it = fn.apply(this, arguments);
+    it.next();
+    return it;
+  };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/slicedToArray.js b/node_modules/@babel/runtime/helpers/builtin/es6/slicedToArray.js
new file mode 100644
index 00000000..f6f10816
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/slicedToArray.js
@@ -0,0 +1,6 @@
+import arrayWithHoles from "./arrayWithHoles";
+import iterableToArrayLimit from "./iterableToArrayLimit";
+import nonIterableRest from "./nonIterableRest";
+export default function _slicedToArray(arr, i) {
+  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || nonIterableRest();
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/slicedToArrayLoose.js b/node_modules/@babel/runtime/helpers/builtin/es6/slicedToArrayLoose.js
new file mode 100644
index 00000000..e6757890
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/slicedToArrayLoose.js
@@ -0,0 +1,6 @@
+import arrayWithHoles from "./arrayWithHoles";
+import iterableToArrayLimitLoose from "./iterableToArrayLimitLoose";
+import nonIterableRest from "./nonIterableRest";
+export default function _slicedToArrayLoose(arr, i) {
+  return arrayWithHoles(arr) || iterableToArrayLimitLoose(arr, i) || nonIterableRest();
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/superPropBase.js b/node_modules/@babel/runtime/helpers/builtin/es6/superPropBase.js
new file mode 100644
index 00000000..eace947c
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/superPropBase.js
@@ -0,0 +1,9 @@
+import getPrototypeOf from "./getPrototypeOf";
+export default function _superPropBase(object, property) {
+  while (!Object.prototype.hasOwnProperty.call(object, property)) {
+    object = getPrototypeOf(object);
+    if (object === null) break;
+  }
+
+  return object;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/taggedTemplateLiteral.js b/node_modules/@babel/runtime/helpers/builtin/es6/taggedTemplateLiteral.js
new file mode 100644
index 00000000..421f18ab
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/taggedTemplateLiteral.js
@@ -0,0 +1,11 @@
+export default function _taggedTemplateLiteral(strings, raw) {
+  if (!raw) {
+    raw = strings.slice(0);
+  }
+
+  return Object.freeze(Object.defineProperties(strings, {
+    raw: {
+      value: Object.freeze(raw)
+    }
+  }));
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/taggedTemplateLiteralLoose.js b/node_modules/@babel/runtime/helpers/builtin/es6/taggedTemplateLiteralLoose.js
new file mode 100644
index 00000000..c8f081e9
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/taggedTemplateLiteralLoose.js
@@ -0,0 +1,8 @@
+export default function _taggedTemplateLiteralLoose(strings, raw) {
+  if (!raw) {
+    raw = strings.slice(0);
+  }
+
+  strings.raw = raw;
+  return strings;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/temporalRef.js b/node_modules/@babel/runtime/helpers/builtin/es6/temporalRef.js
new file mode 100644
index 00000000..4b0679c6
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/temporalRef.js
@@ -0,0 +1,8 @@
+import undef from "./temporalUndefined";
+export default function _temporalRef(val, name) {
+  if (val === undef) {
+    throw new ReferenceError(name + " is not defined - temporal dead zone");
+  } else {
+    return val;
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/temporalUndefined.js b/node_modules/@babel/runtime/helpers/builtin/es6/temporalUndefined.js
new file mode 100644
index 00000000..7c645e42
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/temporalUndefined.js
@@ -0,0 +1 @@
+export default {};
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/toArray.js b/node_modules/@babel/runtime/helpers/builtin/es6/toArray.js
new file mode 100644
index 00000000..5acb22b3
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/toArray.js
@@ -0,0 +1,6 @@
+import arrayWithHoles from "./arrayWithHoles";
+import iterableToArray from "./iterableToArray";
+import nonIterableRest from "./nonIterableRest";
+export default function _toArray(arr) {
+  return arrayWithHoles(arr) || iterableToArray(arr) || nonIterableRest();
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/toConsumableArray.js b/node_modules/@babel/runtime/helpers/builtin/es6/toConsumableArray.js
new file mode 100644
index 00000000..7e480b9d
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/toConsumableArray.js
@@ -0,0 +1,6 @@
+import arrayWithoutHoles from "./arrayWithoutHoles";
+import iterableToArray from "./iterableToArray";
+import nonIterableSpread from "./nonIterableSpread";
+export default function _toConsumableArray(arr) {
+  return arrayWithoutHoles(arr) || iterableToArray(arr) || nonIterableSpread();
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/toPropertyKey.js b/node_modules/@babel/runtime/helpers/builtin/es6/toPropertyKey.js
new file mode 100644
index 00000000..9321458e
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/toPropertyKey.js
@@ -0,0 +1,8 @@
+import _typeof from "../../../helpers/builtin/es6/typeof";
+export default function _toPropertyKey(key) {
+  if (_typeof(key) === "symbol") {
+    return key;
+  } else {
+    return String(key);
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/typeof.js b/node_modules/@babel/runtime/helpers/builtin/es6/typeof.js
new file mode 100644
index 00000000..7825537f
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/typeof.js
@@ -0,0 +1,15 @@
+function _typeof2(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof2 = function _typeof2(obj) { return typeof obj; }; } else { _typeof2 = function _typeof2(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof2(obj); }
+
+export default function _typeof(obj) {
+  if (typeof Symbol === "function" && _typeof2(Symbol.iterator) === "symbol") {
+    _typeof = function _typeof(obj) {
+      return _typeof2(obj);
+    };
+  } else {
+    _typeof = function _typeof(obj) {
+      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : _typeof2(obj);
+    };
+  }
+
+  return _typeof(obj);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/wrapAsyncGenerator.js b/node_modules/@babel/runtime/helpers/builtin/es6/wrapAsyncGenerator.js
new file mode 100644
index 00000000..6d6d9811
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/wrapAsyncGenerator.js
@@ -0,0 +1,6 @@
+import AsyncGenerator from "./AsyncGenerator";
+export default function _wrapAsyncGenerator(fn) {
+  return function () {
+    return new AsyncGenerator(fn.apply(this, arguments));
+  };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/es6/wrapNativeSuper.js b/node_modules/@babel/runtime/helpers/builtin/es6/wrapNativeSuper.js
new file mode 100644
index 00000000..efa3bafc
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/es6/wrapNativeSuper.js
@@ -0,0 +1,34 @@
+import _gPO from "./getPrototypeOf";
+import _sPO from "./setPrototypeOf";
+import construct from "./construct";
+export default function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? new Map() : undefined;
+
+  _wrapNativeSuper = function _wrapNativeSuper(Class) {
+    if (typeof Class !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class)) return _cache.get(Class);
+
+      _cache.set(Class, Wrapper);
+    }
+
+    function Wrapper() {}
+
+    Wrapper.prototype = Object.create(Class.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _sPO(Wrapper, _sPO(function Super() {
+      return construct(Class, arguments, _gPO(this).constructor);
+    }, Class));
+  };
+
+  return _wrapNativeSuper(Class);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/extends.js b/node_modules/@babel/runtime/helpers/builtin/extends.js
new file mode 100644
index 00000000..1816877e
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/extends.js
@@ -0,0 +1,19 @@
+function _extends() {
+  module.exports = _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
+module.exports = _extends;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/get.js b/node_modules/@babel/runtime/helpers/builtin/get.js
new file mode 100644
index 00000000..2cd0bb43
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/get.js
@@ -0,0 +1,25 @@
+var getPrototypeOf = require("./getPrototypeOf");
+
+var superPropBase = require("./superPropBase");
+
+function _get(target, property, receiver) {
+  if (typeof Reflect !== "undefined" && Reflect.get) {
+    module.exports = _get = Reflect.get;
+  } else {
+    module.exports = _get = function _get(target, property, receiver) {
+      var base = superPropBase(target, property);
+      if (!base) return;
+      var desc = Object.getOwnPropertyDescriptor(base, property);
+
+      if (desc.get) {
+        return desc.get.call(receiver);
+      }
+
+      return desc.value;
+    };
+  }
+
+  return _get(target, property, receiver || target);
+}
+
+module.exports = _get;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/getPrototypeOf.js b/node_modules/@babel/runtime/helpers/builtin/getPrototypeOf.js
new file mode 100644
index 00000000..33cb17fa
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/getPrototypeOf.js
@@ -0,0 +1,9 @@
+function _getPrototypeOf(o) {
+  module.exports = _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) {
+    return o.__proto__;
+  };
+
+  return _getPrototypeOf(o);
+}
+
+module.exports = _getPrototypeOf;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/inherits.js b/node_modules/@babel/runtime/helpers/builtin/inherits.js
new file mode 100644
index 00000000..766ce4a9
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/inherits.js
@@ -0,0 +1,12 @@
+var setPrototypeOf = require("./setPrototypeOf");
+
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+
+  setPrototypeOf(subClass.prototype, superClass && superClass.prototype);
+  if (superClass) setPrototypeOf(subClass, superClass);
+}
+
+module.exports = _inherits;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/inheritsLoose.js b/node_modules/@babel/runtime/helpers/builtin/inheritsLoose.js
new file mode 100644
index 00000000..423693bb
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/inheritsLoose.js
@@ -0,0 +1,6 @@
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype.__proto__ = superClass && superClass.prototype;
+  subClass.__proto__ = superClass;
+}
+
+module.exports = _inheritsLoose;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/initializerDefineProperty.js b/node_modules/@babel/runtime/helpers/builtin/initializerDefineProperty.js
new file mode 100644
index 00000000..4caa5ca6
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/initializerDefineProperty.js
@@ -0,0 +1,11 @@
+function _initializerDefineProperty(target, property, descriptor, context) {
+  if (!descriptor) return;
+  Object.defineProperty(target, property, {
+    enumerable: descriptor.enumerable,
+    configurable: descriptor.configurable,
+    writable: descriptor.writable,
+    value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
+  });
+}
+
+module.exports = _initializerDefineProperty;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/initializerWarningHelper.js b/node_modules/@babel/runtime/helpers/builtin/initializerWarningHelper.js
new file mode 100644
index 00000000..56e0c173
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/initializerWarningHelper.js
@@ -0,0 +1,5 @@
+function _initializerWarningHelper(descriptor, context) {
+  throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and set to use loose mode. ' + 'To use proposal-class-properties in spec mode with decorators, wait for ' + 'the next major version of decorators in stage 2.');
+}
+
+module.exports = _initializerWarningHelper;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/instanceof.js b/node_modules/@babel/runtime/helpers/builtin/instanceof.js
new file mode 100644
index 00000000..d3cd18a5
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/instanceof.js
@@ -0,0 +1,9 @@
+function _instanceof(left, right) {
+  if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+    return right[Symbol.hasInstance](left);
+  } else {
+    return left instanceof right;
+  }
+}
+
+module.exports = _instanceof;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/interopRequireDefault.js b/node_modules/@babel/runtime/helpers/builtin/interopRequireDefault.js
new file mode 100644
index 00000000..0e65e2b8
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/interopRequireDefault.js
@@ -0,0 +1,7 @@
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}
+
+module.exports = _interopRequireDefault;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/interopRequireWildcard.js b/node_modules/@babel/runtime/helpers/builtin/interopRequireWildcard.js
new file mode 100644
index 00000000..baf08e2b
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/interopRequireWildcard.js
@@ -0,0 +1,26 @@
+function _interopRequireWildcard(obj) {
+  if (obj && obj.__esModule) {
+    return obj;
+  } else {
+    var newObj = {};
+
+    if (obj != null) {
+      for (var key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+          var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {};
+
+          if (desc.get || desc.set) {
+            Object.defineProperty(newObj, key, desc);
+          } else {
+            newObj[key] = obj[key];
+          }
+        }
+      }
+    }
+
+    newObj.default = obj;
+    return newObj;
+  }
+}
+
+module.exports = _interopRequireWildcard;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/iterableToArray.js b/node_modules/@babel/runtime/helpers/builtin/iterableToArray.js
new file mode 100644
index 00000000..e917e579
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/iterableToArray.js
@@ -0,0 +1,5 @@
+function _iterableToArray(iter) {
+  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
+}
+
+module.exports = _iterableToArray;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/iterableToArrayLimit.js b/node_modules/@babel/runtime/helpers/builtin/iterableToArrayLimit.js
new file mode 100644
index 00000000..14c1daa6
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/iterableToArrayLimit.js
@@ -0,0 +1,27 @@
+function _iterableToArrayLimit(arr, i) {
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+  var _e = undefined;
+
+  try {
+    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+
+      if (i && _arr.length === i) break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) _i["return"]();
+    } finally {
+      if (_d) throw _e;
+    }
+  }
+
+  return _arr;
+}
+
+module.exports = _iterableToArrayLimit;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/iterableToArrayLimitLoose.js b/node_modules/@babel/runtime/helpers/builtin/iterableToArrayLimitLoose.js
new file mode 100644
index 00000000..c7dfeb30
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/iterableToArrayLimitLoose.js
@@ -0,0 +1,13 @@
+function _iterableToArrayLimitLoose(arr, i) {
+  var _arr = [];
+
+  for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) {
+    _arr.push(_step.value);
+
+    if (i && _arr.length === i) break;
+  }
+
+  return _arr;
+}
+
+module.exports = _iterableToArrayLimitLoose;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/jsx.js b/node_modules/@babel/runtime/helpers/builtin/jsx.js
new file mode 100644
index 00000000..db6ffd76
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/jsx.js
@@ -0,0 +1,49 @@
+var REACT_ELEMENT_TYPE;
+
+function _createRawReactElement(type, props, key, children) {
+  if (!REACT_ELEMENT_TYPE) {
+    REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol.for && Symbol.for("react.element") || 0xeac7;
+  }
+
+  var defaultProps = type && type.defaultProps;
+  var childrenLength = arguments.length - 3;
+
+  if (!props && childrenLength !== 0) {
+    props = {
+      children: void 0
+    };
+  }
+
+  if (props && defaultProps) {
+    for (var propName in defaultProps) {
+      if (props[propName] === void 0) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+  } else if (!props) {
+    props = defaultProps || {};
+  }
+
+  if (childrenLength === 1) {
+    props.children = children;
+  } else if (childrenLength > 1) {
+    var childArray = new Array(childrenLength);
+
+    for (var i = 0; i < childrenLength; i++) {
+      childArray[i] = arguments[i + 3];
+    }
+
+    props.children = childArray;
+  }
+
+  return {
+    $$typeof: REACT_ELEMENT_TYPE,
+    type: type,
+    key: key === undefined ? null : '' + key,
+    ref: null,
+    props: props,
+    _owner: null
+  };
+}
+
+module.exports = _createRawReactElement;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/newArrowCheck.js b/node_modules/@babel/runtime/helpers/builtin/newArrowCheck.js
new file mode 100644
index 00000000..9b59f58c
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/newArrowCheck.js
@@ -0,0 +1,7 @@
+function _newArrowCheck(innerThis, boundThis) {
+  if (innerThis !== boundThis) {
+    throw new TypeError("Cannot instantiate an arrow function");
+  }
+}
+
+module.exports = _newArrowCheck;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/nonIterableRest.js b/node_modules/@babel/runtime/helpers/builtin/nonIterableRest.js
new file mode 100644
index 00000000..eb447dd7
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/nonIterableRest.js
@@ -0,0 +1,5 @@
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance");
+}
+
+module.exports = _nonIterableRest;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/nonIterableSpread.js b/node_modules/@babel/runtime/helpers/builtin/nonIterableSpread.js
new file mode 100644
index 00000000..7d7ca436
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/nonIterableSpread.js
@@ -0,0 +1,5 @@
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance");
+}
+
+module.exports = _nonIterableSpread;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/objectDestructuringEmpty.js b/node_modules/@babel/runtime/helpers/builtin/objectDestructuringEmpty.js
new file mode 100644
index 00000000..1d5c04a7
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/objectDestructuringEmpty.js
@@ -0,0 +1,5 @@
+function _objectDestructuringEmpty(obj) {
+  if (obj == null) throw new TypeError("Cannot destructure undefined");
+}
+
+module.exports = _objectDestructuringEmpty;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/objectSpread.js b/node_modules/@babel/runtime/helpers/builtin/objectSpread.js
new file mode 100644
index 00000000..b9234007
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/objectSpread.js
@@ -0,0 +1,22 @@
+var defineProperty = require("./defineProperty");
+
+function _objectSpread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    var ownKeys = Object.keys(source);
+
+    if (typeof Object.getOwnPropertySymbols === 'function') {
+      ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
+        return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+      }));
+    }
+
+    ownKeys.forEach(function (key) {
+      defineProperty(target, key, source[key]);
+    });
+  }
+
+  return target;
+}
+
+module.exports = _objectSpread;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/objectWithoutProperties.js b/node_modules/@babel/runtime/helpers/builtin/objectWithoutProperties.js
new file mode 100644
index 00000000..c7d7351e
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/objectWithoutProperties.js
@@ -0,0 +1,27 @@
+function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+
+  return target;
+}
+
+module.exports = _objectWithoutProperties;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/possibleConstructorReturn.js b/node_modules/@babel/runtime/helpers/builtin/possibleConstructorReturn.js
new file mode 100644
index 00000000..34f92cfd
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/possibleConstructorReturn.js
@@ -0,0 +1,13 @@
+var _typeof = require("../../helpers/builtin/typeof");
+
+var assertThisInitialized = require("./assertThisInitialized");
+
+function _possibleConstructorReturn(self, call) {
+  if (call && (_typeof(call) === "object" || typeof call === "function")) {
+    return call;
+  }
+
+  return assertThisInitialized(self);
+}
+
+module.exports = _possibleConstructorReturn;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/readOnlyError.js b/node_modules/@babel/runtime/helpers/builtin/readOnlyError.js
new file mode 100644
index 00000000..4e61e3fd
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/readOnlyError.js
@@ -0,0 +1,5 @@
+function _readOnlyError(name) {
+  throw new Error("\"" + name + "\" is read-only");
+}
+
+module.exports = _readOnlyError;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/set.js b/node_modules/@babel/runtime/helpers/builtin/set.js
new file mode 100644
index 00000000..aad38c22
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/set.js
@@ -0,0 +1,56 @@
+var getPrototypeOf = require("./getPrototypeOf");
+
+var superPropBase = require("./superPropBase");
+
+var defineProperty = require("./defineProperty");
+
+function set(target, property, value, receiver) {
+  if (typeof Reflect !== "undefined" && Reflect.set) {
+    set = Reflect.set;
+  } else {
+    set = function set(target, property, value, receiver) {
+      var base = superPropBase(target, property);
+      var desc;
+
+      if (base) {
+        desc = Object.getOwnPropertyDescriptor(base, property);
+
+        if (desc.set) {
+          desc.set.call(receiver, value);
+          return true;
+        } else if (!desc.writable) {
+          return false;
+        }
+      }
+
+      desc = Object.getOwnPropertyDescriptor(receiver, property);
+
+      if (desc) {
+        if (!desc.writable) {
+          return false;
+        }
+
+        desc.value = value;
+        Object.defineProperty(receiver, property, desc);
+      } else {
+        defineProperty(receiver, property, value);
+      }
+
+      return true;
+    };
+  }
+
+  return set(target, property, value, receiver);
+}
+
+function _set(target, property, value, receiver, isStrict) {
+  var s = set(target, property, value, receiver || target);
+
+  if (!s && isStrict) {
+    throw new Error('failed to set property');
+  }
+
+  return value;
+}
+
+module.exports = _set;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/setPrototypeOf.js b/node_modules/@babel/runtime/helpers/builtin/setPrototypeOf.js
new file mode 100644
index 00000000..d86e2fc3
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/setPrototypeOf.js
@@ -0,0 +1,10 @@
+function _setPrototypeOf(o, p) {
+  module.exports = _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+
+  return _setPrototypeOf(o, p);
+}
+
+module.exports = _setPrototypeOf;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/skipFirstGeneratorNext.js b/node_modules/@babel/runtime/helpers/builtin/skipFirstGeneratorNext.js
new file mode 100644
index 00000000..e1d6c86b
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/skipFirstGeneratorNext.js
@@ -0,0 +1,9 @@
+function _skipFirstGeneratorNext(fn) {
+  return function () {
+    var it = fn.apply(this, arguments);
+    it.next();
+    return it;
+  };
+}
+
+module.exports = _skipFirstGeneratorNext;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/slicedToArray.js b/node_modules/@babel/runtime/helpers/builtin/slicedToArray.js
new file mode 100644
index 00000000..243ea9e2
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/slicedToArray.js
@@ -0,0 +1,11 @@
+var arrayWithHoles = require("./arrayWithHoles");
+
+var iterableToArrayLimit = require("./iterableToArrayLimit");
+
+var nonIterableRest = require("./nonIterableRest");
+
+function _slicedToArray(arr, i) {
+  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || nonIterableRest();
+}
+
+module.exports = _slicedToArray;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/slicedToArrayLoose.js b/node_modules/@babel/runtime/helpers/builtin/slicedToArrayLoose.js
new file mode 100644
index 00000000..c7e4313b
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/slicedToArrayLoose.js
@@ -0,0 +1,11 @@
+var arrayWithHoles = require("./arrayWithHoles");
+
+var iterableToArrayLimitLoose = require("./iterableToArrayLimitLoose");
+
+var nonIterableRest = require("./nonIterableRest");
+
+function _slicedToArrayLoose(arr, i) {
+  return arrayWithHoles(arr) || iterableToArrayLimitLoose(arr, i) || nonIterableRest();
+}
+
+module.exports = _slicedToArrayLoose;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/superPropBase.js b/node_modules/@babel/runtime/helpers/builtin/superPropBase.js
new file mode 100644
index 00000000..bbb34a2d
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/superPropBase.js
@@ -0,0 +1,12 @@
+var getPrototypeOf = require("./getPrototypeOf");
+
+function _superPropBase(object, property) {
+  while (!Object.prototype.hasOwnProperty.call(object, property)) {
+    object = getPrototypeOf(object);
+    if (object === null) break;
+  }
+
+  return object;
+}
+
+module.exports = _superPropBase;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/taggedTemplateLiteral.js b/node_modules/@babel/runtime/helpers/builtin/taggedTemplateLiteral.js
new file mode 100644
index 00000000..bdcc1e9d
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/taggedTemplateLiteral.js
@@ -0,0 +1,13 @@
+function _taggedTemplateLiteral(strings, raw) {
+  if (!raw) {
+    raw = strings.slice(0);
+  }
+
+  return Object.freeze(Object.defineProperties(strings, {
+    raw: {
+      value: Object.freeze(raw)
+    }
+  }));
+}
+
+module.exports = _taggedTemplateLiteral;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/taggedTemplateLiteralLoose.js b/node_modules/@babel/runtime/helpers/builtin/taggedTemplateLiteralLoose.js
new file mode 100644
index 00000000..beced541
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/taggedTemplateLiteralLoose.js
@@ -0,0 +1,10 @@
+function _taggedTemplateLiteralLoose(strings, raw) {
+  if (!raw) {
+    raw = strings.slice(0);
+  }
+
+  strings.raw = raw;
+  return strings;
+}
+
+module.exports = _taggedTemplateLiteralLoose;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/temporalRef.js b/node_modules/@babel/runtime/helpers/builtin/temporalRef.js
new file mode 100644
index 00000000..20b2652a
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/temporalRef.js
@@ -0,0 +1,11 @@
+var temporalUndefined = require("./temporalUndefined");
+
+function _temporalRef(val, name) {
+  if (val === temporalUndefined) {
+    throw new ReferenceError(name + " is not defined - temporal dead zone");
+  } else {
+    return val;
+  }
+}
+
+module.exports = _temporalRef;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/temporalUndefined.js b/node_modules/@babel/runtime/helpers/builtin/temporalUndefined.js
new file mode 100644
index 00000000..a0995453
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/temporalUndefined.js
@@ -0,0 +1 @@
+module.exports = {};
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/toArray.js b/node_modules/@babel/runtime/helpers/builtin/toArray.js
new file mode 100644
index 00000000..c28fd9e4
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/toArray.js
@@ -0,0 +1,11 @@
+var arrayWithHoles = require("./arrayWithHoles");
+
+var iterableToArray = require("./iterableToArray");
+
+var nonIterableRest = require("./nonIterableRest");
+
+function _toArray(arr) {
+  return arrayWithHoles(arr) || iterableToArray(arr) || nonIterableRest();
+}
+
+module.exports = _toArray;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/toConsumableArray.js b/node_modules/@babel/runtime/helpers/builtin/toConsumableArray.js
new file mode 100644
index 00000000..4cd54a33
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/toConsumableArray.js
@@ -0,0 +1,11 @@
+var arrayWithoutHoles = require("./arrayWithoutHoles");
+
+var iterableToArray = require("./iterableToArray");
+
+var nonIterableSpread = require("./nonIterableSpread");
+
+function _toConsumableArray(arr) {
+  return arrayWithoutHoles(arr) || iterableToArray(arr) || nonIterableSpread();
+}
+
+module.exports = _toConsumableArray;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/toPropertyKey.js b/node_modules/@babel/runtime/helpers/builtin/toPropertyKey.js
new file mode 100644
index 00000000..7c5294c2
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/toPropertyKey.js
@@ -0,0 +1,11 @@
+var _typeof = require("../../helpers/builtin/typeof");
+
+function _toPropertyKey(key) {
+  if (_typeof(key) === "symbol") {
+    return key;
+  } else {
+    return String(key);
+  }
+}
+
+module.exports = _toPropertyKey;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/typeof.js b/node_modules/@babel/runtime/helpers/builtin/typeof.js
new file mode 100644
index 00000000..fd7d3edf
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/typeof.js
@@ -0,0 +1,17 @@
+function _typeof2(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof2 = function _typeof2(obj) { return typeof obj; }; } else { _typeof2 = function _typeof2(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof2(obj); }
+
+function _typeof(obj) {
+  if (typeof Symbol === "function" && _typeof2(Symbol.iterator) === "symbol") {
+    module.exports = _typeof = function _typeof(obj) {
+      return _typeof2(obj);
+    };
+  } else {
+    module.exports = _typeof = function _typeof(obj) {
+      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : _typeof2(obj);
+    };
+  }
+
+  return _typeof(obj);
+}
+
+module.exports = _typeof;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/wrapAsyncGenerator.js b/node_modules/@babel/runtime/helpers/builtin/wrapAsyncGenerator.js
new file mode 100644
index 00000000..11554f3d
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/wrapAsyncGenerator.js
@@ -0,0 +1,9 @@
+var AsyncGenerator = require("./AsyncGenerator");
+
+function _wrapAsyncGenerator(fn) {
+  return function () {
+    return new AsyncGenerator(fn.apply(this, arguments));
+  };
+}
+
+module.exports = _wrapAsyncGenerator;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/builtin/wrapNativeSuper.js b/node_modules/@babel/runtime/helpers/builtin/wrapNativeSuper.js
new file mode 100644
index 00000000..3c2fc5ed
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/builtin/wrapNativeSuper.js
@@ -0,0 +1,39 @@
+var getPrototypeOf = require("./getPrototypeOf");
+
+var setPrototypeOf = require("./setPrototypeOf");
+
+var construct = require("./construct");
+
+function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? new Map() : undefined;
+
+  module.exports = _wrapNativeSuper = function _wrapNativeSuper(Class) {
+    if (typeof Class !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class)) return _cache.get(Class);
+
+      _cache.set(Class, Wrapper);
+    }
+
+    function Wrapper() {}
+
+    Wrapper.prototype = Object.create(Class.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return setPrototypeOf(Wrapper, setPrototypeOf(function Super() {
+      return construct(Class, arguments, getPrototypeOf(this).constructor);
+    }, Class));
+  };
+
+  return _wrapNativeSuper(Class);
+}
+
+module.exports = _wrapNativeSuper;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/classCallCheck.js b/node_modules/@babel/runtime/helpers/classCallCheck.js
new file mode 100644
index 00000000..f389f2e8
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/classCallCheck.js
@@ -0,0 +1,7 @@
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+
+module.exports = _classCallCheck;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/classNameTDZError.js b/node_modules/@babel/runtime/helpers/classNameTDZError.js
new file mode 100644
index 00000000..8c1bdf55
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/classNameTDZError.js
@@ -0,0 +1,5 @@
+function _classNameTDZError(name) {
+  throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys.");
+}
+
+module.exports = _classNameTDZError;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/construct.js b/node_modules/@babel/runtime/helpers/construct.js
new file mode 100644
index 00000000..c20f569f
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/construct.js
@@ -0,0 +1,22 @@
+var _Reflect$construct = require("../core-js/reflect/construct");
+
+var setPrototypeOf = require("./setPrototypeOf");
+
+function _construct(Parent, args, Class) {
+  if (typeof Reflect !== "undefined" && _Reflect$construct) {
+    module.exports = _construct = _Reflect$construct;
+  } else {
+    module.exports = _construct = function _construct(Parent, args, Class) {
+      var a = [null];
+      a.push.apply(a, args);
+      var Constructor = Parent.bind.apply(Parent, a);
+      var instance = new Constructor();
+      if (Class) setPrototypeOf(instance, Class.prototype);
+      return instance;
+    };
+  }
+
+  return _construct.apply(null, arguments);
+}
+
+module.exports = _construct;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/createClass.js b/node_modules/@babel/runtime/helpers/createClass.js
new file mode 100644
index 00000000..c04c910e
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/createClass.js
@@ -0,0 +1,20 @@
+var _Object$defineProperty = require("../core-js/object/define-property");
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+
+    _Object$defineProperty(target, descriptor.key, descriptor);
+  }
+}
+
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+
+module.exports = _createClass;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/defaults.js b/node_modules/@babel/runtime/helpers/defaults.js
new file mode 100644
index 00000000..77c4b85a
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/defaults.js
@@ -0,0 +1,23 @@
+var _Object$defineProperty = require("../core-js/object/define-property");
+
+var _Object$getOwnPropertyDescriptor = require("../core-js/object/get-own-property-descriptor");
+
+var _Object$getOwnPropertyNames = require("../core-js/object/get-own-property-names");
+
+function _defaults(obj, defaults) {
+  var keys = _Object$getOwnPropertyNames(defaults);
+
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+
+    var value = _Object$getOwnPropertyDescriptor(defaults, key);
+
+    if (value && value.configurable && obj[key] === undefined) {
+      _Object$defineProperty(obj, key, value);
+    }
+  }
+
+  return obj;
+}
+
+module.exports = _defaults;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/defineEnumerableProperties.js b/node_modules/@babel/runtime/helpers/defineEnumerableProperties.js
new file mode 100644
index 00000000..0ef3a34a
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/defineEnumerableProperties.js
@@ -0,0 +1,30 @@
+var _Object$getOwnPropertySymbols = require("../core-js/object/get-own-property-symbols");
+
+var _Object$defineProperty = require("../core-js/object/define-property");
+
+function _defineEnumerableProperties(obj, descs) {
+  for (var key in descs) {
+    var desc = descs[key];
+    desc.configurable = desc.enumerable = true;
+    if ("value" in desc) desc.writable = true;
+
+    _Object$defineProperty(obj, key, desc);
+  }
+
+  if (_Object$getOwnPropertySymbols) {
+    var objectSymbols = _Object$getOwnPropertySymbols(descs);
+
+    for (var i = 0; i < objectSymbols.length; i++) {
+      var sym = objectSymbols[i];
+      var desc = descs[sym];
+      desc.configurable = desc.enumerable = true;
+      if ("value" in desc) desc.writable = true;
+
+      _Object$defineProperty(obj, sym, desc);
+    }
+  }
+
+  return obj;
+}
+
+module.exports = _defineEnumerableProperties;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/defineProperty.js b/node_modules/@babel/runtime/helpers/defineProperty.js
new file mode 100644
index 00000000..b08c5e85
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/defineProperty.js
@@ -0,0 +1,18 @@
+var _Object$defineProperty = require("../core-js/object/define-property");
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    _Object$defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+module.exports = _defineProperty;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/AsyncGenerator.js b/node_modules/@babel/runtime/helpers/es6/AsyncGenerator.js
new file mode 100644
index 00000000..05d1b4a0
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/AsyncGenerator.js
@@ -0,0 +1,100 @@
+import _Symbol from "../../core-js/symbol";
+import _Promise from "../../core-js/promise";
+import AwaitValue from "./AwaitValue";
+export default function AsyncGenerator(gen) {
+  var front, back;
+
+  function send(key, arg) {
+    return new _Promise(function (resolve, reject) {
+      var request = {
+        key: key,
+        arg: arg,
+        resolve: resolve,
+        reject: reject,
+        next: null
+      };
+
+      if (back) {
+        back = back.next = request;
+      } else {
+        front = back = request;
+        resume(key, arg);
+      }
+    });
+  }
+
+  function resume(key, arg) {
+    try {
+      var result = gen[key](arg);
+      var value = result.value;
+      var wrappedAwait = value instanceof AwaitValue;
+
+      _Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) {
+        if (wrappedAwait) {
+          resume("next", arg);
+          return;
+        }
+
+        settle(result.done ? "return" : "normal", arg);
+      }, function (err) {
+        resume("throw", err);
+      });
+    } catch (err) {
+      settle("throw", err);
+    }
+  }
+
+  function settle(type, value) {
+    switch (type) {
+      case "return":
+        front.resolve({
+          value: value,
+          done: true
+        });
+        break;
+
+      case "throw":
+        front.reject(value);
+        break;
+
+      default:
+        front.resolve({
+          value: value,
+          done: false
+        });
+        break;
+    }
+
+    front = front.next;
+
+    if (front) {
+      resume(front.key, front.arg);
+    } else {
+      back = null;
+    }
+  }
+
+  this._invoke = send;
+
+  if (typeof gen.return !== "function") {
+    this.return = undefined;
+  }
+}
+
+if (typeof _Symbol === "function" && _Symbol.asyncIterator) {
+  AsyncGenerator.prototype[_Symbol.asyncIterator] = function () {
+    return this;
+  };
+}
+
+AsyncGenerator.prototype.next = function (arg) {
+  return this._invoke("next", arg);
+};
+
+AsyncGenerator.prototype.throw = function (arg) {
+  return this._invoke("throw", arg);
+};
+
+AsyncGenerator.prototype.return = function (arg) {
+  return this._invoke("return", arg);
+};
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/AwaitValue.js b/node_modules/@babel/runtime/helpers/es6/AwaitValue.js
new file mode 100644
index 00000000..5237e18f
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/AwaitValue.js
@@ -0,0 +1,3 @@
+export default function _AwaitValue(value) {
+  this.wrapped = value;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/applyDecoratedDescriptor.js b/node_modules/@babel/runtime/helpers/es6/applyDecoratedDescriptor.js
new file mode 100644
index 00000000..74923717
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/applyDecoratedDescriptor.js
@@ -0,0 +1,28 @@
+export default function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
+  var desc = {};
+  Object['ke' + 'ys'](descriptor).forEach(function (key) {
+    desc[key] = descriptor[key];
+  });
+  desc.enumerable = !!desc.enumerable;
+  desc.configurable = !!desc.configurable;
+
+  if ('value' in desc || desc.initializer) {
+    desc.writable = true;
+  }
+
+  desc = decorators.slice().reverse().reduce(function (desc, decorator) {
+    return decorator(target, property, desc) || desc;
+  }, desc);
+
+  if (context && desc.initializer !== void 0) {
+    desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
+    desc.initializer = undefined;
+  }
+
+  if (desc.initializer === void 0) {
+    Object['define' + 'Property'](target, property, desc);
+    desc = null;
+  }
+
+  return desc;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/arrayWithHoles.js b/node_modules/@babel/runtime/helpers/es6/arrayWithHoles.js
new file mode 100644
index 00000000..be734fc3
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/arrayWithHoles.js
@@ -0,0 +1,3 @@
+export default function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/arrayWithoutHoles.js b/node_modules/@babel/runtime/helpers/es6/arrayWithoutHoles.js
new file mode 100644
index 00000000..cbcffa15
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/arrayWithoutHoles.js
@@ -0,0 +1,9 @@
+export default function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) {
+    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
+      arr2[i] = arr[i];
+    }
+
+    return arr2;
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/assertThisInitialized.js b/node_modules/@babel/runtime/helpers/es6/assertThisInitialized.js
new file mode 100644
index 00000000..bbf849ca
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/assertThisInitialized.js
@@ -0,0 +1,7 @@
+export default function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/asyncGeneratorDelegate.js b/node_modules/@babel/runtime/helpers/es6/asyncGeneratorDelegate.js
new file mode 100644
index 00000000..26bd91fd
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/asyncGeneratorDelegate.js
@@ -0,0 +1,54 @@
+import _Symbol$iterator from "../../core-js/symbol/iterator";
+import _Symbol from "../../core-js/symbol";
+import _Promise from "../../core-js/promise";
+export default function _asyncGeneratorDelegate(inner, awaitWrap) {
+  var iter = {},
+      waiting = false;
+
+  function pump(key, value) {
+    waiting = true;
+    value = new _Promise(function (resolve) {
+      resolve(inner[key](value));
+    });
+    return {
+      done: false,
+      value: awaitWrap(value)
+    };
+  }
+
+  ;
+
+  if (typeof _Symbol === "function" && _Symbol$iterator) {
+    iter[_Symbol$iterator] = function () {
+      return this;
+    };
+  }
+
+  iter.next = function (value) {
+    if (waiting) {
+      waiting = false;
+      return value;
+    }
+
+    return pump("next", value);
+  };
+
+  if (typeof inner.throw === "function") {
+    iter.throw = function (value) {
+      if (waiting) {
+        waiting = false;
+        throw value;
+      }
+
+      return pump("throw", value);
+    };
+  }
+
+  if (typeof inner.return === "function") {
+    iter.return = function (value) {
+      return pump("return", value);
+    };
+  }
+
+  return iter;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/asyncIterator.js b/node_modules/@babel/runtime/helpers/es6/asyncIterator.js
new file mode 100644
index 00000000..f07cc5aa
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/asyncIterator.js
@@ -0,0 +1,19 @@
+import _Symbol$iterator from "../../core-js/symbol/iterator";
+import _Symbol from "../../core-js/symbol";
+export default function _asyncIterator(iterable) {
+  var method;
+
+  if (typeof _Symbol === "function") {
+    if (_Symbol.asyncIterator) {
+      method = iterable[_Symbol.asyncIterator];
+      if (method != null) return method.call(iterable);
+    }
+
+    if (_Symbol$iterator) {
+      method = iterable[_Symbol$iterator];
+      if (method != null) return method.call(iterable);
+    }
+  }
+
+  throw new TypeError("Object is not async iterable");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/asyncToGenerator.js b/node_modules/@babel/runtime/helpers/es6/asyncToGenerator.js
new file mode 100644
index 00000000..f77e2727
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/asyncToGenerator.js
@@ -0,0 +1,36 @@
+import _Promise from "../../core-js/promise";
+export default function _asyncToGenerator(fn) {
+  return function () {
+    var self = this,
+        args = arguments;
+    return new _Promise(function (resolve, reject) {
+      var gen = fn.apply(self, args);
+
+      function step(key, arg) {
+        try {
+          var info = gen[key](arg);
+          var value = info.value;
+        } catch (error) {
+          reject(error);
+          return;
+        }
+
+        if (info.done) {
+          resolve(value);
+        } else {
+          _Promise.resolve(value).then(_next, _throw);
+        }
+      }
+
+      function _next(value) {
+        step("next", value);
+      }
+
+      function _throw(err) {
+        step("throw", err);
+      }
+
+      _next();
+    });
+  };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/awaitAsyncGenerator.js b/node_modules/@babel/runtime/helpers/es6/awaitAsyncGenerator.js
new file mode 100644
index 00000000..462f99cd
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/awaitAsyncGenerator.js
@@ -0,0 +1,4 @@
+import AwaitValue from "./AwaitValue";
+export default function _awaitAsyncGenerator(value) {
+  return new AwaitValue(value);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/classCallCheck.js b/node_modules/@babel/runtime/helpers/es6/classCallCheck.js
new file mode 100644
index 00000000..2f1738a3
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/classCallCheck.js
@@ -0,0 +1,5 @@
+export default function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/classNameTDZError.js b/node_modules/@babel/runtime/helpers/es6/classNameTDZError.js
new file mode 100644
index 00000000..f7b6dd57
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/classNameTDZError.js
@@ -0,0 +1,3 @@
+export default function _classNameTDZError(name) {
+  throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys.");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/construct.js b/node_modules/@babel/runtime/helpers/es6/construct.js
new file mode 100644
index 00000000..6abef26c
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/construct.js
@@ -0,0 +1,18 @@
+import _Reflect$construct from "../../core-js/reflect/construct";
+import setPrototypeOf from "./setPrototypeOf";
+export default function _construct(Parent, args, Class) {
+  if (typeof Reflect !== "undefined" && _Reflect$construct) {
+    _construct = _Reflect$construct;
+  } else {
+    _construct = function _construct(Parent, args, Class) {
+      var a = [null];
+      a.push.apply(a, args);
+      var Constructor = Parent.bind.apply(Parent, a);
+      var instance = new Constructor();
+      if (Class) setPrototypeOf(instance, Class.prototype);
+      return instance;
+    };
+  }
+
+  return _construct.apply(null, arguments);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/createClass.js b/node_modules/@babel/runtime/helpers/es6/createClass.js
new file mode 100644
index 00000000..8a6ab384
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/createClass.js
@@ -0,0 +1,18 @@
+import _Object$defineProperty from "../../core-js/object/define-property";
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+
+    _Object$defineProperty(target, descriptor.key, descriptor);
+  }
+}
+
+export default function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/defaults.js b/node_modules/@babel/runtime/helpers/es6/defaults.js
new file mode 100644
index 00000000..8f7670af
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/defaults.js
@@ -0,0 +1,18 @@
+import _Object$defineProperty from "../../core-js/object/define-property";
+import _Object$getOwnPropertyDescriptor from "../../core-js/object/get-own-property-descriptor";
+import _Object$getOwnPropertyNames from "../../core-js/object/get-own-property-names";
+export default function _defaults(obj, defaults) {
+  var keys = _Object$getOwnPropertyNames(defaults);
+
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+
+    var value = _Object$getOwnPropertyDescriptor(defaults, key);
+
+    if (value && value.configurable && obj[key] === undefined) {
+      _Object$defineProperty(obj, key, value);
+    }
+  }
+
+  return obj;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/defineEnumerableProperties.js b/node_modules/@babel/runtime/helpers/es6/defineEnumerableProperties.js
new file mode 100644
index 00000000..5c19c68a
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/defineEnumerableProperties.js
@@ -0,0 +1,26 @@
+import _Object$getOwnPropertySymbols from "../../core-js/object/get-own-property-symbols";
+import _Object$defineProperty from "../../core-js/object/define-property";
+export default function _defineEnumerableProperties(obj, descs) {
+  for (var key in descs) {
+    var desc = descs[key];
+    desc.configurable = desc.enumerable = true;
+    if ("value" in desc) desc.writable = true;
+
+    _Object$defineProperty(obj, key, desc);
+  }
+
+  if (_Object$getOwnPropertySymbols) {
+    var objectSymbols = _Object$getOwnPropertySymbols(descs);
+
+    for (var i = 0; i < objectSymbols.length; i++) {
+      var sym = objectSymbols[i];
+      var desc = descs[sym];
+      desc.configurable = desc.enumerable = true;
+      if ("value" in desc) desc.writable = true;
+
+      _Object$defineProperty(obj, sym, desc);
+    }
+  }
+
+  return obj;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/defineProperty.js b/node_modules/@babel/runtime/helpers/es6/defineProperty.js
new file mode 100644
index 00000000..54752abf
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/defineProperty.js
@@ -0,0 +1,15 @@
+import _Object$defineProperty from "../../core-js/object/define-property";
+export default function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    _Object$defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/extends.js b/node_modules/@babel/runtime/helpers/es6/extends.js
new file mode 100644
index 00000000..ed3c050e
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/extends.js
@@ -0,0 +1,18 @@
+import _Object$assign from "../../core-js/object/assign";
+export default function _extends() {
+  _extends = _Object$assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/get.js b/node_modules/@babel/runtime/helpers/es6/get.js
new file mode 100644
index 00000000..9a0fd944
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/get.js
@@ -0,0 +1,24 @@
+import _Object$getOwnPropertyDescriptor from "../../core-js/object/get-own-property-descriptor";
+import _Reflect$get from "../../core-js/reflect/get";
+import getPrototypeOf from "./getPrototypeOf";
+import superPropBase from "./superPropBase";
+export default function _get(target, property, receiver) {
+  if (typeof Reflect !== "undefined" && _Reflect$get) {
+    _get = _Reflect$get;
+  } else {
+    _get = function _get(target, property, receiver) {
+      var base = superPropBase(target, property);
+      if (!base) return;
+
+      var desc = _Object$getOwnPropertyDescriptor(base, property);
+
+      if (desc.get) {
+        return desc.get.call(receiver);
+      }
+
+      return desc.value;
+    };
+  }
+
+  return _get(target, property, receiver || target);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/getPrototypeOf.js b/node_modules/@babel/runtime/helpers/es6/getPrototypeOf.js
new file mode 100644
index 00000000..44a73cb8
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/getPrototypeOf.js
@@ -0,0 +1,8 @@
+import _Object$getPrototypeOf from "../../core-js/object/get-prototype-of";
+export default function _getPrototypeOf(o) {
+  _getPrototypeOf = _Object$getPrototypeOf || function _getPrototypeOf(o) {
+    return o.__proto__;
+  };
+
+  return _getPrototypeOf(o);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/inherits.js b/node_modules/@babel/runtime/helpers/es6/inherits.js
new file mode 100644
index 00000000..a1024204
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/inherits.js
@@ -0,0 +1,9 @@
+import setPrototypeOf from "./setPrototypeOf";
+export default function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+
+  setPrototypeOf(subClass.prototype, superClass && superClass.prototype);
+  if (superClass) setPrototypeOf(subClass, superClass);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/inheritsLoose.js b/node_modules/@babel/runtime/helpers/es6/inheritsLoose.js
new file mode 100644
index 00000000..713d72c1
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/inheritsLoose.js
@@ -0,0 +1,4 @@
+export default function _inheritsLoose(subClass, superClass) {
+  subClass.prototype.__proto__ = superClass && superClass.prototype;
+  subClass.__proto__ = superClass;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/initializerDefineProperty.js b/node_modules/@babel/runtime/helpers/es6/initializerDefineProperty.js
new file mode 100644
index 00000000..d43d6a47
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/initializerDefineProperty.js
@@ -0,0 +1,11 @@
+import _Object$defineProperty from "../../core-js/object/define-property";
+export default function _initializerDefineProperty(target, property, descriptor, context) {
+  if (!descriptor) return;
+
+  _Object$defineProperty(target, property, {
+    enumerable: descriptor.enumerable,
+    configurable: descriptor.configurable,
+    writable: descriptor.writable,
+    value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
+  });
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/initializerWarningHelper.js b/node_modules/@babel/runtime/helpers/es6/initializerWarningHelper.js
new file mode 100644
index 00000000..d40ca01c
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/initializerWarningHelper.js
@@ -0,0 +1,3 @@
+export default function _initializerWarningHelper(descriptor, context) {
+  throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and set to use loose mode. ' + 'To use proposal-class-properties in spec mode with decorators, wait for ' + 'the next major version of decorators in stage 2.');
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/instanceof.js b/node_modules/@babel/runtime/helpers/es6/instanceof.js
new file mode 100644
index 00000000..8f3e8b32
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/instanceof.js
@@ -0,0 +1,9 @@
+import _Symbol$hasInstance from "../../core-js/symbol/has-instance";
+import _Symbol from "../../core-js/symbol";
+export default function _instanceof(left, right) {
+  if (right != null && typeof _Symbol !== "undefined" && right[_Symbol$hasInstance]) {
+    return right[_Symbol$hasInstance](left);
+  } else {
+    return left instanceof right;
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/interopRequireDefault.js b/node_modules/@babel/runtime/helpers/es6/interopRequireDefault.js
new file mode 100644
index 00000000..dd5e7815
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/interopRequireDefault.js
@@ -0,0 +1,5 @@
+export default function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/interopRequireWildcard.js b/node_modules/@babel/runtime/helpers/es6/interopRequireWildcard.js
new file mode 100644
index 00000000..c581eb58
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/interopRequireWildcard.js
@@ -0,0 +1,26 @@
+import _Object$getOwnPropertyDescriptor from "../../core-js/object/get-own-property-descriptor";
+import _Object$defineProperty from "../../core-js/object/define-property";
+export default function _interopRequireWildcard(obj) {
+  if (obj && obj.__esModule) {
+    return obj;
+  } else {
+    var newObj = {};
+
+    if (obj != null) {
+      for (var key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+          var desc = _Object$defineProperty && _Object$getOwnPropertyDescriptor ? _Object$getOwnPropertyDescriptor(obj, key) : {};
+
+          if (desc.get || desc.set) {
+            _Object$defineProperty(newObj, key, desc);
+          } else {
+            newObj[key] = obj[key];
+          }
+        }
+      }
+    }
+
+    newObj.default = obj;
+    return newObj;
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/iterableToArray.js b/node_modules/@babel/runtime/helpers/es6/iterableToArray.js
new file mode 100644
index 00000000..9f20ecdb
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/iterableToArray.js
@@ -0,0 +1,5 @@
+import _Array$from from "../../core-js/array/from";
+import _isIterable from "../../core-js/is-iterable";
+export default function _iterableToArray(iter) {
+  if (_isIterable(Object(iter)) || Object.prototype.toString.call(iter) === "[object Arguments]") return _Array$from(iter);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/iterableToArrayLimit.js b/node_modules/@babel/runtime/helpers/es6/iterableToArrayLimit.js
new file mode 100644
index 00000000..3dc81f96
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/iterableToArrayLimit.js
@@ -0,0 +1,26 @@
+import _getIterator from "../../core-js/get-iterator";
+export default function _iterableToArrayLimit(arr, i) {
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+  var _e = undefined;
+
+  try {
+    for (var _i = _getIterator(arr), _s; !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+
+      if (i && _arr.length === i) break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) _i["return"]();
+    } finally {
+      if (_d) throw _e;
+    }
+  }
+
+  return _arr;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/iterableToArrayLimitLoose.js b/node_modules/@babel/runtime/helpers/es6/iterableToArrayLimitLoose.js
new file mode 100644
index 00000000..1bad9ef9
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/iterableToArrayLimitLoose.js
@@ -0,0 +1,12 @@
+import _getIterator from "../../core-js/get-iterator";
+export default function _iterableToArrayLimitLoose(arr, i) {
+  var _arr = [];
+
+  for (var _iterator = _getIterator(arr), _step; !(_step = _iterator.next()).done;) {
+    _arr.push(_step.value);
+
+    if (i && _arr.length === i) break;
+  }
+
+  return _arr;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/jsx.js b/node_modules/@babel/runtime/helpers/es6/jsx.js
new file mode 100644
index 00000000..f094165b
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/jsx.js
@@ -0,0 +1,48 @@
+import _Symbol$for from "../../core-js/symbol/for";
+import _Symbol from "../../core-js/symbol";
+var REACT_ELEMENT_TYPE;
+export default function _createRawReactElement(type, props, key, children) {
+  if (!REACT_ELEMENT_TYPE) {
+    REACT_ELEMENT_TYPE = typeof _Symbol === "function" && _Symbol$for && _Symbol$for("react.element") || 0xeac7;
+  }
+
+  var defaultProps = type && type.defaultProps;
+  var childrenLength = arguments.length - 3;
+
+  if (!props && childrenLength !== 0) {
+    props = {
+      children: void 0
+    };
+  }
+
+  if (props && defaultProps) {
+    for (var propName in defaultProps) {
+      if (props[propName] === void 0) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+  } else if (!props) {
+    props = defaultProps || {};
+  }
+
+  if (childrenLength === 1) {
+    props.children = children;
+  } else if (childrenLength > 1) {
+    var childArray = new Array(childrenLength);
+
+    for (var i = 0; i < childrenLength; i++) {
+      childArray[i] = arguments[i + 3];
+    }
+
+    props.children = childArray;
+  }
+
+  return {
+    $$typeof: REACT_ELEMENT_TYPE,
+    type: type,
+    key: key === undefined ? null : '' + key,
+    ref: null,
+    props: props,
+    _owner: null
+  };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/newArrowCheck.js b/node_modules/@babel/runtime/helpers/es6/newArrowCheck.js
new file mode 100644
index 00000000..d6cd8643
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/newArrowCheck.js
@@ -0,0 +1,5 @@
+export default function _newArrowCheck(innerThis, boundThis) {
+  if (innerThis !== boundThis) {
+    throw new TypeError("Cannot instantiate an arrow function");
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/nonIterableRest.js b/node_modules/@babel/runtime/helpers/es6/nonIterableRest.js
new file mode 100644
index 00000000..f94186da
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/nonIterableRest.js
@@ -0,0 +1,3 @@
+export default function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/nonIterableSpread.js b/node_modules/@babel/runtime/helpers/es6/nonIterableSpread.js
new file mode 100644
index 00000000..d6bc738a
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/nonIterableSpread.js
@@ -0,0 +1,3 @@
+export default function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/objectDestructuringEmpty.js b/node_modules/@babel/runtime/helpers/es6/objectDestructuringEmpty.js
new file mode 100644
index 00000000..82b67d2c
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/objectDestructuringEmpty.js
@@ -0,0 +1,3 @@
+export default function _objectDestructuringEmpty(obj) {
+  if (obj == null) throw new TypeError("Cannot destructure undefined");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/objectSpread.js b/node_modules/@babel/runtime/helpers/es6/objectSpread.js
new file mode 100644
index 00000000..ac5a3830
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/objectSpread.js
@@ -0,0 +1,23 @@
+import _Object$getOwnPropertyDescriptor from "../../core-js/object/get-own-property-descriptor";
+import _Object$getOwnPropertySymbols from "../../core-js/object/get-own-property-symbols";
+import _Object$keys from "../../core-js/object/keys";
+import defineProperty from "./defineProperty";
+export default function _objectSpread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+
+    var ownKeys = _Object$keys(source);
+
+    if (typeof _Object$getOwnPropertySymbols === 'function') {
+      ownKeys = ownKeys.concat(_Object$getOwnPropertySymbols(source).filter(function (sym) {
+        return _Object$getOwnPropertyDescriptor(source, sym).enumerable;
+      }));
+    }
+
+    ownKeys.forEach(function (key) {
+      defineProperty(target, key, source[key]);
+    });
+  }
+
+  return target;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/objectWithoutProperties.js b/node_modules/@babel/runtime/helpers/es6/objectWithoutProperties.js
new file mode 100644
index 00000000..c13525e8
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/objectWithoutProperties.js
@@ -0,0 +1,29 @@
+import _Object$getOwnPropertySymbols from "../../core-js/object/get-own-property-symbols";
+import _Object$keys from "../../core-js/object/keys";
+export default function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+
+  var sourceKeys = _Object$keys(source);
+
+  var key, i;
+
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+
+  if (_Object$getOwnPropertySymbols) {
+    var sourceSymbolKeys = _Object$getOwnPropertySymbols(source);
+
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+
+  return target;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/possibleConstructorReturn.js b/node_modules/@babel/runtime/helpers/es6/possibleConstructorReturn.js
new file mode 100644
index 00000000..2b99c318
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/possibleConstructorReturn.js
@@ -0,0 +1,9 @@
+import _typeof from "../../helpers/es6/typeof";
+import assertThisInitialized from "./assertThisInitialized";
+export default function _possibleConstructorReturn(self, call) {
+  if (call && (_typeof(call) === "object" || typeof call === "function")) {
+    return call;
+  }
+
+  return assertThisInitialized(self);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/readOnlyError.js b/node_modules/@babel/runtime/helpers/es6/readOnlyError.js
new file mode 100644
index 00000000..45d01d72
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/readOnlyError.js
@@ -0,0 +1,3 @@
+export default function _readOnlyError(name) {
+  throw new Error("\"" + name + "\" is read-only");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/set.js b/node_modules/@babel/runtime/helpers/es6/set.js
new file mode 100644
index 00000000..a26d2a5e
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/set.js
@@ -0,0 +1,56 @@
+import _Object$defineProperty from "../../core-js/object/define-property";
+import _Object$getOwnPropertyDescriptor from "../../core-js/object/get-own-property-descriptor";
+import _Reflect$set from "../../core-js/reflect/set";
+import getPrototypeOf from "./getPrototypeOf";
+import superPropBase from "./superPropBase";
+import defineProperty from "./defineProperty";
+
+function set(target, property, value, receiver) {
+  if (typeof Reflect !== "undefined" && _Reflect$set) {
+    set = _Reflect$set;
+  } else {
+    set = function set(target, property, value, receiver) {
+      var base = superPropBase(target, property);
+      var desc;
+
+      if (base) {
+        desc = _Object$getOwnPropertyDescriptor(base, property);
+
+        if (desc.set) {
+          desc.set.call(receiver, value);
+          return true;
+        } else if (!desc.writable) {
+          return false;
+        }
+      }
+
+      desc = _Object$getOwnPropertyDescriptor(receiver, property);
+
+      if (desc) {
+        if (!desc.writable) {
+          return false;
+        }
+
+        desc.value = value;
+
+        _Object$defineProperty(receiver, property, desc);
+      } else {
+        defineProperty(receiver, property, value);
+      }
+
+      return true;
+    };
+  }
+
+  return set(target, property, value, receiver);
+}
+
+export default function _set(target, property, value, receiver, isStrict) {
+  var s = set(target, property, value, receiver || target);
+
+  if (!s && isStrict) {
+    throw new Error('failed to set property');
+  }
+
+  return value;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/setPrototypeOf.js b/node_modules/@babel/runtime/helpers/es6/setPrototypeOf.js
new file mode 100644
index 00000000..56682d52
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/setPrototypeOf.js
@@ -0,0 +1,9 @@
+import _Object$setPrototypeOf from "../../core-js/object/set-prototype-of";
+export default function _setPrototypeOf(o, p) {
+  _setPrototypeOf = _Object$setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+
+  return _setPrototypeOf(o, p);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/skipFirstGeneratorNext.js b/node_modules/@babel/runtime/helpers/es6/skipFirstGeneratorNext.js
new file mode 100644
index 00000000..cadd9bb5
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/skipFirstGeneratorNext.js
@@ -0,0 +1,7 @@
+export default function _skipFirstGeneratorNext(fn) {
+  return function () {
+    var it = fn.apply(this, arguments);
+    it.next();
+    return it;
+  };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/slicedToArray.js b/node_modules/@babel/runtime/helpers/es6/slicedToArray.js
new file mode 100644
index 00000000..f6f10816
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/slicedToArray.js
@@ -0,0 +1,6 @@
+import arrayWithHoles from "./arrayWithHoles";
+import iterableToArrayLimit from "./iterableToArrayLimit";
+import nonIterableRest from "./nonIterableRest";
+export default function _slicedToArray(arr, i) {
+  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || nonIterableRest();
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/slicedToArrayLoose.js b/node_modules/@babel/runtime/helpers/es6/slicedToArrayLoose.js
new file mode 100644
index 00000000..e6757890
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/slicedToArrayLoose.js
@@ -0,0 +1,6 @@
+import arrayWithHoles from "./arrayWithHoles";
+import iterableToArrayLimitLoose from "./iterableToArrayLimitLoose";
+import nonIterableRest from "./nonIterableRest";
+export default function _slicedToArrayLoose(arr, i) {
+  return arrayWithHoles(arr) || iterableToArrayLimitLoose(arr, i) || nonIterableRest();
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/superPropBase.js b/node_modules/@babel/runtime/helpers/es6/superPropBase.js
new file mode 100644
index 00000000..eace947c
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/superPropBase.js
@@ -0,0 +1,9 @@
+import getPrototypeOf from "./getPrototypeOf";
+export default function _superPropBase(object, property) {
+  while (!Object.prototype.hasOwnProperty.call(object, property)) {
+    object = getPrototypeOf(object);
+    if (object === null) break;
+  }
+
+  return object;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/taggedTemplateLiteral.js b/node_modules/@babel/runtime/helpers/es6/taggedTemplateLiteral.js
new file mode 100644
index 00000000..edc7b127
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/taggedTemplateLiteral.js
@@ -0,0 +1,13 @@
+import _Object$defineProperties from "../../core-js/object/define-properties";
+import _Object$freeze from "../../core-js/object/freeze";
+export default function _taggedTemplateLiteral(strings, raw) {
+  if (!raw) {
+    raw = strings.slice(0);
+  }
+
+  return _Object$freeze(_Object$defineProperties(strings, {
+    raw: {
+      value: _Object$freeze(raw)
+    }
+  }));
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/taggedTemplateLiteralLoose.js b/node_modules/@babel/runtime/helpers/es6/taggedTemplateLiteralLoose.js
new file mode 100644
index 00000000..c8f081e9
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/taggedTemplateLiteralLoose.js
@@ -0,0 +1,8 @@
+export default function _taggedTemplateLiteralLoose(strings, raw) {
+  if (!raw) {
+    raw = strings.slice(0);
+  }
+
+  strings.raw = raw;
+  return strings;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/temporalRef.js b/node_modules/@babel/runtime/helpers/es6/temporalRef.js
new file mode 100644
index 00000000..4b0679c6
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/temporalRef.js
@@ -0,0 +1,8 @@
+import undef from "./temporalUndefined";
+export default function _temporalRef(val, name) {
+  if (val === undef) {
+    throw new ReferenceError(name + " is not defined - temporal dead zone");
+  } else {
+    return val;
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/temporalUndefined.js b/node_modules/@babel/runtime/helpers/es6/temporalUndefined.js
new file mode 100644
index 00000000..7c645e42
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/temporalUndefined.js
@@ -0,0 +1 @@
+export default {};
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/toArray.js b/node_modules/@babel/runtime/helpers/es6/toArray.js
new file mode 100644
index 00000000..5acb22b3
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/toArray.js
@@ -0,0 +1,6 @@
+import arrayWithHoles from "./arrayWithHoles";
+import iterableToArray from "./iterableToArray";
+import nonIterableRest from "./nonIterableRest";
+export default function _toArray(arr) {
+  return arrayWithHoles(arr) || iterableToArray(arr) || nonIterableRest();
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/toConsumableArray.js b/node_modules/@babel/runtime/helpers/es6/toConsumableArray.js
new file mode 100644
index 00000000..7e480b9d
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/toConsumableArray.js
@@ -0,0 +1,6 @@
+import arrayWithoutHoles from "./arrayWithoutHoles";
+import iterableToArray from "./iterableToArray";
+import nonIterableSpread from "./nonIterableSpread";
+export default function _toConsumableArray(arr) {
+  return arrayWithoutHoles(arr) || iterableToArray(arr) || nonIterableSpread();
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/toPropertyKey.js b/node_modules/@babel/runtime/helpers/es6/toPropertyKey.js
new file mode 100644
index 00000000..e0948f85
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/toPropertyKey.js
@@ -0,0 +1,8 @@
+import _typeof from "../../helpers/es6/typeof";
+export default function _toPropertyKey(key) {
+  if (_typeof(key) === "symbol") {
+    return key;
+  } else {
+    return String(key);
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/typeof.js b/node_modules/@babel/runtime/helpers/es6/typeof.js
new file mode 100644
index 00000000..c2c2f83b
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/typeof.js
@@ -0,0 +1,18 @@
+import _Symbol$iterator from "../../core-js/symbol/iterator";
+import _Symbol from "../../core-js/symbol";
+
+function _typeof2(obj) { if (typeof _Symbol === "function" && typeof _Symbol$iterator === "symbol") { _typeof2 = function _typeof2(obj) { return typeof obj; }; } else { _typeof2 = function _typeof2(obj) { return obj && typeof _Symbol === "function" && obj.constructor === _Symbol && obj !== _Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof2(obj); }
+
+export default function _typeof(obj) {
+  if (typeof _Symbol === "function" && _typeof2(_Symbol$iterator) === "symbol") {
+    _typeof = function _typeof(obj) {
+      return _typeof2(obj);
+    };
+  } else {
+    _typeof = function _typeof(obj) {
+      return obj && typeof _Symbol === "function" && obj.constructor === _Symbol && obj !== _Symbol.prototype ? "symbol" : _typeof2(obj);
+    };
+  }
+
+  return _typeof(obj);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/wrapAsyncGenerator.js b/node_modules/@babel/runtime/helpers/es6/wrapAsyncGenerator.js
new file mode 100644
index 00000000..6d6d9811
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/wrapAsyncGenerator.js
@@ -0,0 +1,6 @@
+import AsyncGenerator from "./AsyncGenerator";
+export default function _wrapAsyncGenerator(fn) {
+  return function () {
+    return new AsyncGenerator(fn.apply(this, arguments));
+  };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/es6/wrapNativeSuper.js b/node_modules/@babel/runtime/helpers/es6/wrapNativeSuper.js
new file mode 100644
index 00000000..1b64b02f
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/es6/wrapNativeSuper.js
@@ -0,0 +1,36 @@
+import _Object$create from "../../core-js/object/create";
+import _Map from "../../core-js/map";
+import _gPO from "./getPrototypeOf";
+import _sPO from "./setPrototypeOf";
+import construct from "./construct";
+export default function _wrapNativeSuper(Class) {
+  var _cache = typeof _Map === "function" ? new _Map() : undefined;
+
+  _wrapNativeSuper = function _wrapNativeSuper(Class) {
+    if (typeof Class !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class)) return _cache.get(Class);
+
+      _cache.set(Class, Wrapper);
+    }
+
+    function Wrapper() {}
+
+    Wrapper.prototype = _Object$create(Class.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _sPO(Wrapper, _sPO(function Super() {
+      return construct(Class, arguments, _gPO(this).constructor);
+    }, Class));
+  };
+
+  return _wrapNativeSuper(Class);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/extends.js b/node_modules/@babel/runtime/helpers/extends.js
new file mode 100644
index 00000000..7327deaf
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/extends.js
@@ -0,0 +1,21 @@
+var _Object$assign = require("../core-js/object/assign");
+
+function _extends() {
+  module.exports = _extends = _Object$assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
+module.exports = _extends;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/get.js b/node_modules/@babel/runtime/helpers/get.js
new file mode 100644
index 00000000..4525997a
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/get.js
@@ -0,0 +1,30 @@
+var _Object$getOwnPropertyDescriptor = require("../core-js/object/get-own-property-descriptor");
+
+var _Reflect$get = require("../core-js/reflect/get");
+
+var getPrototypeOf = require("./getPrototypeOf");
+
+var superPropBase = require("./superPropBase");
+
+function _get(target, property, receiver) {
+  if (typeof Reflect !== "undefined" && _Reflect$get) {
+    module.exports = _get = _Reflect$get;
+  } else {
+    module.exports = _get = function _get(target, property, receiver) {
+      var base = superPropBase(target, property);
+      if (!base) return;
+
+      var desc = _Object$getOwnPropertyDescriptor(base, property);
+
+      if (desc.get) {
+        return desc.get.call(receiver);
+      }
+
+      return desc.value;
+    };
+  }
+
+  return _get(target, property, receiver || target);
+}
+
+module.exports = _get;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/getPrototypeOf.js b/node_modules/@babel/runtime/helpers/getPrototypeOf.js
new file mode 100644
index 00000000..069e5c5a
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/getPrototypeOf.js
@@ -0,0 +1,11 @@
+var _Object$getPrototypeOf = require("../core-js/object/get-prototype-of");
+
+function _getPrototypeOf(o) {
+  module.exports = _getPrototypeOf = _Object$getPrototypeOf || function _getPrototypeOf(o) {
+    return o.__proto__;
+  };
+
+  return _getPrototypeOf(o);
+}
+
+module.exports = _getPrototypeOf;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/inherits.js b/node_modules/@babel/runtime/helpers/inherits.js
new file mode 100644
index 00000000..766ce4a9
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/inherits.js
@@ -0,0 +1,12 @@
+var setPrototypeOf = require("./setPrototypeOf");
+
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+
+  setPrototypeOf(subClass.prototype, superClass && superClass.prototype);
+  if (superClass) setPrototypeOf(subClass, superClass);
+}
+
+module.exports = _inherits;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/inheritsLoose.js b/node_modules/@babel/runtime/helpers/inheritsLoose.js
new file mode 100644
index 00000000..423693bb
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/inheritsLoose.js
@@ -0,0 +1,6 @@
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype.__proto__ = superClass && superClass.prototype;
+  subClass.__proto__ = superClass;
+}
+
+module.exports = _inheritsLoose;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/initializerDefineProperty.js b/node_modules/@babel/runtime/helpers/initializerDefineProperty.js
new file mode 100644
index 00000000..c0b86d96
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/initializerDefineProperty.js
@@ -0,0 +1,14 @@
+var _Object$defineProperty = require("../core-js/object/define-property");
+
+function _initializerDefineProperty(target, property, descriptor, context) {
+  if (!descriptor) return;
+
+  _Object$defineProperty(target, property, {
+    enumerable: descriptor.enumerable,
+    configurable: descriptor.configurable,
+    writable: descriptor.writable,
+    value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
+  });
+}
+
+module.exports = _initializerDefineProperty;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/initializerWarningHelper.js b/node_modules/@babel/runtime/helpers/initializerWarningHelper.js
new file mode 100644
index 00000000..56e0c173
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/initializerWarningHelper.js
@@ -0,0 +1,5 @@
+function _initializerWarningHelper(descriptor, context) {
+  throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and set to use loose mode. ' + 'To use proposal-class-properties in spec mode with decorators, wait for ' + 'the next major version of decorators in stage 2.');
+}
+
+module.exports = _initializerWarningHelper;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/instanceof.js b/node_modules/@babel/runtime/helpers/instanceof.js
new file mode 100644
index 00000000..830c41e3
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/instanceof.js
@@ -0,0 +1,13 @@
+var _Symbol$hasInstance = require("../core-js/symbol/has-instance");
+
+var _Symbol = require("../core-js/symbol");
+
+function _instanceof(left, right) {
+  if (right != null && typeof _Symbol !== "undefined" && right[_Symbol$hasInstance]) {
+    return right[_Symbol$hasInstance](left);
+  } else {
+    return left instanceof right;
+  }
+}
+
+module.exports = _instanceof;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/interopRequireDefault.js b/node_modules/@babel/runtime/helpers/interopRequireDefault.js
new file mode 100644
index 00000000..0e65e2b8
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/interopRequireDefault.js
@@ -0,0 +1,7 @@
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}
+
+module.exports = _interopRequireDefault;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/interopRequireWildcard.js b/node_modules/@babel/runtime/helpers/interopRequireWildcard.js
new file mode 100644
index 00000000..e0fe792d
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/interopRequireWildcard.js
@@ -0,0 +1,30 @@
+var _Object$getOwnPropertyDescriptor = require("../core-js/object/get-own-property-descriptor");
+
+var _Object$defineProperty = require("../core-js/object/define-property");
+
+function _interopRequireWildcard(obj) {
+  if (obj && obj.__esModule) {
+    return obj;
+  } else {
+    var newObj = {};
+
+    if (obj != null) {
+      for (var key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+          var desc = _Object$defineProperty && _Object$getOwnPropertyDescriptor ? _Object$getOwnPropertyDescriptor(obj, key) : {};
+
+          if (desc.get || desc.set) {
+            _Object$defineProperty(newObj, key, desc);
+          } else {
+            newObj[key] = obj[key];
+          }
+        }
+      }
+    }
+
+    newObj.default = obj;
+    return newObj;
+  }
+}
+
+module.exports = _interopRequireWildcard;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/iterableToArray.js b/node_modules/@babel/runtime/helpers/iterableToArray.js
new file mode 100644
index 00000000..c7834a31
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/iterableToArray.js
@@ -0,0 +1,9 @@
+var _Array$from = require("../core-js/array/from");
+
+var _isIterable = require("../core-js/is-iterable");
+
+function _iterableToArray(iter) {
+  if (_isIterable(Object(iter)) || Object.prototype.toString.call(iter) === "[object Arguments]") return _Array$from(iter);
+}
+
+module.exports = _iterableToArray;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/iterableToArrayLimit.js b/node_modules/@babel/runtime/helpers/iterableToArrayLimit.js
new file mode 100644
index 00000000..22d0d025
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/iterableToArrayLimit.js
@@ -0,0 +1,29 @@
+var _getIterator = require("../core-js/get-iterator");
+
+function _iterableToArrayLimit(arr, i) {
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+  var _e = undefined;
+
+  try {
+    for (var _i = _getIterator(arr), _s; !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+
+      if (i && _arr.length === i) break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) _i["return"]();
+    } finally {
+      if (_d) throw _e;
+    }
+  }
+
+  return _arr;
+}
+
+module.exports = _iterableToArrayLimit;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/iterableToArrayLimitLoose.js b/node_modules/@babel/runtime/helpers/iterableToArrayLimitLoose.js
new file mode 100644
index 00000000..ef233630
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/iterableToArrayLimitLoose.js
@@ -0,0 +1,15 @@
+var _getIterator = require("../core-js/get-iterator");
+
+function _iterableToArrayLimitLoose(arr, i) {
+  var _arr = [];
+
+  for (var _iterator = _getIterator(arr), _step; !(_step = _iterator.next()).done;) {
+    _arr.push(_step.value);
+
+    if (i && _arr.length === i) break;
+  }
+
+  return _arr;
+}
+
+module.exports = _iterableToArrayLimitLoose;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/jsx.js b/node_modules/@babel/runtime/helpers/jsx.js
new file mode 100644
index 00000000..5de724bb
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/jsx.js
@@ -0,0 +1,53 @@
+var _Symbol$for = require("../core-js/symbol/for");
+
+var _Symbol = require("../core-js/symbol");
+
+var REACT_ELEMENT_TYPE;
+
+function _createRawReactElement(type, props, key, children) {
+  if (!REACT_ELEMENT_TYPE) {
+    REACT_ELEMENT_TYPE = typeof _Symbol === "function" && _Symbol$for && _Symbol$for("react.element") || 0xeac7;
+  }
+
+  var defaultProps = type && type.defaultProps;
+  var childrenLength = arguments.length - 3;
+
+  if (!props && childrenLength !== 0) {
+    props = {
+      children: void 0
+    };
+  }
+
+  if (props && defaultProps) {
+    for (var propName in defaultProps) {
+      if (props[propName] === void 0) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+  } else if (!props) {
+    props = defaultProps || {};
+  }
+
+  if (childrenLength === 1) {
+    props.children = children;
+  } else if (childrenLength > 1) {
+    var childArray = new Array(childrenLength);
+
+    for (var i = 0; i < childrenLength; i++) {
+      childArray[i] = arguments[i + 3];
+    }
+
+    props.children = childArray;
+  }
+
+  return {
+    $$typeof: REACT_ELEMENT_TYPE,
+    type: type,
+    key: key === undefined ? null : '' + key,
+    ref: null,
+    props: props,
+    _owner: null
+  };
+}
+
+module.exports = _createRawReactElement;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/newArrowCheck.js b/node_modules/@babel/runtime/helpers/newArrowCheck.js
new file mode 100644
index 00000000..9b59f58c
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/newArrowCheck.js
@@ -0,0 +1,7 @@
+function _newArrowCheck(innerThis, boundThis) {
+  if (innerThis !== boundThis) {
+    throw new TypeError("Cannot instantiate an arrow function");
+  }
+}
+
+module.exports = _newArrowCheck;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/nonIterableRest.js b/node_modules/@babel/runtime/helpers/nonIterableRest.js
new file mode 100644
index 00000000..eb447dd7
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/nonIterableRest.js
@@ -0,0 +1,5 @@
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance");
+}
+
+module.exports = _nonIterableRest;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/nonIterableSpread.js b/node_modules/@babel/runtime/helpers/nonIterableSpread.js
new file mode 100644
index 00000000..7d7ca436
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/nonIterableSpread.js
@@ -0,0 +1,5 @@
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance");
+}
+
+module.exports = _nonIterableSpread;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/objectDestructuringEmpty.js b/node_modules/@babel/runtime/helpers/objectDestructuringEmpty.js
new file mode 100644
index 00000000..1d5c04a7
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/objectDestructuringEmpty.js
@@ -0,0 +1,5 @@
+function _objectDestructuringEmpty(obj) {
+  if (obj == null) throw new TypeError("Cannot destructure undefined");
+}
+
+module.exports = _objectDestructuringEmpty;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/objectSpread.js b/node_modules/@babel/runtime/helpers/objectSpread.js
new file mode 100644
index 00000000..9246e44a
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/objectSpread.js
@@ -0,0 +1,29 @@
+var _Object$getOwnPropertyDescriptor = require("../core-js/object/get-own-property-descriptor");
+
+var _Object$getOwnPropertySymbols = require("../core-js/object/get-own-property-symbols");
+
+var _Object$keys = require("../core-js/object/keys");
+
+var defineProperty = require("./defineProperty");
+
+function _objectSpread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+
+    var ownKeys = _Object$keys(source);
+
+    if (typeof _Object$getOwnPropertySymbols === 'function') {
+      ownKeys = ownKeys.concat(_Object$getOwnPropertySymbols(source).filter(function (sym) {
+        return _Object$getOwnPropertyDescriptor(source, sym).enumerable;
+      }));
+    }
+
+    ownKeys.forEach(function (key) {
+      defineProperty(target, key, source[key]);
+    });
+  }
+
+  return target;
+}
+
+module.exports = _objectSpread;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/objectWithoutProperties.js b/node_modules/@babel/runtime/helpers/objectWithoutProperties.js
new file mode 100644
index 00000000..f5bea285
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/objectWithoutProperties.js
@@ -0,0 +1,33 @@
+var _Object$getOwnPropertySymbols = require("../core-js/object/get-own-property-symbols");
+
+var _Object$keys = require("../core-js/object/keys");
+
+function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+
+  var sourceKeys = _Object$keys(source);
+
+  var key, i;
+
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+
+  if (_Object$getOwnPropertySymbols) {
+    var sourceSymbolKeys = _Object$getOwnPropertySymbols(source);
+
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+
+  return target;
+}
+
+module.exports = _objectWithoutProperties;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/possibleConstructorReturn.js b/node_modules/@babel/runtime/helpers/possibleConstructorReturn.js
new file mode 100644
index 00000000..84f7bf63
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/possibleConstructorReturn.js
@@ -0,0 +1,13 @@
+var _typeof = require("../helpers/typeof");
+
+var assertThisInitialized = require("./assertThisInitialized");
+
+function _possibleConstructorReturn(self, call) {
+  if (call && (_typeof(call) === "object" || typeof call === "function")) {
+    return call;
+  }
+
+  return assertThisInitialized(self);
+}
+
+module.exports = _possibleConstructorReturn;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/readOnlyError.js b/node_modules/@babel/runtime/helpers/readOnlyError.js
new file mode 100644
index 00000000..4e61e3fd
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/readOnlyError.js
@@ -0,0 +1,5 @@
+function _readOnlyError(name) {
+  throw new Error("\"" + name + "\" is read-only");
+}
+
+module.exports = _readOnlyError;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/set.js b/node_modules/@babel/runtime/helpers/set.js
new file mode 100644
index 00000000..aa405aaf
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/set.js
@@ -0,0 +1,63 @@
+var _Object$defineProperty = require("../core-js/object/define-property");
+
+var _Object$getOwnPropertyDescriptor = require("../core-js/object/get-own-property-descriptor");
+
+var _Reflect$set = require("../core-js/reflect/set");
+
+var getPrototypeOf = require("./getPrototypeOf");
+
+var superPropBase = require("./superPropBase");
+
+var defineProperty = require("./defineProperty");
+
+function set(target, property, value, receiver) {
+  if (typeof Reflect !== "undefined" && _Reflect$set) {
+    set = _Reflect$set;
+  } else {
+    set = function set(target, property, value, receiver) {
+      var base = superPropBase(target, property);
+      var desc;
+
+      if (base) {
+        desc = _Object$getOwnPropertyDescriptor(base, property);
+
+        if (desc.set) {
+          desc.set.call(receiver, value);
+          return true;
+        } else if (!desc.writable) {
+          return false;
+        }
+      }
+
+      desc = _Object$getOwnPropertyDescriptor(receiver, property);
+
+      if (desc) {
+        if (!desc.writable) {
+          return false;
+        }
+
+        desc.value = value;
+
+        _Object$defineProperty(receiver, property, desc);
+      } else {
+        defineProperty(receiver, property, value);
+      }
+
+      return true;
+    };
+  }
+
+  return set(target, property, value, receiver);
+}
+
+function _set(target, property, value, receiver, isStrict) {
+  var s = set(target, property, value, receiver || target);
+
+  if (!s && isStrict) {
+    throw new Error('failed to set property');
+  }
+
+  return value;
+}
+
+module.exports = _set;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/setPrototypeOf.js b/node_modules/@babel/runtime/helpers/setPrototypeOf.js
new file mode 100644
index 00000000..ccca1c2b
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/setPrototypeOf.js
@@ -0,0 +1,12 @@
+var _Object$setPrototypeOf = require("../core-js/object/set-prototype-of");
+
+function _setPrototypeOf(o, p) {
+  module.exports = _setPrototypeOf = _Object$setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+
+  return _setPrototypeOf(o, p);
+}
+
+module.exports = _setPrototypeOf;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/skipFirstGeneratorNext.js b/node_modules/@babel/runtime/helpers/skipFirstGeneratorNext.js
new file mode 100644
index 00000000..e1d6c86b
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/skipFirstGeneratorNext.js
@@ -0,0 +1,9 @@
+function _skipFirstGeneratorNext(fn) {
+  return function () {
+    var it = fn.apply(this, arguments);
+    it.next();
+    return it;
+  };
+}
+
+module.exports = _skipFirstGeneratorNext;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/slicedToArray.js b/node_modules/@babel/runtime/helpers/slicedToArray.js
new file mode 100644
index 00000000..243ea9e2
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/slicedToArray.js
@@ -0,0 +1,11 @@
+var arrayWithHoles = require("./arrayWithHoles");
+
+var iterableToArrayLimit = require("./iterableToArrayLimit");
+
+var nonIterableRest = require("./nonIterableRest");
+
+function _slicedToArray(arr, i) {
+  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || nonIterableRest();
+}
+
+module.exports = _slicedToArray;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/slicedToArrayLoose.js b/node_modules/@babel/runtime/helpers/slicedToArrayLoose.js
new file mode 100644
index 00000000..c7e4313b
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/slicedToArrayLoose.js
@@ -0,0 +1,11 @@
+var arrayWithHoles = require("./arrayWithHoles");
+
+var iterableToArrayLimitLoose = require("./iterableToArrayLimitLoose");
+
+var nonIterableRest = require("./nonIterableRest");
+
+function _slicedToArrayLoose(arr, i) {
+  return arrayWithHoles(arr) || iterableToArrayLimitLoose(arr, i) || nonIterableRest();
+}
+
+module.exports = _slicedToArrayLoose;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/superPropBase.js b/node_modules/@babel/runtime/helpers/superPropBase.js
new file mode 100644
index 00000000..bbb34a2d
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/superPropBase.js
@@ -0,0 +1,12 @@
+var getPrototypeOf = require("./getPrototypeOf");
+
+function _superPropBase(object, property) {
+  while (!Object.prototype.hasOwnProperty.call(object, property)) {
+    object = getPrototypeOf(object);
+    if (object === null) break;
+  }
+
+  return object;
+}
+
+module.exports = _superPropBase;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/taggedTemplateLiteral.js b/node_modules/@babel/runtime/helpers/taggedTemplateLiteral.js
new file mode 100644
index 00000000..bdebfa46
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/taggedTemplateLiteral.js
@@ -0,0 +1,17 @@
+var _Object$defineProperties = require("../core-js/object/define-properties");
+
+var _Object$freeze = require("../core-js/object/freeze");
+
+function _taggedTemplateLiteral(strings, raw) {
+  if (!raw) {
+    raw = strings.slice(0);
+  }
+
+  return _Object$freeze(_Object$defineProperties(strings, {
+    raw: {
+      value: _Object$freeze(raw)
+    }
+  }));
+}
+
+module.exports = _taggedTemplateLiteral;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/taggedTemplateLiteralLoose.js b/node_modules/@babel/runtime/helpers/taggedTemplateLiteralLoose.js
new file mode 100644
index 00000000..beced541
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/taggedTemplateLiteralLoose.js
@@ -0,0 +1,10 @@
+function _taggedTemplateLiteralLoose(strings, raw) {
+  if (!raw) {
+    raw = strings.slice(0);
+  }
+
+  strings.raw = raw;
+  return strings;
+}
+
+module.exports = _taggedTemplateLiteralLoose;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/temporalRef.js b/node_modules/@babel/runtime/helpers/temporalRef.js
new file mode 100644
index 00000000..20b2652a
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/temporalRef.js
@@ -0,0 +1,11 @@
+var temporalUndefined = require("./temporalUndefined");
+
+function _temporalRef(val, name) {
+  if (val === temporalUndefined) {
+    throw new ReferenceError(name + " is not defined - temporal dead zone");
+  } else {
+    return val;
+  }
+}
+
+module.exports = _temporalRef;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/temporalUndefined.js b/node_modules/@babel/runtime/helpers/temporalUndefined.js
new file mode 100644
index 00000000..a0995453
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/temporalUndefined.js
@@ -0,0 +1 @@
+module.exports = {};
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/toArray.js b/node_modules/@babel/runtime/helpers/toArray.js
new file mode 100644
index 00000000..c28fd9e4
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/toArray.js
@@ -0,0 +1,11 @@
+var arrayWithHoles = require("./arrayWithHoles");
+
+var iterableToArray = require("./iterableToArray");
+
+var nonIterableRest = require("./nonIterableRest");
+
+function _toArray(arr) {
+  return arrayWithHoles(arr) || iterableToArray(arr) || nonIterableRest();
+}
+
+module.exports = _toArray;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/toConsumableArray.js b/node_modules/@babel/runtime/helpers/toConsumableArray.js
new file mode 100644
index 00000000..4cd54a33
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/toConsumableArray.js
@@ -0,0 +1,11 @@
+var arrayWithoutHoles = require("./arrayWithoutHoles");
+
+var iterableToArray = require("./iterableToArray");
+
+var nonIterableSpread = require("./nonIterableSpread");
+
+function _toConsumableArray(arr) {
+  return arrayWithoutHoles(arr) || iterableToArray(arr) || nonIterableSpread();
+}
+
+module.exports = _toConsumableArray;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/toPropertyKey.js b/node_modules/@babel/runtime/helpers/toPropertyKey.js
new file mode 100644
index 00000000..d4014dd7
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/toPropertyKey.js
@@ -0,0 +1,11 @@
+var _typeof = require("../helpers/typeof");
+
+function _toPropertyKey(key) {
+  if (_typeof(key) === "symbol") {
+    return key;
+  } else {
+    return String(key);
+  }
+}
+
+module.exports = _toPropertyKey;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/typeof.js b/node_modules/@babel/runtime/helpers/typeof.js
new file mode 100644
index 00000000..cbc85fe7
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/typeof.js
@@ -0,0 +1,21 @@
+var _Symbol$iterator = require("../core-js/symbol/iterator");
+
+var _Symbol = require("../core-js/symbol");
+
+function _typeof2(obj) { if (typeof _Symbol === "function" && typeof _Symbol$iterator === "symbol") { _typeof2 = function _typeof2(obj) { return typeof obj; }; } else { _typeof2 = function _typeof2(obj) { return obj && typeof _Symbol === "function" && obj.constructor === _Symbol && obj !== _Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof2(obj); }
+
+function _typeof(obj) {
+  if (typeof _Symbol === "function" && _typeof2(_Symbol$iterator) === "symbol") {
+    module.exports = _typeof = function _typeof(obj) {
+      return _typeof2(obj);
+    };
+  } else {
+    module.exports = _typeof = function _typeof(obj) {
+      return obj && typeof _Symbol === "function" && obj.constructor === _Symbol && obj !== _Symbol.prototype ? "symbol" : _typeof2(obj);
+    };
+  }
+
+  return _typeof(obj);
+}
+
+module.exports = _typeof;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/wrapAsyncGenerator.js b/node_modules/@babel/runtime/helpers/wrapAsyncGenerator.js
new file mode 100644
index 00000000..11554f3d
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/wrapAsyncGenerator.js
@@ -0,0 +1,9 @@
+var AsyncGenerator = require("./AsyncGenerator");
+
+function _wrapAsyncGenerator(fn) {
+  return function () {
+    return new AsyncGenerator(fn.apply(this, arguments));
+  };
+}
+
+module.exports = _wrapAsyncGenerator;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/helpers/wrapNativeSuper.js b/node_modules/@babel/runtime/helpers/wrapNativeSuper.js
new file mode 100644
index 00000000..fe133e04
--- /dev/null
+++ b/node_modules/@babel/runtime/helpers/wrapNativeSuper.js
@@ -0,0 +1,43 @@
+var _Object$create = require("../core-js/object/create");
+
+var _Map = require("../core-js/map");
+
+var getPrototypeOf = require("./getPrototypeOf");
+
+var setPrototypeOf = require("./setPrototypeOf");
+
+var construct = require("./construct");
+
+function _wrapNativeSuper(Class) {
+  var _cache = typeof _Map === "function" ? new _Map() : undefined;
+
+  module.exports = _wrapNativeSuper = function _wrapNativeSuper(Class) {
+    if (typeof Class !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class)) return _cache.get(Class);
+
+      _cache.set(Class, Wrapper);
+    }
+
+    function Wrapper() {}
+
+    Wrapper.prototype = _Object$create(Class.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return setPrototypeOf(Wrapper, setPrototypeOf(function Super() {
+      return construct(Class, arguments, getPrototypeOf(this).constructor);
+    }, Class));
+  };
+
+  return _wrapNativeSuper(Class);
+}
+
+module.exports = _wrapNativeSuper;
\ No newline at end of file
diff --git a/node_modules/@babel/runtime/package.json b/node_modules/@babel/runtime/package.json
new file mode 100644
index 00000000..525e6faf
--- /dev/null
+++ b/node_modules/@babel/runtime/package.json
@@ -0,0 +1,19 @@
+{
+  "name": "@babel/runtime",
+  "version": "7.0.0-beta.47",
+  "description": "babel selfContained runtime",
+  "license": "MIT",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-runtime",
+  "author": "Sebastian McKenzie <sebmck@gmail.com>",
+  "dependencies": {
+    "core-js": "^2.5.3",
+    "regenerator-runtime": "^0.11.1"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helpers": "7.0.0-beta.47",
+    "@babel/plugin-transform-runtime": "7.0.0-beta.47",
+    "@babel/preset-env": "7.0.0-beta.47",
+    "@babel/types": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/runtime/regenerator/index.js b/node_modules/@babel/runtime/regenerator/index.js
new file mode 100644
index 00000000..9fd4158a
--- /dev/null
+++ b/node_modules/@babel/runtime/regenerator/index.js
@@ -0,0 +1 @@
+module.exports = require("regenerator-runtime");
diff --git a/node_modules/@babel/template/README.md b/node_modules/@babel/template/README.md
new file mode 100644
index 00000000..0219286c
--- /dev/null
+++ b/node_modules/@babel/template/README.md
@@ -0,0 +1,172 @@
+# @babel/template
+
+> Generate an AST from a string template or template literal.
+
+In computer science, this is known as an implementation of quasiquotes.
+
+## Install
+
+```sh
+npm install --save-dev @babel/template
+```
+
+## String Usage
+
+```js
+import template from "@babel/template";
+import generate from "@babel/generator";
+import * as t from "@babel/types";
+
+const buildRequire = template(`
+  var IMPORT_NAME = require(SOURCE);
+`);
+
+const ast = buildRequire({
+  IMPORT_NAME: t.identifier("myModule"),
+  SOURCE: t.stringLiteral("my-module")
+});
+
+console.log(generate(ast).code);
+```
+
+```js
+const myModule = require("my-module");
+```
+
+### `.ast`
+
+If no placeholders are in use and you just want a simple way to parse a
+string into an AST, you can use the `.ast` version of the template.
+
+```js
+const ast = template.ast(`
+  var myModule = require("my-module");
+`);
+```
+which will parse and return the AST directly.
+
+
+## Template Literal Usage
+
+```js
+import template from "@babel/template";
+import generate from "@babel/generator";
+import * as t from "@babel/types";
+
+const fn = template`
+  var IMPORT_NAME = require('${"my-module"}');
+`);
+
+const ast = fn({
+  IMPORT_NAME: t.identifier("myModule");
+});
+
+console.log(generate(ast).code);
+```
+
+Note that placeholders can be passed directly as part of the template literal
+in order to make things as readable as possible, or they can be passed into
+the template function.
+
+### `.ast`
+
+If no placeholders are in use and you just want a simple way to parse a
+string into an AST, you can use the `.ast` version of the template.
+
+```js
+const name = "my-module";
+const mod = "myModule";
+
+const ast = template.ast`
+  var ${mod} = require("${name}");
+`;
+```
+which will parse and return the AST directly. Note that unlike the string-based
+version mentioned earlier, since this is a template literal, it is still
+valid to perform replacements using template literal replacements.
+
+
+## AST results
+
+The `@babel/template` API exposes a few flexible APIs to make it as easy as
+possible to create ASTs with an expected structure. Each of these also has
+the `.ast` property mentioned above.
+
+### `template`
+
+`template` returns either a single statement, or an array of
+statements, depending on the parsed result.
+
+### `template.smart`
+
+This is the same as the default `template` API, returning either a single
+node, or an array of nodes, depending on the parsed result.
+
+### `template.statement`
+
+`template.statement("foo;")()` returns a single statement node, and throw
+an exception if the result is anything but a single statement.
+
+### `template.statements`
+
+`template.statements("foo;foo;")()` returns an array of statement nodes.
+
+### `template.expression`
+
+`template.expression("foo")()` returns the expression node.
+
+### `template.program`
+
+`template.program("foo;")()` returns the `Program` node for the template.
+
+
+## API
+
+### `template(code, [opts])`
+
+#### code
+
+Type: `string`
+
+#### options
+
+`@babel/template` accepts all of the options from [babylon](https://github.com/babel/babel/tree/master/packages/babylon), and specifies
+some defaults of its own:
+
+* `allowReturnOutsideFunction` is set to `true` by default.
+* `allowSuperOutsideMethod` is set to `true` by default.
+* `sourceType` is set to `module` by default.
+
+##### placeholderWhitelist
+
+Type: `Set<string>`
+Default: `undefined`
+
+A set of placeholder names to automatically accept. Items in this list do
+not need to match the given placeholder pattern.
+
+##### placeholderPattern
+
+Type: `RegExp | false`
+Default: `/^[_$A-Z0-9]+$/`
+
+A pattern to search for when looking for Identifier and StringLiteral
+nodes that should be considered placeholders.
+'false' will disable placeholder searching entirely, leaving only the
+'placeholderWhitelist' value to find placeholders.
+
+##### preserveComments
+
+Type: `boolean`
+Default: `false`
+
+Set this to `true` to preserve any comments from the `code` parameter.
+
+#### Return value
+
+By default `@babel/template` returns a `function` which is invoked with an
+optional object of replacements. See the usage section for an example.
+
+When using `.ast`, the AST will be returned directly.
+
+[babylon]: https://github.com/babel/babylon#options
diff --git a/node_modules/@babel/template/lib/builder.js b/node_modules/@babel/template/lib/builder.js
new file mode 100644
index 00000000..2a0e6297
--- /dev/null
+++ b/node_modules/@babel/template/lib/builder.js
@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createTemplateBuilder;
+
+var _options = require("./options");
+
+var _string = _interopRequireDefault(require("./string"));
+
+var _literal = _interopRequireDefault(require("./literal"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const NO_PLACEHOLDER = (0, _options.validate)({
+  placeholderPattern: false
+});
+
+function createTemplateBuilder(formatter, defaultOpts) {
+  const templateFnCache = new WeakMap();
+  const templateAstCache = new WeakMap();
+  const cachedOpts = defaultOpts || (0, _options.validate)(null);
+  return Object.assign((tpl, ...args) => {
+    if (typeof tpl === "string") {
+      if (args.length > 1) throw new Error("Unexpected extra params.");
+      return extendedTrace((0, _string.default)(formatter, tpl, (0, _options.merge)(cachedOpts, (0, _options.validate)(args[0]))));
+    } else if (Array.isArray(tpl)) {
+      let builder = templateFnCache.get(tpl);
+
+      if (!builder) {
+        builder = (0, _literal.default)(formatter, tpl, cachedOpts);
+        templateFnCache.set(tpl, builder);
+      }
+
+      return extendedTrace(builder(args));
+    } else if (typeof tpl === "object" && tpl) {
+      if (args.length > 0) throw new Error("Unexpected extra params.");
+      return createTemplateBuilder(formatter, (0, _options.merge)(cachedOpts, (0, _options.validate)(tpl)));
+    }
+
+    throw new Error(`Unexpected template param ${typeof tpl}`);
+  }, {
+    ast: (tpl, ...args) => {
+      if (typeof tpl === "string") {
+        if (args.length > 1) throw new Error("Unexpected extra params.");
+        return (0, _string.default)(formatter, tpl, (0, _options.merge)((0, _options.merge)(cachedOpts, (0, _options.validate)(args[0])), NO_PLACEHOLDER))();
+      } else if (Array.isArray(tpl)) {
+        let builder = templateAstCache.get(tpl);
+
+        if (!builder) {
+          builder = (0, _literal.default)(formatter, tpl, (0, _options.merge)(cachedOpts, NO_PLACEHOLDER));
+          templateAstCache.set(tpl, builder);
+        }
+
+        return builder(args)();
+      }
+
+      throw new Error(`Unexpected template param ${typeof tpl}`);
+    }
+  });
+}
+
+function extendedTrace(fn) {
+  let rootStack = "";
+
+  try {
+    throw new Error();
+  } catch (error) {
+    if (error.stack) {
+      rootStack = error.stack.split("\n").slice(3).join("\n");
+    }
+  }
+
+  return arg => {
+    try {
+      return fn(arg);
+    } catch (err) {
+      err.stack += `\n    =============\n${rootStack}`;
+      throw err;
+    }
+  };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/template/lib/formatters.js b/node_modules/@babel/template/lib/formatters.js
new file mode 100644
index 00000000..59e0984c
--- /dev/null
+++ b/node_modules/@babel/template/lib/formatters.js
@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.program = exports.expression = exports.statement = exports.statements = exports.smart = void 0;
+
+function makeStatementFormatter(fn) {
+  return {
+    code: str => `/* @babel/template */;\n${str}`,
+    validate: () => {},
+    unwrap: ast => {
+      return fn(ast.program.body.slice(1));
+    }
+  };
+}
+
+const smart = makeStatementFormatter(body => {
+  if (body.length > 1) {
+    return body;
+  } else {
+    return body[0];
+  }
+});
+exports.smart = smart;
+const statements = makeStatementFormatter(body => body);
+exports.statements = statements;
+const statement = makeStatementFormatter(body => {
+  if (body.length === 0) {
+    throw new Error("Found nothing to return.");
+  }
+
+  if (body.length > 1) {
+    throw new Error("Found multiple statements but wanted one");
+  }
+
+  return body[0];
+});
+exports.statement = statement;
+const expression = {
+  code: str => `(\n${str}\n)`,
+  validate: ({
+    program
+  }) => {
+    if (program.body.length > 1) {
+      throw new Error("Found multiple statements but wanted one");
+    }
+
+    const expression = program.body[0].expression;
+
+    if (expression.start === 0) {
+      throw new Error("Parse result included parens.");
+    }
+  },
+  unwrap: ast => ast.program.body[0].expression
+};
+exports.expression = expression;
+const program = {
+  code: str => str,
+  validate: () => {},
+  unwrap: ast => ast.program
+};
+exports.program = program;
\ No newline at end of file
diff --git a/node_modules/@babel/template/lib/index.js b/node_modules/@babel/template/lib/index.js
new file mode 100644
index 00000000..7ce85e9f
--- /dev/null
+++ b/node_modules/@babel/template/lib/index.js
@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.program = exports.expression = exports.statements = exports.statement = exports.smart = void 0;
+
+var formatters = _interopRequireWildcard(require("./formatters"));
+
+var _builder = _interopRequireDefault(require("./builder"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+const smart = (0, _builder.default)(formatters.smart);
+exports.smart = smart;
+const statement = (0, _builder.default)(formatters.statement);
+exports.statement = statement;
+const statements = (0, _builder.default)(formatters.statements);
+exports.statements = statements;
+const expression = (0, _builder.default)(formatters.expression);
+exports.expression = expression;
+const program = (0, _builder.default)(formatters.program);
+exports.program = program;
+
+var _default = Object.assign(smart.bind(undefined), {
+  smart,
+  statement,
+  statements,
+  expression,
+  program,
+  ast: smart.ast
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/template/lib/literal.js b/node_modules/@babel/template/lib/literal.js
new file mode 100644
index 00000000..6f614096
--- /dev/null
+++ b/node_modules/@babel/template/lib/literal.js
@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = literalTemplate;
+
+var _options = require("./options");
+
+var _parse = _interopRequireDefault(require("./parse"));
+
+var _populate = _interopRequireDefault(require("./populate"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function literalTemplate(formatter, tpl, opts) {
+  const _buildLiteralData = buildLiteralData(formatter, tpl, opts),
+        metadata = _buildLiteralData.metadata,
+        names = _buildLiteralData.names;
+
+  return arg => {
+    const defaultReplacements = arg.reduce((acc, replacement, i) => {
+      acc[names[i]] = replacement;
+      return acc;
+    }, {});
+    return arg => {
+      const replacements = (0, _options.normalizeReplacements)(arg);
+
+      if (replacements) {
+        Object.keys(replacements).forEach(key => {
+          if (Object.prototype.hasOwnProperty.call(defaultReplacements, key)) {
+            throw new Error("Unexpected replacement overlap.");
+          }
+        });
+      }
+
+      return formatter.unwrap((0, _populate.default)(metadata, replacements ? Object.assign(replacements, defaultReplacements) : defaultReplacements));
+    };
+  };
+}
+
+function buildLiteralData(formatter, tpl, opts) {
+  let names;
+  let nameSet;
+  let metadata;
+  let prefix = "";
+
+  do {
+    prefix += "$";
+    const result = buildTemplateCode(tpl, prefix);
+    names = result.names;
+    nameSet = new Set(names);
+    metadata = (0, _parse.default)(formatter, formatter.code(result.code), {
+      parser: opts.parser,
+      placeholderWhitelist: new Set(result.names.concat(opts.placeholderWhitelist ? Array.from(opts.placeholderWhitelist) : [])),
+      placeholderPattern: opts.placeholderPattern,
+      preserveComments: opts.preserveComments
+    });
+  } while (metadata.placeholders.some(placeholder => placeholder.isDuplicate && nameSet.has(placeholder.name)));
+
+  return {
+    metadata,
+    names
+  };
+}
+
+function buildTemplateCode(tpl, prefix) {
+  const names = [];
+  let code = tpl[0];
+
+  for (let i = 1; i < tpl.length; i++) {
+    const value = `${prefix}${i - 1}`;
+    names.push(value);
+    code += value + tpl[i];
+  }
+
+  return {
+    names,
+    code
+  };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/template/lib/options.js b/node_modules/@babel/template/lib/options.js
new file mode 100644
index 00000000..2a5a48a1
--- /dev/null
+++ b/node_modules/@babel/template/lib/options.js
@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.merge = merge;
+exports.validate = validate;
+exports.normalizeReplacements = normalizeReplacements;
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function merge(a, b) {
+  const _b$placeholderWhiteli = b.placeholderWhitelist,
+        placeholderWhitelist = _b$placeholderWhiteli === void 0 ? a.placeholderWhitelist : _b$placeholderWhiteli,
+        _b$placeholderPattern = b.placeholderPattern,
+        placeholderPattern = _b$placeholderPattern === void 0 ? a.placeholderPattern : _b$placeholderPattern,
+        _b$preserveComments = b.preserveComments,
+        preserveComments = _b$preserveComments === void 0 ? a.preserveComments : _b$preserveComments;
+  return {
+    parser: Object.assign({}, a.parser, b.parser),
+    placeholderWhitelist,
+    placeholderPattern,
+    preserveComments
+  };
+}
+
+function validate(opts) {
+  if (opts != null && typeof opts !== "object") {
+    throw new Error("Unknown template options.");
+  }
+
+  const _ref = opts || {},
+        placeholderWhitelist = _ref.placeholderWhitelist,
+        placeholderPattern = _ref.placeholderPattern,
+        preserveComments = _ref.preserveComments,
+        parser = _objectWithoutProperties(_ref, ["placeholderWhitelist", "placeholderPattern", "preserveComments"]);
+
+  if (placeholderWhitelist != null && !(placeholderWhitelist instanceof Set)) {
+    throw new Error("'.placeholderWhitelist' must be a Set, null, or undefined");
+  }
+
+  if (placeholderPattern != null && !(placeholderPattern instanceof RegExp) && placeholderPattern !== false) {
+    throw new Error("'.placeholderPattern' must be a RegExp, false, null, or undefined");
+  }
+
+  if (preserveComments != null && typeof preserveComments !== "boolean") {
+    throw new Error("'.preserveComments' must be a boolean, null, or undefined");
+  }
+
+  return {
+    parser,
+    placeholderWhitelist: placeholderWhitelist || undefined,
+    placeholderPattern: placeholderPattern == null ? undefined : placeholderPattern,
+    preserveComments: preserveComments == null ? false : preserveComments
+  };
+}
+
+function normalizeReplacements(replacements) {
+  if (Array.isArray(replacements)) {
+    return replacements.reduce((acc, replacement, i) => {
+      acc["$" + i] = replacement;
+      return acc;
+    }, {});
+  } else if (typeof replacements === "object" || replacements == null) {
+    return replacements || undefined;
+  }
+
+  throw new Error("Template replacements must be an array, object, null, or undefined");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/template/lib/parse.js b/node_modules/@babel/template/lib/parse.js
new file mode 100644
index 00000000..ddaa69fb
--- /dev/null
+++ b/node_modules/@babel/template/lib/parse.js
@@ -0,0 +1,154 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = parseAndBuildMetadata;
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _babylon() {
+  const data = require("babylon");
+
+  _babylon = function _babylon() {
+    return data;
+  };
+
+  return data;
+}
+
+function _codeFrame() {
+  const data = require("@babel/code-frame");
+
+  _codeFrame = function _codeFrame() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+const PATTERN = /^[_$A-Z0-9]+$/;
+
+function parseAndBuildMetadata(formatter, code, opts) {
+  const ast = parseWithCodeFrame(code, opts.parser);
+  const placeholderWhitelist = opts.placeholderWhitelist,
+        _opts$placeholderPatt = opts.placeholderPattern,
+        placeholderPattern = _opts$placeholderPatt === void 0 ? PATTERN : _opts$placeholderPatt,
+        preserveComments = opts.preserveComments;
+  t().removePropertiesDeep(ast, {
+    preserveComments
+  });
+  formatter.validate(ast);
+  const placeholders = [];
+  const placeholderNames = new Set();
+  t().traverse(ast, placeholderVisitorHandler, {
+    placeholders,
+    placeholderNames,
+    placeholderWhitelist,
+    placeholderPattern
+  });
+  return {
+    ast,
+    placeholders,
+    placeholderNames
+  };
+}
+
+function placeholderVisitorHandler(node, ancestors, state) {
+  let name;
+
+  if (t().isIdentifier(node) || t().isJSXIdentifier(node)) {
+    name = node.name;
+  } else if (t().isStringLiteral(node)) {
+    name = node.value;
+  } else {
+    return;
+  }
+
+  if ((!state.placeholderPattern || !state.placeholderPattern.test(name)) && (!state.placeholderWhitelist || !state.placeholderWhitelist.has(name))) {
+    return;
+  }
+
+  ancestors = ancestors.slice();
+  const _ancestors = ancestors[ancestors.length - 1],
+        parent = _ancestors.node,
+        key = _ancestors.key;
+  let type;
+
+  if (t().isStringLiteral(node)) {
+    type = "string";
+  } else if (t().isNewExpression(parent) && key === "arguments" || t().isCallExpression(parent) && key === "arguments" || t().isFunction(parent) && key === "params") {
+    type = "param";
+  } else if (t().isExpressionStatement(parent)) {
+    type = "statement";
+    ancestors = ancestors.slice(0, -1);
+  } else {
+    type = "other";
+  }
+
+  state.placeholders.push({
+    name,
+    type,
+    resolve: ast => resolveAncestors(ast, ancestors),
+    isDuplicate: state.placeholderNames.has(name)
+  });
+  state.placeholderNames.add(name);
+}
+
+function resolveAncestors(ast, ancestors) {
+  let parent = ast;
+
+  for (let i = 0; i < ancestors.length - 1; i++) {
+    const _ancestors$i = ancestors[i],
+          key = _ancestors$i.key,
+          index = _ancestors$i.index;
+
+    if (index === undefined) {
+      parent = parent[key];
+    } else {
+      parent = parent[key][index];
+    }
+  }
+
+  const _ancestors2 = ancestors[ancestors.length - 1],
+        key = _ancestors2.key,
+        index = _ancestors2.index;
+  return {
+    parent,
+    key,
+    index
+  };
+}
+
+function parseWithCodeFrame(code, parserOpts) {
+  parserOpts = Object.assign({
+    allowReturnOutsideFunction: true,
+    allowSuperOutsideMethod: true,
+    sourceType: "module"
+  }, parserOpts);
+
+  try {
+    return (0, _babylon().parse)(code, parserOpts);
+  } catch (err) {
+    const loc = err.loc;
+
+    if (loc) {
+      err.message += "\n" + (0, _codeFrame().codeFrameColumns)(code, {
+        start: loc
+      });
+      err.code = "BABEL_TEMPLATE_PARSE_ERROR";
+    }
+
+    throw err;
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/template/lib/populate.js b/node_modules/@babel/template/lib/populate.js
new file mode 100644
index 00000000..a5746642
--- /dev/null
+++ b/node_modules/@babel/template/lib/populate.js
@@ -0,0 +1,132 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = populatePlaceholders;
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function populatePlaceholders(metadata, replacements) {
+  const ast = t().cloneNode(metadata.ast);
+
+  if (replacements) {
+    metadata.placeholders.forEach(placeholder => {
+      if (!Object.prototype.hasOwnProperty.call(replacements, placeholder.name)) {
+        const placeholderName = placeholder.name;
+        throw new Error(`Error: No substitution given for "${placeholderName}". If this is not meant to be a
+            placeholder you may want to consider passing one of the following options to @babel/template:
+            - { placeholderPattern: false, placeholderWhitelist: new Set(['${placeholderName}'])}
+            - { placeholderPattern: /^${placeholderName}$/ }`);
+      }
+    });
+    Object.keys(replacements).forEach(key => {
+      if (!metadata.placeholderNames.has(key)) {
+        throw new Error(`Unknown substitution "${key}" given`);
+      }
+    });
+  }
+
+  metadata.placeholders.slice().reverse().forEach(placeholder => {
+    try {
+      applyReplacement(placeholder, ast, replacements && replacements[placeholder.name] || null);
+    } catch (e) {
+      e.message = `@babel/template placeholder "${placeholder.name}": ${e.message}`;
+      throw e;
+    }
+  });
+  return ast;
+}
+
+function applyReplacement(placeholder, ast, replacement) {
+  if (placeholder.isDuplicate) {
+    if (Array.isArray(replacement)) {
+      replacement = replacement.map(node => t().cloneNode(node));
+    } else if (typeof replacement === "object") {
+      replacement = t().cloneNode(replacement);
+    }
+  }
+
+  const _placeholder$resolve = placeholder.resolve(ast),
+        parent = _placeholder$resolve.parent,
+        key = _placeholder$resolve.key,
+        index = _placeholder$resolve.index;
+
+  if (placeholder.type === "string") {
+    if (typeof replacement === "string") {
+      replacement = t().stringLiteral(replacement);
+    }
+
+    if (!replacement || !t().isStringLiteral(replacement)) {
+      throw new Error("Expected string substitution");
+    }
+  } else if (placeholder.type === "statement") {
+    if (index === undefined) {
+      if (!replacement) {
+        replacement = t().emptyStatement();
+      } else if (Array.isArray(replacement)) {
+        replacement = t().blockStatement(replacement);
+      } else if (typeof replacement === "string") {
+        replacement = t().expressionStatement(t().identifier(replacement));
+      } else if (!t().isStatement(replacement)) {
+        replacement = t().expressionStatement(replacement);
+      }
+    } else {
+      if (replacement && !Array.isArray(replacement)) {
+        if (typeof replacement === "string") {
+          replacement = t().identifier(replacement);
+        }
+
+        if (!t().isStatement(replacement)) {
+          replacement = t().expressionStatement(replacement);
+        }
+      }
+    }
+  } else if (placeholder.type === "param") {
+    if (typeof replacement === "string") {
+      replacement = t().identifier(replacement);
+    }
+
+    if (index === undefined) throw new Error("Assertion failure.");
+  } else {
+    if (typeof replacement === "string") {
+      replacement = t().identifier(replacement);
+    }
+
+    if (Array.isArray(replacement)) {
+      throw new Error("Cannot replace single expression with an array.");
+    }
+  }
+
+  if (index === undefined) {
+    t().validate(parent, key, replacement);
+    parent[key] = replacement;
+  } else {
+    const items = parent[key].slice();
+
+    if (placeholder.type === "statement" || placeholder.type === "param") {
+      if (replacement == null) {
+        items.splice(index, 1);
+      } else if (Array.isArray(replacement)) {
+        items.splice(index, 1, ...replacement);
+      } else {
+        items[index] = replacement;
+      }
+    } else {
+      items[index] = replacement;
+    }
+
+    t().validate(parent, key, items);
+    parent[key] = items;
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/template/lib/string.js b/node_modules/@babel/template/lib/string.js
new file mode 100644
index 00000000..02ad4578
--- /dev/null
+++ b/node_modules/@babel/template/lib/string.js
@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = stringTemplate;
+
+var _options = require("./options");
+
+var _parse = _interopRequireDefault(require("./parse"));
+
+var _populate = _interopRequireDefault(require("./populate"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function stringTemplate(formatter, code, opts) {
+  code = formatter.code(code);
+  let metadata;
+  return arg => {
+    const replacements = (0, _options.normalizeReplacements)(arg);
+    if (!metadata) metadata = (0, _parse.default)(formatter, code, opts);
+    return formatter.unwrap((0, _populate.default)(metadata, replacements));
+  };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/template/node_modules/.bin/babylon b/node_modules/@babel/template/node_modules/.bin/babylon
new file mode 120000
index 00000000..5acfefcc
--- /dev/null
+++ b/node_modules/@babel/template/node_modules/.bin/babylon
@@ -0,0 +1 @@
+../../../../babylon/bin/babylon.js
\ No newline at end of file
diff --git a/node_modules/@babel/template/package.json b/node_modules/@babel/template/package.json
new file mode 100644
index 00000000..55eafdb4
--- /dev/null
+++ b/node_modules/@babel/template/package.json
@@ -0,0 +1,16 @@
+{
+  "name": "@babel/template",
+  "version": "7.0.0-beta.47",
+  "description": "Generate an AST from a string template.",
+  "author": "Sebastian McKenzie <sebmck@gmail.com>",
+  "homepage": "https://babeljs.io/",
+  "license": "MIT",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-template",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/code-frame": "7.0.0-beta.47",
+    "@babel/types": "7.0.0-beta.47",
+    "babylon": "7.0.0-beta.47",
+    "lodash": "^4.17.5"
+  }
+}
diff --git a/node_modules/@babel/traverse/README.md b/node_modules/@babel/traverse/README.md
new file mode 100644
index 00000000..a25ffe70
--- /dev/null
+++ b/node_modules/@babel/traverse/README.md
@@ -0,0 +1,33 @@
+# @babel/traverse
+
+> @babel/traverse maintains the overall tree state, and is responsible for replacing, removing, and adding nodes.
+
+## Install
+
+```sh
+$ npm install --save @babel/traverse
+```
+
+## Usage
+
+We can use it alongside Babylon to traverse and update nodes:
+
+```js
+import * as babylon from "babylon";
+import traverse from "@babel/traverse";
+
+const code = `function square(n) {
+  return n * n;
+}`;
+
+const ast = babylon.parse(code);
+
+traverse(ast, {
+  enter(path) {
+    if (path.isIdentifier({ name: "n" })) {
+      path.node.name = "x";
+    }
+  }
+});
+```
+[:book: **Read the full docs here**](https://github.com/thejameskyle/babel-handbook/blob/master/translations/en/plugin-handbook.md#babel-traverse)
diff --git a/node_modules/@babel/traverse/lib/cache.js b/node_modules/@babel/traverse/lib/cache.js
new file mode 100644
index 00000000..89f20077
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/cache.js
@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clear = clear;
+exports.clearPath = clearPath;
+exports.clearScope = clearScope;
+exports.scope = exports.path = void 0;
+let path = new WeakMap();
+exports.path = path;
+let scope = new WeakMap();
+exports.scope = scope;
+
+function clear() {
+  clearPath();
+  clearScope();
+}
+
+function clearPath() {
+  exports.path = path = new WeakMap();
+}
+
+function clearScope() {
+  exports.scope = scope = new WeakMap();
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/context.js b/node_modules/@babel/traverse/lib/context.js
new file mode 100644
index 00000000..1ba35ddc
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/context.js
@@ -0,0 +1,188 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _path = _interopRequireDefault(require("./path"));
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const testing = process.env.NODE_ENV === "test";
+
+class TraversalContext {
+  constructor(scope, opts, state, parentPath) {
+    this.queue = null;
+    this.parentPath = parentPath;
+    this.scope = scope;
+    this.state = state;
+    this.opts = opts;
+  }
+
+  shouldVisit(node) {
+    const opts = this.opts;
+    if (opts.enter || opts.exit) return true;
+    if (opts[node.type]) return true;
+    const keys = t().VISITOR_KEYS[node.type];
+    if (!keys || !keys.length) return false;
+
+    for (var _iterator = keys, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i >= _iterator.length) break;
+        _ref = _iterator[_i++];
+      } else {
+        _i = _iterator.next();
+        if (_i.done) break;
+        _ref = _i.value;
+      }
+
+      const key = _ref;
+      if (node[key]) return true;
+    }
+
+    return false;
+  }
+
+  create(node, obj, key, listKey) {
+    return _path.default.get({
+      parentPath: this.parentPath,
+      parent: node,
+      container: obj,
+      key: key,
+      listKey
+    });
+  }
+
+  maybeQueue(path, notPriority) {
+    if (this.trap) {
+      throw new Error("Infinite cycle detected");
+    }
+
+    if (this.queue) {
+      if (notPriority) {
+        this.queue.push(path);
+      } else {
+        this.priorityQueue.push(path);
+      }
+    }
+  }
+
+  visitMultiple(container, parent, listKey) {
+    if (container.length === 0) return false;
+    const queue = [];
+
+    for (let key = 0; key < container.length; key++) {
+      const node = container[key];
+
+      if (node && this.shouldVisit(node)) {
+        queue.push(this.create(parent, container, key, listKey));
+      }
+    }
+
+    return this.visitQueue(queue);
+  }
+
+  visitSingle(node, key) {
+    if (this.shouldVisit(node[key])) {
+      return this.visitQueue([this.create(node, node, key)]);
+    } else {
+      return false;
+    }
+  }
+
+  visitQueue(queue) {
+    this.queue = queue;
+    this.priorityQueue = [];
+    const visited = [];
+    let stop = false;
+
+    for (var _iterator2 = queue, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+      var _ref2;
+
+      if (_isArray2) {
+        if (_i2 >= _iterator2.length) break;
+        _ref2 = _iterator2[_i2++];
+      } else {
+        _i2 = _iterator2.next();
+        if (_i2.done) break;
+        _ref2 = _i2.value;
+      }
+
+      const path = _ref2;
+      path.resync();
+
+      if (path.contexts.length === 0 || path.contexts[path.contexts.length - 1] !== this) {
+        path.pushContext(this);
+      }
+
+      if (path.key === null) continue;
+
+      if (testing && queue.length >= 10000) {
+        this.trap = true;
+      }
+
+      if (visited.indexOf(path.node) >= 0) continue;
+      visited.push(path.node);
+
+      if (path.visit()) {
+        stop = true;
+        break;
+      }
+
+      if (this.priorityQueue.length) {
+        stop = this.visitQueue(this.priorityQueue);
+        this.priorityQueue = [];
+        this.queue = queue;
+        if (stop) break;
+      }
+    }
+
+    for (var _iterator3 = queue, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
+      var _ref3;
+
+      if (_isArray3) {
+        if (_i3 >= _iterator3.length) break;
+        _ref3 = _iterator3[_i3++];
+      } else {
+        _i3 = _iterator3.next();
+        if (_i3.done) break;
+        _ref3 = _i3.value;
+      }
+
+      const path = _ref3;
+      path.popContext();
+    }
+
+    this.queue = null;
+    return stop;
+  }
+
+  visit(node, key) {
+    const nodes = node[key];
+    if (!nodes) return false;
+
+    if (Array.isArray(nodes)) {
+      return this.visitMultiple(nodes, node, key);
+    } else {
+      return this.visitSingle(node, key);
+    }
+  }
+
+}
+
+exports.default = TraversalContext;
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/hub.js b/node_modules/@babel/traverse/lib/hub.js
new file mode 100644
index 00000000..9f97f79c
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/hub.js
@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+class Hub {
+  constructor(file) {
+    this.file = file;
+  }
+
+}
+
+exports.default = Hub;
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/index.js b/node_modules/@babel/traverse/lib/index.js
new file mode 100644
index 00000000..d140f19f
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/index.js
@@ -0,0 +1,142 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = traverse;
+Object.defineProperty(exports, "NodePath", {
+  enumerable: true,
+  get: function get() {
+    return _path.default;
+  }
+});
+Object.defineProperty(exports, "Scope", {
+  enumerable: true,
+  get: function get() {
+    return _scope.default;
+  }
+});
+Object.defineProperty(exports, "Hub", {
+  enumerable: true,
+  get: function get() {
+    return _hub.default;
+  }
+});
+exports.visitors = void 0;
+
+var _context = _interopRequireDefault(require("./context"));
+
+var visitors = _interopRequireWildcard(require("./visitors"));
+
+exports.visitors = visitors;
+
+function _includes() {
+  const data = _interopRequireDefault(require("lodash/includes"));
+
+  _includes = function _includes() {
+    return data;
+  };
+
+  return data;
+}
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+var cache = _interopRequireWildcard(require("./cache"));
+
+var _path = _interopRequireDefault(require("./path"));
+
+var _scope = _interopRequireDefault(require("./scope"));
+
+var _hub = _interopRequireDefault(require("./hub"));
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function traverse(parent, opts, scope, state, parentPath) {
+  if (!parent) return;
+  if (!opts) opts = {};
+
+  if (!opts.noScope && !scope) {
+    if (parent.type !== "Program" && parent.type !== "File") {
+      throw new Error("You must pass a scope and parentPath unless traversing a Program/File. " + `Instead of that you tried to traverse a ${parent.type} node without ` + "passing scope and parentPath.");
+    }
+  }
+
+  visitors.explode(opts);
+  traverse.node(parent, opts, scope, state, parentPath);
+}
+
+traverse.visitors = visitors;
+traverse.verify = visitors.verify;
+traverse.explode = visitors.explode;
+
+traverse.cheap = function (node, enter) {
+  return t().traverseFast(node, enter);
+};
+
+traverse.node = function (node, opts, scope, state, parentPath, skipKeys) {
+  const keys = t().VISITOR_KEYS[node.type];
+  if (!keys) return;
+  const context = new _context.default(scope, opts, state, parentPath);
+
+  for (var _iterator = keys, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref;
+
+    if (_isArray) {
+      if (_i >= _iterator.length) break;
+      _ref = _iterator[_i++];
+    } else {
+      _i = _iterator.next();
+      if (_i.done) break;
+      _ref = _i.value;
+    }
+
+    const key = _ref;
+    if (skipKeys && skipKeys[key]) continue;
+    if (context.visit(node, key)) return;
+  }
+};
+
+traverse.clearNode = function (node, opts) {
+  t().removeProperties(node, opts);
+  cache.path.delete(node);
+};
+
+traverse.removeProperties = function (tree, opts) {
+  t().traverseFast(tree, traverse.clearNode, opts);
+  return tree;
+};
+
+function hasBlacklistedType(path, state) {
+  if (path.node.type === state.type) {
+    state.has = true;
+    path.stop();
+  }
+}
+
+traverse.hasType = function (tree, type, blacklistTypes) {
+  if ((0, _includes().default)(blacklistTypes, tree.type)) return false;
+  if (tree.type === type) return true;
+  const state = {
+    has: false,
+    type: type
+  };
+  traverse(tree, {
+    noScope: true,
+    blacklist: blacklistTypes,
+    enter: hasBlacklistedType
+  }, null, state);
+  return state.has;
+};
+
+traverse.cache = cache;
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/ancestry.js b/node_modules/@babel/traverse/lib/path/ancestry.js
new file mode 100644
index 00000000..f60b08e8
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/ancestry.js
@@ -0,0 +1,196 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findParent = findParent;
+exports.find = find;
+exports.getFunctionParent = getFunctionParent;
+exports.getStatementParent = getStatementParent;
+exports.getEarliestCommonAncestorFrom = getEarliestCommonAncestorFrom;
+exports.getDeepestCommonAncestorFrom = getDeepestCommonAncestorFrom;
+exports.getAncestry = getAncestry;
+exports.isAncestor = isAncestor;
+exports.isDescendant = isDescendant;
+exports.inType = inType;
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+var _index = _interopRequireDefault(require("./index"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function findParent(callback) {
+  let path = this;
+
+  while (path = path.parentPath) {
+    if (callback(path)) return path;
+  }
+
+  return null;
+}
+
+function find(callback) {
+  let path = this;
+
+  do {
+    if (callback(path)) return path;
+  } while (path = path.parentPath);
+
+  return null;
+}
+
+function getFunctionParent() {
+  return this.findParent(p => p.isFunction());
+}
+
+function getStatementParent() {
+  let path = this;
+
+  do {
+    if (!path.parentPath || Array.isArray(path.container) && path.isStatement()) {
+      break;
+    } else {
+      path = path.parentPath;
+    }
+  } while (path);
+
+  if (path && (path.isProgram() || path.isFile())) {
+    throw new Error("File/Program node, we can't possibly find a statement parent to this");
+  }
+
+  return path;
+}
+
+function getEarliestCommonAncestorFrom(paths) {
+  return this.getDeepestCommonAncestorFrom(paths, function (deepest, i, ancestries) {
+    let earliest;
+    const keys = t().VISITOR_KEYS[deepest.type];
+    var _arr = ancestries;
+
+    for (var _i = 0; _i < _arr.length; _i++) {
+      const ancestry = _arr[_i];
+      const path = ancestry[i + 1];
+
+      if (!earliest) {
+        earliest = path;
+        continue;
+      }
+
+      if (path.listKey && earliest.listKey === path.listKey) {
+        if (path.key < earliest.key) {
+          earliest = path;
+          continue;
+        }
+      }
+
+      const earliestKeyIndex = keys.indexOf(earliest.parentKey);
+      const currentKeyIndex = keys.indexOf(path.parentKey);
+
+      if (earliestKeyIndex > currentKeyIndex) {
+        earliest = path;
+      }
+    }
+
+    return earliest;
+  });
+}
+
+function getDeepestCommonAncestorFrom(paths, filter) {
+  if (!paths.length) {
+    return this;
+  }
+
+  if (paths.length === 1) {
+    return paths[0];
+  }
+
+  let minDepth = Infinity;
+  let lastCommonIndex, lastCommon;
+  const ancestries = paths.map(path => {
+    const ancestry = [];
+
+    do {
+      ancestry.unshift(path);
+    } while ((path = path.parentPath) && path !== this);
+
+    if (ancestry.length < minDepth) {
+      minDepth = ancestry.length;
+    }
+
+    return ancestry;
+  });
+  const first = ancestries[0];
+
+  depthLoop: for (let i = 0; i < minDepth; i++) {
+    const shouldMatch = first[i];
+    var _arr2 = ancestries;
+
+    for (var _i2 = 0; _i2 < _arr2.length; _i2++) {
+      const ancestry = _arr2[_i2];
+
+      if (ancestry[i] !== shouldMatch) {
+        break depthLoop;
+      }
+    }
+
+    lastCommonIndex = i;
+    lastCommon = shouldMatch;
+  }
+
+  if (lastCommon) {
+    if (filter) {
+      return filter(lastCommon, lastCommonIndex, ancestries);
+    } else {
+      return lastCommon;
+    }
+  } else {
+    throw new Error("Couldn't find intersection");
+  }
+}
+
+function getAncestry() {
+  let path = this;
+  const paths = [];
+
+  do {
+    paths.push(path);
+  } while (path = path.parentPath);
+
+  return paths;
+}
+
+function isAncestor(maybeDescendant) {
+  return maybeDescendant.isDescendant(this);
+}
+
+function isDescendant(maybeAncestor) {
+  return !!this.findParent(parent => parent === maybeAncestor);
+}
+
+function inType() {
+  let path = this;
+
+  while (path) {
+    var _arr3 = arguments;
+
+    for (var _i3 = 0; _i3 < _arr3.length; _i3++) {
+      const type = _arr3[_i3];
+      if (path.node.type === type) return true;
+    }
+
+    path = path.parentPath;
+  }
+
+  return false;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/comments.js b/node_modules/@babel/traverse/lib/path/comments.js
new file mode 100644
index 00000000..da5f0356
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/comments.js
@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.shareCommentsWithSiblings = shareCommentsWithSiblings;
+exports.addComment = addComment;
+exports.addComments = addComments;
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function shareCommentsWithSiblings() {
+  if (typeof this.key === "string") return;
+  const node = this.node;
+  if (!node) return;
+  const trailing = node.trailingComments;
+  const leading = node.leadingComments;
+  if (!trailing && !leading) return;
+  const prev = this.getSibling(this.key - 1);
+  const next = this.getSibling(this.key + 1);
+  const hasPrev = Boolean(prev.node);
+  const hasNext = Boolean(next.node);
+
+  if (hasPrev && hasNext) {} else if (hasPrev) {
+    prev.addComments("trailing", trailing);
+  } else if (hasNext) {
+    next.addComments("leading", leading);
+  }
+}
+
+function addComment(type, content, line) {
+  t().addComment(this.node, type, content, line);
+}
+
+function addComments(type, comments) {
+  t().addComments(this.node, type, comments);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/context.js b/node_modules/@babel/traverse/lib/path/context.js
new file mode 100644
index 00000000..72bfac1e
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/context.js
@@ -0,0 +1,269 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.call = call;
+exports._call = _call;
+exports.isBlacklisted = isBlacklisted;
+exports.visit = visit;
+exports.skip = skip;
+exports.skipKey = skipKey;
+exports.stop = stop;
+exports.setScope = setScope;
+exports.setContext = setContext;
+exports.resync = resync;
+exports._resyncParent = _resyncParent;
+exports._resyncKey = _resyncKey;
+exports._resyncList = _resyncList;
+exports._resyncRemoved = _resyncRemoved;
+exports.popContext = popContext;
+exports.pushContext = pushContext;
+exports.setup = setup;
+exports.setKey = setKey;
+exports.requeue = requeue;
+exports._getQueueContexts = _getQueueContexts;
+
+var _index = _interopRequireDefault(require("../index"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function call(key) {
+  const opts = this.opts;
+  this.debug(key);
+
+  if (this.node) {
+    if (this._call(opts[key])) return true;
+  }
+
+  if (this.node) {
+    return this._call(opts[this.node.type] && opts[this.node.type][key]);
+  }
+
+  return false;
+}
+
+function _call(fns) {
+  if (!fns) return false;
+
+  for (var _iterator = fns, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref;
+
+    if (_isArray) {
+      if (_i >= _iterator.length) break;
+      _ref = _iterator[_i++];
+    } else {
+      _i = _iterator.next();
+      if (_i.done) break;
+      _ref = _i.value;
+    }
+
+    const fn = _ref;
+    if (!fn) continue;
+    const node = this.node;
+    if (!node) return true;
+    const ret = fn.call(this.state, this, this.state);
+
+    if (ret && typeof ret === "object" && typeof ret.then === "function") {
+      throw new Error(`You appear to be using a plugin with an async traversal visitor, ` + `which your current version of Babel does not support.` + `If you're using a published plugin, you may need to upgrade ` + `your @babel/core version.`);
+    }
+
+    if (ret) {
+      throw new Error(`Unexpected return value from visitor method ${fn}`);
+    }
+
+    if (this.node !== node) return true;
+    if (this.shouldStop || this.shouldSkip || this.removed) return true;
+  }
+
+  return false;
+}
+
+function isBlacklisted() {
+  const blacklist = this.opts.blacklist;
+  return blacklist && blacklist.indexOf(this.node.type) > -1;
+}
+
+function visit() {
+  if (!this.node) {
+    return false;
+  }
+
+  if (this.isBlacklisted()) {
+    return false;
+  }
+
+  if (this.opts.shouldSkip && this.opts.shouldSkip(this)) {
+    return false;
+  }
+
+  if (this.call("enter") || this.shouldSkip) {
+    this.debug("Skip...");
+    return this.shouldStop;
+  }
+
+  this.debug("Recursing into...");
+
+  _index.default.node(this.node, this.opts, this.scope, this.state, this, this.skipKeys);
+
+  this.call("exit");
+  return this.shouldStop;
+}
+
+function skip() {
+  this.shouldSkip = true;
+}
+
+function skipKey(key) {
+  this.skipKeys[key] = true;
+}
+
+function stop() {
+  this.shouldStop = true;
+  this.shouldSkip = true;
+}
+
+function setScope() {
+  if (this.opts && this.opts.noScope) return;
+  let path = this.parentPath;
+  let target;
+
+  while (path && !target) {
+    if (path.opts && path.opts.noScope) return;
+    target = path.scope;
+    path = path.parentPath;
+  }
+
+  this.scope = this.getScope(target);
+  if (this.scope) this.scope.init();
+}
+
+function setContext(context) {
+  this.shouldSkip = false;
+  this.shouldStop = false;
+  this.removed = false;
+  this.skipKeys = {};
+
+  if (context) {
+    this.context = context;
+    this.state = context.state;
+    this.opts = context.opts;
+  }
+
+  this.setScope();
+  return this;
+}
+
+function resync() {
+  if (this.removed) return;
+
+  this._resyncParent();
+
+  this._resyncList();
+
+  this._resyncKey();
+}
+
+function _resyncParent() {
+  if (this.parentPath) {
+    this.parent = this.parentPath.node;
+  }
+}
+
+function _resyncKey() {
+  if (!this.container) return;
+  if (this.node === this.container[this.key]) return;
+
+  if (Array.isArray(this.container)) {
+    for (let i = 0; i < this.container.length; i++) {
+      if (this.container[i] === this.node) {
+        return this.setKey(i);
+      }
+    }
+  } else {
+    for (const key in this.container) {
+      if (this.container[key] === this.node) {
+        return this.setKey(key);
+      }
+    }
+  }
+
+  this.key = null;
+}
+
+function _resyncList() {
+  if (!this.parent || !this.inList) return;
+  const newContainer = this.parent[this.listKey];
+  if (this.container === newContainer) return;
+  this.container = newContainer || null;
+}
+
+function _resyncRemoved() {
+  if (this.key == null || !this.container || this.container[this.key] !== this.node) {
+    this._markRemoved();
+  }
+}
+
+function popContext() {
+  this.contexts.pop();
+
+  if (this.contexts.length > 0) {
+    this.setContext(this.contexts[this.contexts.length - 1]);
+  } else {
+    this.setContext(undefined);
+  }
+}
+
+function pushContext(context) {
+  this.contexts.push(context);
+  this.setContext(context);
+}
+
+function setup(parentPath, container, listKey, key) {
+  this.inList = !!listKey;
+  this.listKey = listKey;
+  this.parentKey = listKey || key;
+  this.container = container;
+  this.parentPath = parentPath || this.parentPath;
+  this.setKey(key);
+}
+
+function setKey(key) {
+  this.key = key;
+  this.node = this.container[this.key];
+  this.type = this.node && this.node.type;
+}
+
+function requeue(pathToQueue = this) {
+  if (pathToQueue.removed) return;
+  const contexts = this.contexts;
+
+  for (var _iterator2 = contexts, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+    var _ref2;
+
+    if (_isArray2) {
+      if (_i2 >= _iterator2.length) break;
+      _ref2 = _iterator2[_i2++];
+    } else {
+      _i2 = _iterator2.next();
+      if (_i2.done) break;
+      _ref2 = _i2.value;
+    }
+
+    const context = _ref2;
+    context.maybeQueue(pathToQueue);
+  }
+}
+
+function _getQueueContexts() {
+  let path = this;
+  let contexts = this.contexts;
+
+  while (!contexts.length) {
+    path = path.parentPath;
+    if (!path) break;
+    contexts = path.contexts;
+  }
+
+  return contexts;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/conversion.js b/node_modules/@babel/traverse/lib/path/conversion.js
new file mode 100644
index 00000000..a449ce3f
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/conversion.js
@@ -0,0 +1,465 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toComputedKey = toComputedKey;
+exports.ensureBlock = ensureBlock;
+exports.arrowFunctionToShadowed = arrowFunctionToShadowed;
+exports.unwrapFunctionEnvironment = unwrapFunctionEnvironment;
+exports.arrowFunctionToExpression = arrowFunctionToExpression;
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperFunctionName() {
+  const data = _interopRequireDefault(require("@babel/helper-function-name"));
+
+  _helperFunctionName = function _helperFunctionName() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function toComputedKey() {
+  const node = this.node;
+  let key;
+
+  if (this.isMemberExpression()) {
+    key = node.property;
+  } else if (this.isProperty() || this.isMethod()) {
+    key = node.key;
+  } else {
+    throw new ReferenceError("todo");
+  }
+
+  if (!node.computed) {
+    if (t().isIdentifier(key)) key = t().stringLiteral(key.name);
+  }
+
+  return key;
+}
+
+function ensureBlock() {
+  const body = this.get("body");
+  const bodyNode = body.node;
+
+  if (Array.isArray(body)) {
+    throw new Error("Can't convert array path to a block statement");
+  }
+
+  if (!bodyNode) {
+    throw new Error("Can't convert node without a body");
+  }
+
+  if (body.isBlockStatement()) {
+    return bodyNode;
+  }
+
+  const statements = [];
+  let stringPath = "body";
+  let key;
+  let listKey;
+
+  if (body.isStatement()) {
+    listKey = "body";
+    key = 0;
+    statements.push(body.node);
+  } else {
+    stringPath += ".body.0";
+
+    if (this.isFunction()) {
+      key = "argument";
+      statements.push(t().returnStatement(body.node));
+    } else {
+      key = "expression";
+      statements.push(t().expressionStatement(body.node));
+    }
+  }
+
+  this.node.body = t().blockStatement(statements);
+  const parentPath = this.get(stringPath);
+  body.setup(parentPath, listKey ? parentPath.node[listKey] : parentPath.node, listKey, key);
+  return this.node;
+}
+
+function arrowFunctionToShadowed() {
+  if (!this.isArrowFunctionExpression()) return;
+  this.arrowFunctionToExpression();
+}
+
+function unwrapFunctionEnvironment() {
+  if (!this.isArrowFunctionExpression() && !this.isFunctionExpression() && !this.isFunctionDeclaration()) {
+    throw this.buildCodeFrameError("Can only unwrap the environment of a function.");
+  }
+
+  hoistFunctionEnvironment(this);
+}
+
+function arrowFunctionToExpression({
+  allowInsertArrow = true,
+  specCompliant = false
+} = {}) {
+  if (!this.isArrowFunctionExpression()) {
+    throw this.buildCodeFrameError("Cannot convert non-arrow function to a function expression.");
+  }
+
+  const thisBinding = hoistFunctionEnvironment(this, specCompliant, allowInsertArrow);
+  this.ensureBlock();
+  this.node.type = "FunctionExpression";
+
+  if (specCompliant) {
+    const checkBinding = thisBinding ? null : this.parentPath.scope.generateUidIdentifier("arrowCheckId");
+
+    if (checkBinding) {
+      this.parentPath.scope.push({
+        id: checkBinding,
+        init: t().objectExpression([])
+      });
+    }
+
+    this.get("body").unshiftContainer("body", t().expressionStatement(t().callExpression(this.hub.file.addHelper("newArrowCheck"), [t().thisExpression(), checkBinding ? t().identifier(checkBinding.name) : t().identifier(thisBinding)])));
+    this.replaceWith(t().callExpression(t().memberExpression((0, _helperFunctionName().default)(this, true) || this.node, t().identifier("bind")), [checkBinding ? t().identifier(checkBinding.name) : t().thisExpression()]));
+  }
+}
+
+function hoistFunctionEnvironment(fnPath, specCompliant = false, allowInsertArrow = true) {
+  const thisEnvFn = fnPath.findParent(p => {
+    return p.isFunction() && !p.isArrowFunctionExpression() || p.isProgram() || p.isClassProperty({
+      static: false
+    });
+  });
+  const inConstructor = thisEnvFn && thisEnvFn.node.kind === "constructor";
+
+  if (thisEnvFn.isClassProperty()) {
+    throw fnPath.buildCodeFrameError("Unable to transform arrow inside class property");
+  }
+
+  const _getScopeInformation = getScopeInformation(fnPath),
+        thisPaths = _getScopeInformation.thisPaths,
+        argumentsPaths = _getScopeInformation.argumentsPaths,
+        newTargetPaths = _getScopeInformation.newTargetPaths,
+        superProps = _getScopeInformation.superProps,
+        superCalls = _getScopeInformation.superCalls;
+
+  if (inConstructor && superCalls.length > 0) {
+    if (!allowInsertArrow) {
+      throw superCalls[0].buildCodeFrameError("Unable to handle nested super() usage in arrow");
+    }
+
+    const allSuperCalls = [];
+    thisEnvFn.traverse({
+      Function(child) {
+        if (child.isArrowFunctionExpression()) return;
+        child.skip();
+      },
+
+      ClassProperty(child) {
+        if (child.node.static) return;
+        child.skip();
+      },
+
+      CallExpression(child) {
+        if (!child.get("callee").isSuper()) return;
+        allSuperCalls.push(child);
+      }
+
+    });
+    const superBinding = getSuperBinding(thisEnvFn);
+    allSuperCalls.forEach(superCall => {
+      const callee = t().identifier(superBinding);
+      callee.loc = superCall.node.callee.loc;
+      superCall.get("callee").replaceWith(callee);
+    });
+  }
+
+  let thisBinding;
+
+  if (thisPaths.length > 0 || specCompliant) {
+    thisBinding = getThisBinding(thisEnvFn, inConstructor);
+
+    if (!specCompliant || inConstructor && hasSuperClass(thisEnvFn)) {
+      thisPaths.forEach(thisChild => {
+        const thisRef = thisChild.isJSX() ? t().jsxIdentifier(thisBinding) : t().identifier(thisBinding);
+        thisRef.loc = thisChild.node.loc;
+        thisChild.replaceWith(thisRef);
+      });
+      if (specCompliant) thisBinding = null;
+    }
+  }
+
+  if (argumentsPaths.length > 0) {
+    const argumentsBinding = getBinding(thisEnvFn, "arguments", () => t().identifier("arguments"));
+    argumentsPaths.forEach(argumentsChild => {
+      const argsRef = t().identifier(argumentsBinding);
+      argsRef.loc = argumentsChild.node.loc;
+      argumentsChild.replaceWith(argsRef);
+    });
+  }
+
+  if (newTargetPaths.length > 0) {
+    const newTargetBinding = getBinding(thisEnvFn, "newtarget", () => t().metaProperty(t().identifier("new"), t().identifier("target")));
+    newTargetPaths.forEach(targetChild => {
+      const targetRef = t().identifier(newTargetBinding);
+      targetRef.loc = targetChild.node.loc;
+      targetChild.replaceWith(targetRef);
+    });
+  }
+
+  if (superProps.length > 0) {
+    if (!allowInsertArrow) {
+      throw superProps[0].buildCodeFrameError("Unable to handle nested super.prop usage");
+    }
+
+    const flatSuperProps = superProps.reduce((acc, superProp) => acc.concat(standardizeSuperProperty(superProp)), []);
+    flatSuperProps.forEach(superProp => {
+      const key = superProp.node.computed ? "" : superProp.get("property").node.name;
+
+      if (superProp.parentPath.isCallExpression({
+        callee: superProp.node
+      })) {
+        const superBinding = getSuperPropCallBinding(thisEnvFn, key);
+
+        if (superProp.node.computed) {
+          const prop = superProp.get("property").node;
+          superProp.replaceWith(t().identifier(superBinding));
+          superProp.parentPath.node.arguments.unshift(prop);
+        } else {
+          superProp.replaceWith(t().identifier(superBinding));
+        }
+      } else {
+        const isAssignment = superProp.parentPath.isAssignmentExpression({
+          left: superProp.node
+        });
+        const superBinding = getSuperPropBinding(thisEnvFn, isAssignment, key);
+        const args = [];
+
+        if (superProp.node.computed) {
+          args.push(superProp.get("property").node);
+        }
+
+        if (isAssignment) {
+          const value = superProp.parentPath.node.right;
+          args.push(value);
+          superProp.parentPath.replaceWith(t().callExpression(t().identifier(superBinding), args));
+        } else {
+          superProp.replaceWith(t().callExpression(t().identifier(superBinding), args));
+        }
+      }
+    });
+  }
+
+  return thisBinding;
+}
+
+function standardizeSuperProperty(superProp) {
+  if (superProp.parentPath.isAssignmentExpression() && superProp.parentPath.node.operator !== "=") {
+    const assignmentPath = superProp.parentPath;
+    const op = assignmentPath.node.operator.slice(0, -1);
+    const value = assignmentPath.node.right;
+    assignmentPath.node.operator = "=";
+
+    if (superProp.node.computed) {
+      const tmp = superProp.scope.generateDeclaredUidIdentifier("tmp");
+      assignmentPath.get("left").replaceWith(t().memberExpression(superProp.node.object, t().assignmentExpression("=", tmp, superProp.node.property), true));
+      assignmentPath.get("right").replaceWith(t().binaryExpression(op, t().memberExpression(superProp.node.object, t().identifier(tmp.name), true), value));
+    } else {
+      assignmentPath.get("left").replaceWith(t().memberExpression(superProp.node.object, superProp.node.property));
+      assignmentPath.get("right").replaceWith(t().binaryExpression(op, t().memberExpression(superProp.node.object, t().identifier(superProp.node.property.name)), value));
+    }
+
+    return [assignmentPath.get("left"), assignmentPath.get("right").get("left")];
+  } else if (superProp.parentPath.isUpdateExpression()) {
+    const updateExpr = superProp.parentPath;
+    const tmp = superProp.scope.generateDeclaredUidIdentifier("tmp");
+    const computedKey = superProp.node.computed ? superProp.scope.generateDeclaredUidIdentifier("prop") : null;
+    const parts = [t().assignmentExpression("=", tmp, t().memberExpression(superProp.node.object, computedKey ? t().assignmentExpression("=", computedKey, superProp.node.property) : superProp.node.property, superProp.node.computed)), t().assignmentExpression("=", t().memberExpression(superProp.node.object, computedKey ? t().identifier(computedKey.name) : superProp.node.property, superProp.node.computed), t().binaryExpression("+", t().identifier(tmp.name), t().numericLiteral(1)))];
+
+    if (!superProp.parentPath.node.prefix) {
+      parts.push(t().identifier(tmp.name));
+    }
+
+    updateExpr.replaceWith(t().sequenceExpression(parts));
+    const left = updateExpr.get("expressions.0.right");
+    const right = updateExpr.get("expressions.1.left");
+    return [left, right];
+  }
+
+  return [superProp];
+}
+
+function hasSuperClass(thisEnvFn) {
+  return thisEnvFn.isClassMethod() && !!thisEnvFn.parentPath.parentPath.node.superClass;
+}
+
+function getThisBinding(thisEnvFn, inConstructor) {
+  return getBinding(thisEnvFn, "this", thisBinding => {
+    if (!inConstructor || !hasSuperClass(thisEnvFn)) return t().thisExpression();
+    const supers = new WeakSet();
+    thisEnvFn.traverse({
+      Function(child) {
+        if (child.isArrowFunctionExpression()) return;
+        child.skip();
+      },
+
+      ClassProperty(child) {
+        if (child.node.static) return;
+        child.skip();
+      },
+
+      CallExpression(child) {
+        if (!child.get("callee").isSuper()) return;
+        if (supers.has(child.node)) return;
+        supers.add(child.node);
+        child.replaceWith(t().assignmentExpression("=", t().identifier(thisBinding), child.node));
+      }
+
+    });
+  });
+}
+
+function getSuperBinding(thisEnvFn) {
+  return getBinding(thisEnvFn, "supercall", () => {
+    const argsBinding = thisEnvFn.scope.generateUidIdentifier("args");
+    return t().arrowFunctionExpression([t().restElement(argsBinding)], t().callExpression(t().super(), [t().spreadElement(t().identifier(argsBinding.name))]));
+  });
+}
+
+function getSuperPropCallBinding(thisEnvFn, propName) {
+  return getBinding(thisEnvFn, `superprop_call:${propName || ""}`, () => {
+    const argsBinding = thisEnvFn.scope.generateUidIdentifier("args");
+    const argsList = [t().restElement(argsBinding)];
+    let fnBody;
+
+    if (propName) {
+      fnBody = t().callExpression(t().memberExpression(t().super(), t().identifier(propName)), [t().spreadElement(t().identifier(argsBinding.name))]);
+    } else {
+      const method = thisEnvFn.scope.generateUidIdentifier("prop");
+      argsList.unshift(method);
+      fnBody = t().callExpression(t().memberExpression(t().super(), t().identifier(method.name), true), [t().spreadElement(t().identifier(argsBinding.name))]);
+    }
+
+    return t().arrowFunctionExpression(argsList, fnBody);
+  });
+}
+
+function getSuperPropBinding(thisEnvFn, isAssignment, propName) {
+  const op = isAssignment ? "set" : "get";
+  return getBinding(thisEnvFn, `superprop_${op}:${propName || ""}`, () => {
+    const argsList = [];
+    let fnBody;
+
+    if (propName) {
+      fnBody = t().memberExpression(t().super(), t().identifier(propName));
+    } else {
+      const method = thisEnvFn.scope.generateUidIdentifier("prop");
+      argsList.unshift(method);
+      fnBody = t().memberExpression(t().super(), t().identifier(method.name), true);
+    }
+
+    if (isAssignment) {
+      const valueIdent = thisEnvFn.scope.generateUidIdentifier("value");
+      argsList.push(valueIdent);
+      fnBody = t().assignmentExpression("=", fnBody, t().identifier(valueIdent.name));
+    }
+
+    return t().arrowFunctionExpression(argsList, fnBody);
+  });
+}
+
+function getBinding(thisEnvFn, key, init) {
+  const cacheKey = "binding:" + key;
+  let data = thisEnvFn.getData(cacheKey);
+
+  if (!data) {
+    const id = thisEnvFn.scope.generateUidIdentifier(key);
+    data = id.name;
+    thisEnvFn.setData(cacheKey, data);
+    thisEnvFn.scope.push({
+      id: id,
+      init: init(data)
+    });
+  }
+
+  return data;
+}
+
+function getScopeInformation(fnPath) {
+  const thisPaths = [];
+  const argumentsPaths = [];
+  const newTargetPaths = [];
+  const superProps = [];
+  const superCalls = [];
+  fnPath.traverse({
+    ClassProperty(child) {
+      if (child.node.static) return;
+      child.skip();
+    },
+
+    Function(child) {
+      if (child.isArrowFunctionExpression()) return;
+      child.skip();
+    },
+
+    ThisExpression(child) {
+      thisPaths.push(child);
+    },
+
+    JSXIdentifier(child) {
+      if (child.node.name !== "this") return;
+
+      if (!child.parentPath.isJSXMemberExpression({
+        object: child.node
+      }) && !child.parentPath.isJSXOpeningElement({
+        name: child.node
+      })) {
+        return;
+      }
+
+      thisPaths.push(child);
+    },
+
+    CallExpression(child) {
+      if (child.get("callee").isSuper()) superCalls.push(child);
+    },
+
+    MemberExpression(child) {
+      if (child.get("object").isSuper()) superProps.push(child);
+    },
+
+    ReferencedIdentifier(child) {
+      if (child.node.name !== "arguments") return;
+      argumentsPaths.push(child);
+    },
+
+    MetaProperty(child) {
+      if (!child.get("meta").isIdentifier({
+        name: "new"
+      })) return;
+      if (!child.get("property").isIdentifier({
+        name: "target"
+      })) return;
+      newTargetPaths.push(child);
+    }
+
+  });
+  return {
+    thisPaths,
+    argumentsPaths,
+    newTargetPaths,
+    superProps,
+    superCalls
+  };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/evaluation.js b/node_modules/@babel/traverse/lib/path/evaluation.js
new file mode 100644
index 00000000..0f2d04c9
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/evaluation.js
@@ -0,0 +1,439 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.evaluateTruthy = evaluateTruthy;
+exports.evaluate = evaluate;
+const VALID_CALLEES = ["String", "Number", "Math"];
+const INVALID_METHODS = ["random"];
+
+function evaluateTruthy() {
+  const res = this.evaluate();
+  if (res.confident) return !!res.value;
+}
+
+function deopt(path, state) {
+  if (!state.confident) return;
+  state.deoptPath = path;
+  state.confident = false;
+}
+
+function evaluateCached(path, state) {
+  const node = path.node;
+  const seen = state.seen;
+
+  if (seen.has(node)) {
+    const existing = seen.get(node);
+
+    if (existing.resolved) {
+      return existing.value;
+    } else {
+      deopt(path, state);
+      return;
+    }
+  } else {
+    const item = {
+      resolved: false
+    };
+    seen.set(node, item);
+
+    const val = _evaluate(path, state);
+
+    if (state.confident) {
+      item.resolved = true;
+      item.value = val;
+    }
+
+    return val;
+  }
+}
+
+function _evaluate(path, state) {
+  if (!state.confident) return;
+  const node = path.node;
+
+  if (path.isSequenceExpression()) {
+    const exprs = path.get("expressions");
+    return evaluateCached(exprs[exprs.length - 1], state);
+  }
+
+  if (path.isStringLiteral() || path.isNumericLiteral() || path.isBooleanLiteral()) {
+    return node.value;
+  }
+
+  if (path.isNullLiteral()) {
+    return null;
+  }
+
+  if (path.isTemplateLiteral()) {
+    return evaluateQuasis(path, node.quasis, state);
+  }
+
+  if (path.isTaggedTemplateExpression() && path.get("tag").isMemberExpression()) {
+    const object = path.get("tag.object");
+    const name = object.node.name;
+    const property = path.get("tag.property");
+
+    if (object.isIdentifier() && name === "String" && !path.scope.getBinding(name, true) && property.isIdentifier && property.node.name === "raw") {
+      return evaluateQuasis(path, node.quasi.quasis, state, true);
+    }
+  }
+
+  if (path.isConditionalExpression()) {
+    const testResult = evaluateCached(path.get("test"), state);
+    if (!state.confident) return;
+
+    if (testResult) {
+      return evaluateCached(path.get("consequent"), state);
+    } else {
+      return evaluateCached(path.get("alternate"), state);
+    }
+  }
+
+  if (path.isExpressionWrapper()) {
+    return evaluateCached(path.get("expression"), state);
+  }
+
+  if (path.isMemberExpression() && !path.parentPath.isCallExpression({
+    callee: node
+  })) {
+    const property = path.get("property");
+    const object = path.get("object");
+
+    if (object.isLiteral() && property.isIdentifier()) {
+      const value = object.node.value;
+      const type = typeof value;
+
+      if (type === "number" || type === "string") {
+        return value[property.node.name];
+      }
+    }
+  }
+
+  if (path.isReferencedIdentifier()) {
+    const binding = path.scope.getBinding(node.name);
+
+    if (binding && binding.constantViolations.length > 0) {
+      return deopt(binding.path, state);
+    }
+
+    if (binding && path.node.start < binding.path.node.end) {
+      return deopt(binding.path, state);
+    }
+
+    if (binding && binding.hasValue) {
+      return binding.value;
+    } else {
+      if (node.name === "undefined") {
+        return binding ? deopt(binding.path, state) : undefined;
+      } else if (node.name === "Infinity") {
+        return binding ? deopt(binding.path, state) : Infinity;
+      } else if (node.name === "NaN") {
+        return binding ? deopt(binding.path, state) : NaN;
+      }
+
+      const resolved = path.resolve();
+
+      if (resolved === path) {
+        return deopt(path, state);
+      } else {
+        return evaluateCached(resolved, state);
+      }
+    }
+  }
+
+  if (path.isUnaryExpression({
+    prefix: true
+  })) {
+    if (node.operator === "void") {
+      return undefined;
+    }
+
+    const argument = path.get("argument");
+
+    if (node.operator === "typeof" && (argument.isFunction() || argument.isClass())) {
+      return "function";
+    }
+
+    const arg = evaluateCached(argument, state);
+    if (!state.confident) return;
+
+    switch (node.operator) {
+      case "!":
+        return !arg;
+
+      case "+":
+        return +arg;
+
+      case "-":
+        return -arg;
+
+      case "~":
+        return ~arg;
+
+      case "typeof":
+        return typeof arg;
+    }
+  }
+
+  if (path.isArrayExpression()) {
+    const arr = [];
+    const elems = path.get("elements");
+
+    for (var _iterator = elems, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i >= _iterator.length) break;
+        _ref = _iterator[_i++];
+      } else {
+        _i = _iterator.next();
+        if (_i.done) break;
+        _ref = _i.value;
+      }
+
+      const elem = _ref;
+      const elemValue = elem.evaluate();
+
+      if (elemValue.confident) {
+        arr.push(elemValue.value);
+      } else {
+        return deopt(elem, state);
+      }
+    }
+
+    return arr;
+  }
+
+  if (path.isObjectExpression()) {
+    const obj = {};
+    const props = path.get("properties");
+
+    for (var _iterator2 = props, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+      var _ref2;
+
+      if (_isArray2) {
+        if (_i2 >= _iterator2.length) break;
+        _ref2 = _iterator2[_i2++];
+      } else {
+        _i2 = _iterator2.next();
+        if (_i2.done) break;
+        _ref2 = _i2.value;
+      }
+
+      const prop = _ref2;
+
+      if (prop.isObjectMethod() || prop.isSpreadElement()) {
+        return deopt(prop, state);
+      }
+
+      const keyPath = prop.get("key");
+      let key = keyPath;
+
+      if (prop.node.computed) {
+        key = key.evaluate();
+
+        if (!key.confident) {
+          return deopt(keyPath, state);
+        }
+
+        key = key.value;
+      } else if (key.isIdentifier()) {
+        key = key.node.name;
+      } else {
+        key = key.node.value;
+      }
+
+      const valuePath = prop.get("value");
+      let value = valuePath.evaluate();
+
+      if (!value.confident) {
+        return deopt(valuePath, state);
+      }
+
+      value = value.value;
+      obj[key] = value;
+    }
+
+    return obj;
+  }
+
+  if (path.isLogicalExpression()) {
+    const wasConfident = state.confident;
+    const left = evaluateCached(path.get("left"), state);
+    const leftConfident = state.confident;
+    state.confident = wasConfident;
+    const right = evaluateCached(path.get("right"), state);
+    const rightConfident = state.confident;
+    state.confident = leftConfident && rightConfident;
+
+    switch (node.operator) {
+      case "||":
+        if (left && leftConfident) {
+          state.confident = true;
+          return left;
+        }
+
+        if (!state.confident) return;
+        return left || right;
+
+      case "&&":
+        if (!left && leftConfident || !right && rightConfident) {
+          state.confident = true;
+        }
+
+        if (!state.confident) return;
+        return left && right;
+    }
+  }
+
+  if (path.isBinaryExpression()) {
+    const left = evaluateCached(path.get("left"), state);
+    if (!state.confident) return;
+    const right = evaluateCached(path.get("right"), state);
+    if (!state.confident) return;
+
+    switch (node.operator) {
+      case "-":
+        return left - right;
+
+      case "+":
+        return left + right;
+
+      case "/":
+        return left / right;
+
+      case "*":
+        return left * right;
+
+      case "%":
+        return left % right;
+
+      case "**":
+        return Math.pow(left, right);
+
+      case "<":
+        return left < right;
+
+      case ">":
+        return left > right;
+
+      case "<=":
+        return left <= right;
+
+      case ">=":
+        return left >= right;
+
+      case "==":
+        return left == right;
+
+      case "!=":
+        return left != right;
+
+      case "===":
+        return left === right;
+
+      case "!==":
+        return left !== right;
+
+      case "|":
+        return left | right;
+
+      case "&":
+        return left & right;
+
+      case "^":
+        return left ^ right;
+
+      case "<<":
+        return left << right;
+
+      case ">>":
+        return left >> right;
+
+      case ">>>":
+        return left >>> right;
+    }
+  }
+
+  if (path.isCallExpression()) {
+    const callee = path.get("callee");
+    let context;
+    let func;
+
+    if (callee.isIdentifier() && !path.scope.getBinding(callee.node.name, true) && VALID_CALLEES.indexOf(callee.node.name) >= 0) {
+      func = global[node.callee.name];
+    }
+
+    if (callee.isMemberExpression()) {
+      const object = callee.get("object");
+      const property = callee.get("property");
+
+      if (object.isIdentifier() && property.isIdentifier() && VALID_CALLEES.indexOf(object.node.name) >= 0 && INVALID_METHODS.indexOf(property.node.name) < 0) {
+        context = global[object.node.name];
+        func = context[property.node.name];
+      }
+
+      if (object.isLiteral() && property.isIdentifier()) {
+        const type = typeof object.node.value;
+
+        if (type === "string" || type === "number") {
+          context = object.node.value;
+          func = context[property.node.name];
+        }
+      }
+    }
+
+    if (func) {
+      const args = path.get("arguments").map(arg => evaluateCached(arg, state));
+      if (!state.confident) return;
+      return func.apply(context, args);
+    }
+  }
+
+  deopt(path, state);
+}
+
+function evaluateQuasis(path, quasis, state, raw = false) {
+  let str = "";
+  let i = 0;
+  const exprs = path.get("expressions");
+
+  for (var _iterator3 = quasis, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
+    var _ref3;
+
+    if (_isArray3) {
+      if (_i3 >= _iterator3.length) break;
+      _ref3 = _iterator3[_i3++];
+    } else {
+      _i3 = _iterator3.next();
+      if (_i3.done) break;
+      _ref3 = _i3.value;
+    }
+
+    const elem = _ref3;
+    if (!state.confident) break;
+    str += raw ? elem.value.raw : elem.value.cooked;
+    const expr = exprs[i++];
+    if (expr) str += String(evaluateCached(expr, state));
+  }
+
+  if (!state.confident) return;
+  return str;
+}
+
+function evaluate() {
+  const state = {
+    confident: true,
+    deoptPath: null,
+    seen: new Map()
+  };
+  let value = evaluateCached(this, state);
+  if (!state.confident) value = undefined;
+  return {
+    confident: state.confident,
+    deopt: state.deoptPath,
+    value: value
+  };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/family.js b/node_modules/@babel/traverse/lib/path/family.js
new file mode 100644
index 00000000..2a193940
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/family.js
@@ -0,0 +1,244 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getOpposite = getOpposite;
+exports.getCompletionRecords = getCompletionRecords;
+exports.getSibling = getSibling;
+exports.getPrevSibling = getPrevSibling;
+exports.getNextSibling = getNextSibling;
+exports.getAllNextSiblings = getAllNextSiblings;
+exports.getAllPrevSiblings = getAllPrevSiblings;
+exports.get = get;
+exports._getKey = _getKey;
+exports._getPattern = _getPattern;
+exports.getBindingIdentifiers = getBindingIdentifiers;
+exports.getOuterBindingIdentifiers = getOuterBindingIdentifiers;
+exports.getBindingIdentifierPaths = getBindingIdentifierPaths;
+exports.getOuterBindingIdentifierPaths = getOuterBindingIdentifierPaths;
+
+var _index = _interopRequireDefault(require("./index"));
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function getOpposite() {
+  if (this.key === "left") {
+    return this.getSibling("right");
+  } else if (this.key === "right") {
+    return this.getSibling("left");
+  }
+}
+
+function addCompletionRecords(path, paths) {
+  if (path) return paths.concat(path.getCompletionRecords());
+  return paths;
+}
+
+function getCompletionRecords() {
+  let paths = [];
+
+  if (this.isIfStatement()) {
+    paths = addCompletionRecords(this.get("consequent"), paths);
+    paths = addCompletionRecords(this.get("alternate"), paths);
+  } else if (this.isDoExpression() || this.isFor() || this.isWhile()) {
+    paths = addCompletionRecords(this.get("body"), paths);
+  } else if (this.isProgram() || this.isBlockStatement()) {
+    paths = addCompletionRecords(this.get("body").pop(), paths);
+  } else if (this.isFunction()) {
+    return this.get("body").getCompletionRecords();
+  } else if (this.isTryStatement()) {
+    paths = addCompletionRecords(this.get("block"), paths);
+    paths = addCompletionRecords(this.get("handler"), paths);
+    paths = addCompletionRecords(this.get("finalizer"), paths);
+  } else if (this.isCatchClause()) {
+    paths = addCompletionRecords(this.get("body"), paths);
+  } else {
+    paths.push(this);
+  }
+
+  return paths;
+}
+
+function getSibling(key) {
+  return _index.default.get({
+    parentPath: this.parentPath,
+    parent: this.parent,
+    container: this.container,
+    listKey: this.listKey,
+    key: key
+  });
+}
+
+function getPrevSibling() {
+  return this.getSibling(this.key - 1);
+}
+
+function getNextSibling() {
+  return this.getSibling(this.key + 1);
+}
+
+function getAllNextSiblings() {
+  let _key = this.key;
+  let sibling = this.getSibling(++_key);
+  const siblings = [];
+
+  while (sibling.node) {
+    siblings.push(sibling);
+    sibling = this.getSibling(++_key);
+  }
+
+  return siblings;
+}
+
+function getAllPrevSiblings() {
+  let _key = this.key;
+  let sibling = this.getSibling(--_key);
+  const siblings = [];
+
+  while (sibling.node) {
+    siblings.push(sibling);
+    sibling = this.getSibling(--_key);
+  }
+
+  return siblings;
+}
+
+function get(key, context) {
+  if (context === true) context = this.context;
+  const parts = key.split(".");
+
+  if (parts.length === 1) {
+    return this._getKey(key, context);
+  } else {
+    return this._getPattern(parts, context);
+  }
+}
+
+function _getKey(key, context) {
+  const node = this.node;
+  const container = node[key];
+
+  if (Array.isArray(container)) {
+    return container.map((_, i) => {
+      return _index.default.get({
+        listKey: key,
+        parentPath: this,
+        parent: node,
+        container: container,
+        key: i
+      }).setContext(context);
+    });
+  } else {
+    return _index.default.get({
+      parentPath: this,
+      parent: node,
+      container: node,
+      key: key
+    }).setContext(context);
+  }
+}
+
+function _getPattern(parts, context) {
+  let path = this;
+  var _arr = parts;
+
+  for (var _i = 0; _i < _arr.length; _i++) {
+    const part = _arr[_i];
+
+    if (part === ".") {
+      path = path.parentPath;
+    } else {
+      if (Array.isArray(path)) {
+        path = path[part];
+      } else {
+        path = path.get(part, context);
+      }
+    }
+  }
+
+  return path;
+}
+
+function getBindingIdentifiers(duplicates) {
+  return t().getBindingIdentifiers(this.node, duplicates);
+}
+
+function getOuterBindingIdentifiers(duplicates) {
+  return t().getOuterBindingIdentifiers(this.node, duplicates);
+}
+
+function getBindingIdentifierPaths(duplicates = false, outerOnly = false) {
+  const path = this;
+  let search = [].concat(path);
+  const ids = Object.create(null);
+
+  while (search.length) {
+    const id = search.shift();
+    if (!id) continue;
+    if (!id.node) continue;
+    const keys = t().getBindingIdentifiers.keys[id.node.type];
+
+    if (id.isIdentifier()) {
+      if (duplicates) {
+        const _ids = ids[id.node.name] = ids[id.node.name] || [];
+
+        _ids.push(id);
+      } else {
+        ids[id.node.name] = id;
+      }
+
+      continue;
+    }
+
+    if (id.isExportDeclaration()) {
+      const declaration = id.get("declaration");
+
+      if (declaration.isDeclaration()) {
+        search.push(declaration);
+      }
+
+      continue;
+    }
+
+    if (outerOnly) {
+      if (id.isFunctionDeclaration()) {
+        search.push(id.get("id"));
+        continue;
+      }
+
+      if (id.isFunctionExpression()) {
+        continue;
+      }
+    }
+
+    if (keys) {
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const child = id.get(key);
+
+        if (Array.isArray(child) || child.node) {
+          search = search.concat(child);
+        }
+      }
+    }
+  }
+
+  return ids;
+}
+
+function getOuterBindingIdentifierPaths(duplicates) {
+  return this.getBindingIdentifierPaths(duplicates, true);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/index.js b/node_modules/@babel/traverse/lib/path/index.js
new file mode 100644
index 00000000..2f0927eb
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/index.js
@@ -0,0 +1,228 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var virtualTypes = _interopRequireWildcard(require("./lib/virtual-types"));
+
+function _debug() {
+  const data = _interopRequireDefault(require("debug"));
+
+  _debug = function _debug() {
+    return data;
+  };
+
+  return data;
+}
+
+function _invariant() {
+  const data = _interopRequireDefault(require("invariant"));
+
+  _invariant = function _invariant() {
+    return data;
+  };
+
+  return data;
+}
+
+var _index = _interopRequireDefault(require("../index"));
+
+var _scope = _interopRequireDefault(require("../scope"));
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+var _cache = require("../cache");
+
+function _generator() {
+  const data = _interopRequireDefault(require("@babel/generator"));
+
+  _generator = function _generator() {
+    return data;
+  };
+
+  return data;
+}
+
+var NodePath_ancestry = _interopRequireWildcard(require("./ancestry"));
+
+var NodePath_inference = _interopRequireWildcard(require("./inference"));
+
+var NodePath_replacement = _interopRequireWildcard(require("./replacement"));
+
+var NodePath_evaluation = _interopRequireWildcard(require("./evaluation"));
+
+var NodePath_conversion = _interopRequireWildcard(require("./conversion"));
+
+var NodePath_introspection = _interopRequireWildcard(require("./introspection"));
+
+var NodePath_context = _interopRequireWildcard(require("./context"));
+
+var NodePath_removal = _interopRequireWildcard(require("./removal"));
+
+var NodePath_modification = _interopRequireWildcard(require("./modification"));
+
+var NodePath_family = _interopRequireWildcard(require("./family"));
+
+var NodePath_comments = _interopRequireWildcard(require("./comments"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+const debug = (0, _debug().default)("babel");
+
+class NodePath {
+  constructor(hub, parent) {
+    this.parent = parent;
+    this.hub = hub;
+    this.contexts = [];
+    this.data = {};
+    this.shouldSkip = false;
+    this.shouldStop = false;
+    this.removed = false;
+    this.state = null;
+    this.opts = null;
+    this.skipKeys = null;
+    this.parentPath = null;
+    this.context = null;
+    this.container = null;
+    this.listKey = null;
+    this.inList = false;
+    this.parentKey = null;
+    this.key = null;
+    this.node = null;
+    this.scope = null;
+    this.type = null;
+    this.typeAnnotation = null;
+  }
+
+  static get({
+    hub,
+    parentPath,
+    parent,
+    container,
+    listKey,
+    key
+  }) {
+    if (!hub && parentPath) {
+      hub = parentPath.hub;
+    }
+
+    (0, _invariant().default)(parent, "To get a node path the parent needs to exist");
+    const targetNode = container[key];
+    const paths = _cache.path.get(parent) || [];
+
+    if (!_cache.path.has(parent)) {
+      _cache.path.set(parent, paths);
+    }
+
+    let path;
+
+    for (let i = 0; i < paths.length; i++) {
+      const pathCheck = paths[i];
+
+      if (pathCheck.node === targetNode) {
+        path = pathCheck;
+        break;
+      }
+    }
+
+    if (!path) {
+      path = new NodePath(hub, parent);
+      paths.push(path);
+    }
+
+    path.setup(parentPath, container, listKey, key);
+    return path;
+  }
+
+  getScope(scope) {
+    return this.isScope() ? new _scope.default(this) : scope;
+  }
+
+  setData(key, val) {
+    return this.data[key] = val;
+  }
+
+  getData(key, def) {
+    let val = this.data[key];
+    if (!val && def) val = this.data[key] = def;
+    return val;
+  }
+
+  buildCodeFrameError(msg, Error = SyntaxError) {
+    return this.hub.file.buildCodeFrameError(this.node, msg, Error);
+  }
+
+  traverse(visitor, state) {
+    (0, _index.default)(this.node, visitor, this.scope, state, this);
+  }
+
+  set(key, node) {
+    t().validate(this.node, key, node);
+    this.node[key] = node;
+  }
+
+  getPathLocation() {
+    const parts = [];
+    let path = this;
+
+    do {
+      let key = path.key;
+      if (path.inList) key = `${path.listKey}[${key}]`;
+      parts.unshift(key);
+    } while (path = path.parentPath);
+
+    return parts.join(".");
+  }
+
+  debug(message) {
+    if (!debug.enabled) return;
+    debug(`${this.getPathLocation()} ${this.type}: ${message}`);
+  }
+
+  toString() {
+    return (0, _generator().default)(this.node).code;
+  }
+
+}
+
+exports.default = NodePath;
+Object.assign(NodePath.prototype, NodePath_ancestry, NodePath_inference, NodePath_replacement, NodePath_evaluation, NodePath_conversion, NodePath_introspection, NodePath_context, NodePath_removal, NodePath_modification, NodePath_family, NodePath_comments);
+var _arr = t().TYPES;
+
+for (var _i = 0; _i < _arr.length; _i++) {
+  const type = _arr[_i];
+  const typeKey = `is${type}`;
+  const fn = t()[typeKey];
+
+  NodePath.prototype[typeKey] = function (opts) {
+    return fn(this.node, opts);
+  };
+
+  NodePath.prototype[`assert${type}`] = function (opts) {
+    if (!fn(this.node, opts)) {
+      throw new TypeError(`Expected node path of type ${type}`);
+    }
+  };
+}
+
+for (const type in virtualTypes) {
+  if (type[0] === "_") continue;
+  if (t().TYPES.indexOf(type) < 0) t().TYPES.push(type);
+  const virtualType = virtualTypes[type];
+
+  NodePath.prototype[`is${type}`] = function (opts) {
+    return virtualType.checkPath(this, opts);
+  };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/inference/index.js b/node_modules/@babel/traverse/lib/path/inference/index.js
new file mode 100644
index 00000000..d6e565c7
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/inference/index.js
@@ -0,0 +1,136 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTypeAnnotation = getTypeAnnotation;
+exports._getTypeAnnotation = _getTypeAnnotation;
+exports.isBaseType = isBaseType;
+exports.couldBeBaseType = couldBeBaseType;
+exports.baseTypeStrictlyMatches = baseTypeStrictlyMatches;
+exports.isGenericType = isGenericType;
+
+var inferers = _interopRequireWildcard(require("./inferers"));
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function getTypeAnnotation() {
+  if (this.typeAnnotation) return this.typeAnnotation;
+  let type = this._getTypeAnnotation() || t().anyTypeAnnotation();
+  if (t().isTypeAnnotation(type)) type = type.typeAnnotation;
+  return this.typeAnnotation = type;
+}
+
+function _getTypeAnnotation() {
+  const node = this.node;
+
+  if (!node) {
+    if (this.key === "init" && this.parentPath.isVariableDeclarator()) {
+      const declar = this.parentPath.parentPath;
+      const declarParent = declar.parentPath;
+
+      if (declar.key === "left" && declarParent.isForInStatement()) {
+        return t().stringTypeAnnotation();
+      }
+
+      if (declar.key === "left" && declarParent.isForOfStatement()) {
+        return t().anyTypeAnnotation();
+      }
+
+      return t().voidTypeAnnotation();
+    } else {
+      return;
+    }
+  }
+
+  if (node.typeAnnotation) {
+    return node.typeAnnotation;
+  }
+
+  let inferer = inferers[node.type];
+
+  if (inferer) {
+    return inferer.call(this, node);
+  }
+
+  inferer = inferers[this.parentPath.type];
+
+  if (inferer && inferer.validParent) {
+    return this.parentPath.getTypeAnnotation();
+  }
+}
+
+function isBaseType(baseName, soft) {
+  return _isBaseType(baseName, this.getTypeAnnotation(), soft);
+}
+
+function _isBaseType(baseName, type, soft) {
+  if (baseName === "string") {
+    return t().isStringTypeAnnotation(type);
+  } else if (baseName === "number") {
+    return t().isNumberTypeAnnotation(type);
+  } else if (baseName === "boolean") {
+    return t().isBooleanTypeAnnotation(type);
+  } else if (baseName === "any") {
+    return t().isAnyTypeAnnotation(type);
+  } else if (baseName === "mixed") {
+    return t().isMixedTypeAnnotation(type);
+  } else if (baseName === "empty") {
+    return t().isEmptyTypeAnnotation(type);
+  } else if (baseName === "void") {
+    return t().isVoidTypeAnnotation(type);
+  } else {
+    if (soft) {
+      return false;
+    } else {
+      throw new Error(`Unknown base type ${baseName}`);
+    }
+  }
+}
+
+function couldBeBaseType(name) {
+  const type = this.getTypeAnnotation();
+  if (t().isAnyTypeAnnotation(type)) return true;
+
+  if (t().isUnionTypeAnnotation(type)) {
+    var _arr = type.types;
+
+    for (var _i = 0; _i < _arr.length; _i++) {
+      const type2 = _arr[_i];
+
+      if (t().isAnyTypeAnnotation(type2) || _isBaseType(name, type2, true)) {
+        return true;
+      }
+    }
+
+    return false;
+  } else {
+    return _isBaseType(name, type, true);
+  }
+}
+
+function baseTypeStrictlyMatches(right) {
+  const left = this.getTypeAnnotation();
+  right = right.getTypeAnnotation();
+
+  if (!t().isAnyTypeAnnotation(left) && t().isFlowBaseAnnotation(left)) {
+    return right.type === left.type;
+  }
+}
+
+function isGenericType(genericName) {
+  const type = this.getTypeAnnotation();
+  return t().isGenericTypeAnnotation(type) && t().isIdentifier(type.id, {
+    name: genericName
+  });
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/inference/inferer-reference.js b/node_modules/@babel/traverse/lib/path/inference/inferer-reference.js
new file mode 100644
index 00000000..32f6bce5
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/inference/inferer-reference.js
@@ -0,0 +1,183 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _default(node) {
+  if (!this.isReferenced()) return;
+  const binding = this.scope.getBinding(node.name);
+
+  if (binding) {
+    if (binding.identifier.typeAnnotation) {
+      return binding.identifier.typeAnnotation;
+    } else {
+      return getTypeAnnotationBindingConstantViolations(binding, this, node.name);
+    }
+  }
+
+  if (node.name === "undefined") {
+    return t().voidTypeAnnotation();
+  } else if (node.name === "NaN" || node.name === "Infinity") {
+    return t().numberTypeAnnotation();
+  } else if (node.name === "arguments") {}
+}
+
+function getTypeAnnotationBindingConstantViolations(binding, path, name) {
+  const types = [];
+  const functionConstantViolations = [];
+  let constantViolations = getConstantViolationsBefore(binding, path, functionConstantViolations);
+  const testType = getConditionalAnnotation(binding, path, name);
+
+  if (testType) {
+    const testConstantViolations = getConstantViolationsBefore(binding, testType.ifStatement);
+    constantViolations = constantViolations.filter(path => testConstantViolations.indexOf(path) < 0);
+    types.push(testType.typeAnnotation);
+  }
+
+  if (constantViolations.length) {
+    constantViolations = constantViolations.concat(functionConstantViolations);
+    var _arr = constantViolations;
+
+    for (var _i = 0; _i < _arr.length; _i++) {
+      const violation = _arr[_i];
+      types.push(violation.getTypeAnnotation());
+    }
+  }
+
+  if (types.length) {
+    return t().createUnionTypeAnnotation(types);
+  }
+}
+
+function getConstantViolationsBefore(binding, path, functions) {
+  const violations = binding.constantViolations.slice();
+  violations.unshift(binding.path);
+  return violations.filter(violation => {
+    violation = violation.resolve();
+
+    const status = violation._guessExecutionStatusRelativeTo(path);
+
+    if (functions && status === "function") functions.push(violation);
+    return status === "before";
+  });
+}
+
+function inferAnnotationFromBinaryExpression(name, path) {
+  const operator = path.node.operator;
+  const right = path.get("right").resolve();
+  const left = path.get("left").resolve();
+  let target;
+
+  if (left.isIdentifier({
+    name
+  })) {
+    target = right;
+  } else if (right.isIdentifier({
+    name
+  })) {
+    target = left;
+  }
+
+  if (target) {
+    if (operator === "===") {
+      return target.getTypeAnnotation();
+    }
+
+    if (t().BOOLEAN_NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
+      return t().numberTypeAnnotation();
+    }
+
+    return;
+  }
+
+  if (operator !== "===" && operator !== "==") return;
+  let typeofPath;
+  let typePath;
+
+  if (left.isUnaryExpression({
+    operator: "typeof"
+  })) {
+    typeofPath = left;
+    typePath = right;
+  } else if (right.isUnaryExpression({
+    operator: "typeof"
+  })) {
+    typeofPath = right;
+    typePath = left;
+  }
+
+  if (!typeofPath) return;
+  if (!typeofPath.get("argument").isIdentifier({
+    name
+  })) return;
+  typePath = typePath.resolve();
+  if (!typePath.isLiteral()) return;
+  const typeValue = typePath.node.value;
+  if (typeof typeValue !== "string") return;
+  return t().createTypeAnnotationBasedOnTypeof(typeValue);
+}
+
+function getParentConditionalPath(binding, path, name) {
+  let parentPath;
+
+  while (parentPath = path.parentPath) {
+    if (parentPath.isIfStatement() || parentPath.isConditionalExpression()) {
+      if (path.key === "test") {
+        return;
+      }
+
+      return parentPath;
+    }
+
+    if (parentPath.isFunction()) {
+      if (parentPath.parentPath.scope.getBinding(name) !== binding) return;
+    }
+
+    path = parentPath;
+  }
+}
+
+function getConditionalAnnotation(binding, path, name) {
+  const ifStatement = getParentConditionalPath(binding, path, name);
+  if (!ifStatement) return;
+  const test = ifStatement.get("test");
+  const paths = [test];
+  const types = [];
+
+  for (let i = 0; i < paths.length; i++) {
+    const path = paths[i];
+
+    if (path.isLogicalExpression()) {
+      if (path.node.operator === "&&") {
+        paths.push(path.get("left"));
+        paths.push(path.get("right"));
+      }
+    } else if (path.isBinaryExpression()) {
+      const type = inferAnnotationFromBinaryExpression(name, path);
+      if (type) types.push(type);
+    }
+  }
+
+  if (types.length) {
+    return {
+      typeAnnotation: t().createUnionTypeAnnotation(types),
+      ifStatement
+    };
+  }
+
+  return getConditionalAnnotation(ifStatement, name);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/inference/inferers.js b/node_modules/@babel/traverse/lib/path/inference/inferers.js
new file mode 100644
index 00000000..fe224058
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/inference/inferers.js
@@ -0,0 +1,220 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VariableDeclarator = VariableDeclarator;
+exports.TypeCastExpression = TypeCastExpression;
+exports.NewExpression = NewExpression;
+exports.TemplateLiteral = TemplateLiteral;
+exports.UnaryExpression = UnaryExpression;
+exports.BinaryExpression = BinaryExpression;
+exports.LogicalExpression = LogicalExpression;
+exports.ConditionalExpression = ConditionalExpression;
+exports.SequenceExpression = SequenceExpression;
+exports.AssignmentExpression = AssignmentExpression;
+exports.UpdateExpression = UpdateExpression;
+exports.StringLiteral = StringLiteral;
+exports.NumericLiteral = NumericLiteral;
+exports.BooleanLiteral = BooleanLiteral;
+exports.NullLiteral = NullLiteral;
+exports.RegExpLiteral = RegExpLiteral;
+exports.ObjectExpression = ObjectExpression;
+exports.ArrayExpression = ArrayExpression;
+exports.RestElement = RestElement;
+exports.ClassDeclaration = exports.ClassExpression = exports.FunctionDeclaration = exports.ArrowFunctionExpression = exports.FunctionExpression = Func;
+exports.CallExpression = CallExpression;
+exports.TaggedTemplateExpression = TaggedTemplateExpression;
+Object.defineProperty(exports, "Identifier", {
+  enumerable: true,
+  get: function get() {
+    return _infererReference.default;
+  }
+});
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+var _infererReference = _interopRequireDefault(require("./inferer-reference"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function VariableDeclarator() {
+  const id = this.get("id");
+  if (!id.isIdentifier()) return;
+  const init = this.get("init");
+  let type = init.getTypeAnnotation();
+
+  if (type && type.type === "AnyTypeAnnotation") {
+    if (init.isCallExpression() && init.get("callee").isIdentifier({
+      name: "Array"
+    }) && !init.scope.hasBinding("Array", true)) {
+      type = ArrayExpression();
+    }
+  }
+
+  return type;
+}
+
+function TypeCastExpression(node) {
+  return node.typeAnnotation;
+}
+
+TypeCastExpression.validParent = true;
+
+function NewExpression(node) {
+  if (this.get("callee").isIdentifier()) {
+    return t().genericTypeAnnotation(node.callee);
+  }
+}
+
+function TemplateLiteral() {
+  return t().stringTypeAnnotation();
+}
+
+function UnaryExpression(node) {
+  const operator = node.operator;
+
+  if (operator === "void") {
+    return t().voidTypeAnnotation();
+  } else if (t().NUMBER_UNARY_OPERATORS.indexOf(operator) >= 0) {
+    return t().numberTypeAnnotation();
+  } else if (t().STRING_UNARY_OPERATORS.indexOf(operator) >= 0) {
+    return t().stringTypeAnnotation();
+  } else if (t().BOOLEAN_UNARY_OPERATORS.indexOf(operator) >= 0) {
+    return t().booleanTypeAnnotation();
+  }
+}
+
+function BinaryExpression(node) {
+  const operator = node.operator;
+
+  if (t().NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
+    return t().numberTypeAnnotation();
+  } else if (t().BOOLEAN_BINARY_OPERATORS.indexOf(operator) >= 0) {
+    return t().booleanTypeAnnotation();
+  } else if (operator === "+") {
+    const right = this.get("right");
+    const left = this.get("left");
+
+    if (left.isBaseType("number") && right.isBaseType("number")) {
+      return t().numberTypeAnnotation();
+    } else if (left.isBaseType("string") || right.isBaseType("string")) {
+      return t().stringTypeAnnotation();
+    }
+
+    return t().unionTypeAnnotation([t().stringTypeAnnotation(), t().numberTypeAnnotation()]);
+  }
+}
+
+function LogicalExpression() {
+  return t().createUnionTypeAnnotation([this.get("left").getTypeAnnotation(), this.get("right").getTypeAnnotation()]);
+}
+
+function ConditionalExpression() {
+  return t().createUnionTypeAnnotation([this.get("consequent").getTypeAnnotation(), this.get("alternate").getTypeAnnotation()]);
+}
+
+function SequenceExpression() {
+  return this.get("expressions").pop().getTypeAnnotation();
+}
+
+function AssignmentExpression() {
+  return this.get("right").getTypeAnnotation();
+}
+
+function UpdateExpression(node) {
+  const operator = node.operator;
+
+  if (operator === "++" || operator === "--") {
+    return t().numberTypeAnnotation();
+  }
+}
+
+function StringLiteral() {
+  return t().stringTypeAnnotation();
+}
+
+function NumericLiteral() {
+  return t().numberTypeAnnotation();
+}
+
+function BooleanLiteral() {
+  return t().booleanTypeAnnotation();
+}
+
+function NullLiteral() {
+  return t().nullLiteralTypeAnnotation();
+}
+
+function RegExpLiteral() {
+  return t().genericTypeAnnotation(t().identifier("RegExp"));
+}
+
+function ObjectExpression() {
+  return t().genericTypeAnnotation(t().identifier("Object"));
+}
+
+function ArrayExpression() {
+  return t().genericTypeAnnotation(t().identifier("Array"));
+}
+
+function RestElement() {
+  return ArrayExpression();
+}
+
+RestElement.validParent = true;
+
+function Func() {
+  return t().genericTypeAnnotation(t().identifier("Function"));
+}
+
+const isArrayFrom = t().buildMatchMemberExpression("Array.from");
+const isObjectKeys = t().buildMatchMemberExpression("Object.keys");
+const isObjectValues = t().buildMatchMemberExpression("Object.values");
+const isObjectEntries = t().buildMatchMemberExpression("Object.entries");
+
+function CallExpression() {
+  const callee = this.node.callee;
+
+  if (isObjectKeys(callee)) {
+    return t().arrayTypeAnnotation(t().stringTypeAnnotation());
+  } else if (isArrayFrom(callee) || isObjectValues(callee)) {
+    return t().arrayTypeAnnotation(t().anyTypeAnnotation());
+  } else if (isObjectEntries(callee)) {
+    return t().arrayTypeAnnotation(t().tupleTypeAnnotation([t().stringTypeAnnotation(), t().anyTypeAnnotation()]));
+  }
+
+  return resolveCall(this.get("callee"));
+}
+
+function TaggedTemplateExpression() {
+  return resolveCall(this.get("tag"));
+}
+
+function resolveCall(callee) {
+  callee = callee.resolve();
+
+  if (callee.isFunction()) {
+    if (callee.is("async")) {
+      if (callee.is("generator")) {
+        return t().genericTypeAnnotation(t().identifier("AsyncIterator"));
+      } else {
+        return t().genericTypeAnnotation(t().identifier("Promise"));
+      }
+    } else {
+      if (callee.node.returnType) {
+        return callee.node.returnType;
+      } else {}
+    }
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/introspection.js b/node_modules/@babel/traverse/lib/path/introspection.js
new file mode 100644
index 00000000..6177b65c
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/introspection.js
@@ -0,0 +1,412 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.matchesPattern = matchesPattern;
+exports.has = has;
+exports.isStatic = isStatic;
+exports.isnt = isnt;
+exports.equals = equals;
+exports.isNodeType = isNodeType;
+exports.canHaveVariableDeclarationOrExpression = canHaveVariableDeclarationOrExpression;
+exports.canSwapBetweenExpressionAndStatement = canSwapBetweenExpressionAndStatement;
+exports.isCompletionRecord = isCompletionRecord;
+exports.isStatementOrBlock = isStatementOrBlock;
+exports.referencesImport = referencesImport;
+exports.getSource = getSource;
+exports.willIMaybeExecuteBefore = willIMaybeExecuteBefore;
+exports._guessExecutionStatusRelativeTo = _guessExecutionStatusRelativeTo;
+exports._guessExecutionStatusRelativeToDifferentFunctions = _guessExecutionStatusRelativeToDifferentFunctions;
+exports.resolve = resolve;
+exports._resolve = _resolve;
+exports.isConstantExpression = isConstantExpression;
+exports.isInStrictMode = isInStrictMode;
+exports.is = void 0;
+
+function _includes() {
+  const data = _interopRequireDefault(require("lodash/includes"));
+
+  _includes = function _includes() {
+    return data;
+  };
+
+  return data;
+}
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function matchesPattern(pattern, allowPartial) {
+  return t().matchesPattern(this.node, pattern, allowPartial);
+}
+
+function has(key) {
+  const val = this.node && this.node[key];
+
+  if (val && Array.isArray(val)) {
+    return !!val.length;
+  } else {
+    return !!val;
+  }
+}
+
+function isStatic() {
+  return this.scope.isStatic(this.node);
+}
+
+const is = has;
+exports.is = is;
+
+function isnt(key) {
+  return !this.has(key);
+}
+
+function equals(key, value) {
+  return this.node[key] === value;
+}
+
+function isNodeType(type) {
+  return t().isType(this.type, type);
+}
+
+function canHaveVariableDeclarationOrExpression() {
+  return (this.key === "init" || this.key === "left") && this.parentPath.isFor();
+}
+
+function canSwapBetweenExpressionAndStatement(replacement) {
+  if (this.key !== "body" || !this.parentPath.isArrowFunctionExpression()) {
+    return false;
+  }
+
+  if (this.isExpression()) {
+    return t().isBlockStatement(replacement);
+  } else if (this.isBlockStatement()) {
+    return t().isExpression(replacement);
+  }
+
+  return false;
+}
+
+function isCompletionRecord(allowInsideFunction) {
+  let path = this;
+  let first = true;
+
+  do {
+    const container = path.container;
+
+    if (path.isFunction() && !first) {
+      return !!allowInsideFunction;
+    }
+
+    first = false;
+
+    if (Array.isArray(container) && path.key !== container.length - 1) {
+      return false;
+    }
+  } while ((path = path.parentPath) && !path.isProgram());
+
+  return true;
+}
+
+function isStatementOrBlock() {
+  if (this.parentPath.isLabeledStatement() || t().isBlockStatement(this.container)) {
+    return false;
+  } else {
+    return (0, _includes().default)(t().STATEMENT_OR_BLOCK_KEYS, this.key);
+  }
+}
+
+function referencesImport(moduleSource, importName) {
+  if (!this.isReferencedIdentifier()) return false;
+  const binding = this.scope.getBinding(this.node.name);
+  if (!binding || binding.kind !== "module") return false;
+  const path = binding.path;
+  const parent = path.parentPath;
+  if (!parent.isImportDeclaration()) return false;
+
+  if (parent.node.source.value === moduleSource) {
+    if (!importName) return true;
+  } else {
+    return false;
+  }
+
+  if (path.isImportDefaultSpecifier() && importName === "default") {
+    return true;
+  }
+
+  if (path.isImportNamespaceSpecifier() && importName === "*") {
+    return true;
+  }
+
+  if (path.isImportSpecifier() && path.node.imported.name === importName) {
+    return true;
+  }
+
+  return false;
+}
+
+function getSource() {
+  const node = this.node;
+
+  if (node.end) {
+    return this.hub.file.code.slice(node.start, node.end);
+  } else {
+    return "";
+  }
+}
+
+function willIMaybeExecuteBefore(target) {
+  return this._guessExecutionStatusRelativeTo(target) !== "after";
+}
+
+function _guessExecutionStatusRelativeTo(target) {
+  const targetFuncParent = target.scope.getFunctionParent() || target.scope.getProgramParent();
+  const selfFuncParent = this.scope.getFunctionParent() || target.scope.getProgramParent();
+
+  if (targetFuncParent.node !== selfFuncParent.node) {
+    const status = this._guessExecutionStatusRelativeToDifferentFunctions(targetFuncParent);
+
+    if (status) {
+      return status;
+    } else {
+      target = targetFuncParent.path;
+    }
+  }
+
+  const targetPaths = target.getAncestry();
+  if (targetPaths.indexOf(this) >= 0) return "after";
+  const selfPaths = this.getAncestry();
+  let commonPath;
+  let targetIndex;
+  let selfIndex;
+
+  for (selfIndex = 0; selfIndex < selfPaths.length; selfIndex++) {
+    const selfPath = selfPaths[selfIndex];
+    targetIndex = targetPaths.indexOf(selfPath);
+
+    if (targetIndex >= 0) {
+      commonPath = selfPath;
+      break;
+    }
+  }
+
+  if (!commonPath) {
+    return "before";
+  }
+
+  const targetRelationship = targetPaths[targetIndex - 1];
+  const selfRelationship = selfPaths[selfIndex - 1];
+
+  if (!targetRelationship || !selfRelationship) {
+    return "before";
+  }
+
+  if (targetRelationship.listKey && targetRelationship.container === selfRelationship.container) {
+    return targetRelationship.key > selfRelationship.key ? "before" : "after";
+  }
+
+  const keys = t().VISITOR_KEYS[commonPath.type];
+  const targetKeyPosition = keys.indexOf(targetRelationship.key);
+  const selfKeyPosition = keys.indexOf(selfRelationship.key);
+  return targetKeyPosition > selfKeyPosition ? "before" : "after";
+}
+
+function _guessExecutionStatusRelativeToDifferentFunctions(targetFuncParent) {
+  const targetFuncPath = targetFuncParent.path;
+  if (!targetFuncPath.isFunctionDeclaration()) return;
+  const binding = targetFuncPath.scope.getBinding(targetFuncPath.node.id.name);
+  if (!binding.references) return "before";
+  const referencePaths = binding.referencePaths;
+
+  for (var _iterator = referencePaths, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref;
+
+    if (_isArray) {
+      if (_i >= _iterator.length) break;
+      _ref = _iterator[_i++];
+    } else {
+      _i = _iterator.next();
+      if (_i.done) break;
+      _ref = _i.value;
+    }
+
+    const path = _ref;
+
+    if (path.key !== "callee" || !path.parentPath.isCallExpression()) {
+      return;
+    }
+  }
+
+  let allStatus;
+
+  for (var _iterator2 = referencePaths, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+    var _ref2;
+
+    if (_isArray2) {
+      if (_i2 >= _iterator2.length) break;
+      _ref2 = _iterator2[_i2++];
+    } else {
+      _i2 = _iterator2.next();
+      if (_i2.done) break;
+      _ref2 = _i2.value;
+    }
+
+    const path = _ref2;
+    const childOfFunction = !!path.find(path => path.node === targetFuncPath.node);
+    if (childOfFunction) continue;
+
+    const status = this._guessExecutionStatusRelativeTo(path);
+
+    if (allStatus) {
+      if (allStatus !== status) return;
+    } else {
+      allStatus = status;
+    }
+  }
+
+  return allStatus;
+}
+
+function resolve(dangerous, resolved) {
+  return this._resolve(dangerous, resolved) || this;
+}
+
+function _resolve(dangerous, resolved) {
+  if (resolved && resolved.indexOf(this) >= 0) return;
+  resolved = resolved || [];
+  resolved.push(this);
+
+  if (this.isVariableDeclarator()) {
+    if (this.get("id").isIdentifier()) {
+      return this.get("init").resolve(dangerous, resolved);
+    } else {}
+  } else if (this.isReferencedIdentifier()) {
+    const binding = this.scope.getBinding(this.node.name);
+    if (!binding) return;
+    if (!binding.constant) return;
+    if (binding.kind === "module") return;
+
+    if (binding.path !== this) {
+      const ret = binding.path.resolve(dangerous, resolved);
+      if (this.find(parent => parent.node === ret.node)) return;
+      return ret;
+    }
+  } else if (this.isTypeCastExpression()) {
+    return this.get("expression").resolve(dangerous, resolved);
+  } else if (dangerous && this.isMemberExpression()) {
+    const targetKey = this.toComputedKey();
+    if (!t().isLiteral(targetKey)) return;
+    const targetName = targetKey.value;
+    const target = this.get("object").resolve(dangerous, resolved);
+
+    if (target.isObjectExpression()) {
+      const props = target.get("properties");
+      var _arr = props;
+
+      for (var _i3 = 0; _i3 < _arr.length; _i3++) {
+        const prop = _arr[_i3];
+        if (!prop.isProperty()) continue;
+        const key = prop.get("key");
+        let match = prop.isnt("computed") && key.isIdentifier({
+          name: targetName
+        });
+        match = match || key.isLiteral({
+          value: targetName
+        });
+        if (match) return prop.get("value").resolve(dangerous, resolved);
+      }
+    } else if (target.isArrayExpression() && !isNaN(+targetName)) {
+      const elems = target.get("elements");
+      const elem = elems[targetName];
+      if (elem) return elem.resolve(dangerous, resolved);
+    }
+  }
+}
+
+function isConstantExpression() {
+  if (this.isIdentifier()) {
+    const binding = this.scope.getBinding(this.node.name);
+
+    if (!binding) {
+      return false;
+    }
+
+    return binding.constant && binding.path.get("init").isConstantExpression();
+  }
+
+  if (this.isLiteral()) {
+    if (this.isRegExpLiteral()) {
+      return false;
+    }
+
+    if (this.isTemplateLiteral()) {
+      return this.get("expressions").every(expression => expression.isConstantExpression());
+    }
+
+    return true;
+  }
+
+  if (this.isUnaryExpression()) {
+    if (this.get("operator").node !== "void") {
+      return false;
+    }
+
+    return this.get("argument").isConstantExpression();
+  }
+
+  if (this.isBinaryExpression()) {
+    return this.get("left").isConstantExpression() && this.get("right").isConstantExpression();
+  }
+
+  return false;
+}
+
+function isInStrictMode() {
+  const start = this.isProgram() ? this : this.parentPath;
+  const strictParent = start.find(path => {
+    if (path.isProgram({
+      sourceType: "module"
+    })) return true;
+    if (path.isClass()) return true;
+    if (!path.isProgram() && !path.isFunction()) return false;
+
+    if (path.isArrowFunctionExpression() && !path.get("body").isBlockStatement()) {
+      return false;
+    }
+
+    let node = path.node;
+    if (path.isFunction()) node = node.body;
+
+    for (var _iterator3 = node.directives, _isArray3 = Array.isArray(_iterator3), _i4 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
+      var _ref3;
+
+      if (_isArray3) {
+        if (_i4 >= _iterator3.length) break;
+        _ref3 = _iterator3[_i4++];
+      } else {
+        _i4 = _iterator3.next();
+        if (_i4.done) break;
+        _ref3 = _i4.value;
+      }
+
+      const directive = _ref3;
+
+      if (directive.value.value === "use strict") {
+        return true;
+      }
+    }
+  });
+  return !!strictParent;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/lib/hoister.js b/node_modules/@babel/traverse/lib/path/lib/hoister.js
new file mode 100644
index 00000000..94809727
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/lib/hoister.js
@@ -0,0 +1,194 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+const referenceVisitor = {
+  ReferencedIdentifier(path, state) {
+    if (path.isJSXIdentifier() && t().react.isCompatTag(path.node.name) && !path.parentPath.isJSXMemberExpression()) {
+      return;
+    }
+
+    if (path.node.name === "this") {
+      let scope = path.scope;
+
+      do {
+        if (scope.path.isFunction() && !scope.path.isArrowFunctionExpression()) {
+          break;
+        }
+      } while (scope = scope.parent);
+
+      if (scope) state.breakOnScopePaths.push(scope.path);
+    }
+
+    const binding = path.scope.getBinding(path.node.name);
+    if (!binding) return;
+    if (binding !== state.scope.getBinding(path.node.name)) return;
+    state.bindings[path.node.name] = binding;
+  }
+
+};
+
+class PathHoister {
+  constructor(path, scope) {
+    this.breakOnScopePaths = [];
+    this.bindings = {};
+    this.scopes = [];
+    this.scope = scope;
+    this.path = path;
+    this.attachAfter = false;
+  }
+
+  isCompatibleScope(scope) {
+    for (const key in this.bindings) {
+      const binding = this.bindings[key];
+
+      if (!scope.bindingIdentifierEquals(key, binding.identifier)) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  getCompatibleScopes() {
+    let scope = this.path.scope;
+
+    do {
+      if (this.isCompatibleScope(scope)) {
+        this.scopes.push(scope);
+      } else {
+        break;
+      }
+
+      if (this.breakOnScopePaths.indexOf(scope.path) >= 0) {
+        break;
+      }
+    } while (scope = scope.parent);
+  }
+
+  getAttachmentPath() {
+    let path = this._getAttachmentPath();
+
+    if (!path) return;
+    let targetScope = path.scope;
+
+    if (targetScope.path === path) {
+      targetScope = path.scope.parent;
+    }
+
+    if (targetScope.path.isProgram() || targetScope.path.isFunction()) {
+      for (const name in this.bindings) {
+        if (!targetScope.hasOwnBinding(name)) continue;
+        const binding = this.bindings[name];
+
+        if (binding.kind === "param" || binding.path.parentKey === "params") {
+          continue;
+        }
+
+        const bindingParentPath = this.getAttachmentParentForPath(binding.path);
+
+        if (bindingParentPath.key >= path.key) {
+          this.attachAfter = true;
+          path = binding.path;
+          var _arr = binding.constantViolations;
+
+          for (var _i = 0; _i < _arr.length; _i++) {
+            const violationPath = _arr[_i];
+
+            if (this.getAttachmentParentForPath(violationPath).key > path.key) {
+              path = violationPath;
+            }
+          }
+        }
+      }
+    }
+
+    return path;
+  }
+
+  _getAttachmentPath() {
+    const scopes = this.scopes;
+    const scope = scopes.pop();
+    if (!scope) return;
+
+    if (scope.path.isFunction()) {
+      if (this.hasOwnParamBindings(scope)) {
+        if (this.scope === scope) return;
+        const bodies = scope.path.get("body").get("body");
+
+        for (let i = 0; i < bodies.length; i++) {
+          if (bodies[i].node._blockHoist) continue;
+          return bodies[i];
+        }
+      } else {
+        return this.getNextScopeAttachmentParent();
+      }
+    } else if (scope.path.isProgram()) {
+      return this.getNextScopeAttachmentParent();
+    }
+  }
+
+  getNextScopeAttachmentParent() {
+    const scope = this.scopes.pop();
+    if (scope) return this.getAttachmentParentForPath(scope.path);
+  }
+
+  getAttachmentParentForPath(path) {
+    do {
+      if (!path.parentPath || Array.isArray(path.container) && path.isStatement()) {
+        return path;
+      }
+    } while (path = path.parentPath);
+  }
+
+  hasOwnParamBindings(scope) {
+    for (const name in this.bindings) {
+      if (!scope.hasOwnBinding(name)) continue;
+      const binding = this.bindings[name];
+      if (binding.kind === "param" && binding.constant) return true;
+    }
+
+    return false;
+  }
+
+  run() {
+    this.path.traverse(referenceVisitor, this);
+    this.getCompatibleScopes();
+    const attachTo = this.getAttachmentPath();
+    if (!attachTo) return;
+    if (attachTo.getFunctionParent() === this.path.getFunctionParent()) return;
+    let uid = attachTo.scope.generateUidIdentifier("ref");
+    const declarator = t().variableDeclarator(uid, this.path.node);
+    const insertFn = this.attachAfter ? "insertAfter" : "insertBefore";
+
+    const _attachTo$insertFn = attachTo[insertFn]([attachTo.isVariableDeclarator() ? declarator : t().variableDeclaration("var", [declarator])]),
+          attached = _attachTo$insertFn[0];
+
+    const parent = this.path.parentPath;
+
+    if (parent.isJSXElement() && this.path.container === parent.node.children) {
+      uid = t().JSXExpressionContainer(uid);
+    }
+
+    this.path.replaceWith(t().cloneNode(uid));
+    return attachTo.isVariableDeclarator() ? attached.get("init") : attached.get("declarations.0.init");
+  }
+
+}
+
+exports.default = PathHoister;
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/lib/removal-hooks.js b/node_modules/@babel/traverse/lib/path/lib/removal-hooks.js
new file mode 100644
index 00000000..23ec8fe6
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/lib/removal-hooks.js
@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hooks = void 0;
+const hooks = [function (self, parent) {
+  const removeParent = self.key === "test" && (parent.isWhile() || parent.isSwitchCase()) || self.key === "declaration" && parent.isExportDeclaration() || self.key === "body" && parent.isLabeledStatement() || self.listKey === "declarations" && parent.isVariableDeclaration() && parent.node.declarations.length === 1 || self.key === "expression" && parent.isExpressionStatement();
+
+  if (removeParent) {
+    parent.remove();
+    return true;
+  }
+}, function (self, parent) {
+  if (parent.isSequenceExpression() && parent.node.expressions.length === 1) {
+    parent.replaceWith(parent.node.expressions[0]);
+    return true;
+  }
+}, function (self, parent) {
+  if (parent.isBinary()) {
+    if (self.key === "left") {
+      parent.replaceWith(parent.node.right);
+    } else {
+      parent.replaceWith(parent.node.left);
+    }
+
+    return true;
+  }
+}, function (self, parent) {
+  if (parent.isIfStatement() && (self.key === "consequent" || self.key === "alternate") || self.key === "body" && (parent.isLoop() || parent.isArrowFunctionExpression())) {
+    self.replaceWith({
+      type: "BlockStatement",
+      body: []
+    });
+    return true;
+  }
+}];
+exports.hooks = hooks;
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/lib/virtual-types.js b/node_modules/@babel/traverse/lib/path/lib/virtual-types.js
new file mode 100644
index 00000000..904b0d0d
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/lib/virtual-types.js
@@ -0,0 +1,212 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ForAwaitStatement = exports.NumericLiteralTypeAnnotation = exports.ExistentialTypeParam = exports.SpreadProperty = exports.RestProperty = exports.Flow = exports.Pure = exports.Generated = exports.User = exports.Var = exports.BlockScoped = exports.Referenced = exports.Scope = exports.Expression = exports.Statement = exports.BindingIdentifier = exports.ReferencedMemberExpression = exports.ReferencedIdentifier = void 0;
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+const ReferencedIdentifier = {
+  types: ["Identifier", "JSXIdentifier"],
+
+  checkPath({
+    node,
+    parent
+  }, opts) {
+    if (!t().isIdentifier(node, opts) && !t().isJSXMemberExpression(parent, opts)) {
+      if (t().isJSXIdentifier(node, opts)) {
+        if (t().react.isCompatTag(node.name)) return false;
+      } else {
+        return false;
+      }
+    }
+
+    return t().isReferenced(node, parent);
+  }
+
+};
+exports.ReferencedIdentifier = ReferencedIdentifier;
+const ReferencedMemberExpression = {
+  types: ["MemberExpression"],
+
+  checkPath({
+    node,
+    parent
+  }) {
+    return t().isMemberExpression(node) && t().isReferenced(node, parent);
+  }
+
+};
+exports.ReferencedMemberExpression = ReferencedMemberExpression;
+const BindingIdentifier = {
+  types: ["Identifier"],
+
+  checkPath({
+    node,
+    parent
+  }) {
+    return t().isIdentifier(node) && t().isBinding(node, parent);
+  }
+
+};
+exports.BindingIdentifier = BindingIdentifier;
+const Statement = {
+  types: ["Statement"],
+
+  checkPath({
+    node,
+    parent
+  }) {
+    if (t().isStatement(node)) {
+      if (t().isVariableDeclaration(node)) {
+        if (t().isForXStatement(parent, {
+          left: node
+        })) return false;
+        if (t().isForStatement(parent, {
+          init: node
+        })) return false;
+      }
+
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+};
+exports.Statement = Statement;
+const Expression = {
+  types: ["Expression"],
+
+  checkPath(path) {
+    if (path.isIdentifier()) {
+      return path.isReferencedIdentifier();
+    } else {
+      return t().isExpression(path.node);
+    }
+  }
+
+};
+exports.Expression = Expression;
+const Scope = {
+  types: ["Scopable"],
+
+  checkPath(path) {
+    return t().isScope(path.node, path.parent);
+  }
+
+};
+exports.Scope = Scope;
+const Referenced = {
+  checkPath(path) {
+    return t().isReferenced(path.node, path.parent);
+  }
+
+};
+exports.Referenced = Referenced;
+const BlockScoped = {
+  checkPath(path) {
+    return t().isBlockScoped(path.node);
+  }
+
+};
+exports.BlockScoped = BlockScoped;
+const Var = {
+  types: ["VariableDeclaration"],
+
+  checkPath(path) {
+    return t().isVar(path.node);
+  }
+
+};
+exports.Var = Var;
+const User = {
+  checkPath(path) {
+    return path.node && !!path.node.loc;
+  }
+
+};
+exports.User = User;
+const Generated = {
+  checkPath(path) {
+    return !path.isUser();
+  }
+
+};
+exports.Generated = Generated;
+const Pure = {
+  checkPath(path, opts) {
+    return path.scope.isPure(path.node, opts);
+  }
+
+};
+exports.Pure = Pure;
+const Flow = {
+  types: ["Flow", "ImportDeclaration", "ExportDeclaration", "ImportSpecifier"],
+
+  checkPath({
+    node
+  }) {
+    if (t().isFlow(node)) {
+      return true;
+    } else if (t().isImportDeclaration(node)) {
+      return node.importKind === "type" || node.importKind === "typeof";
+    } else if (t().isExportDeclaration(node)) {
+      return node.exportKind === "type";
+    } else if (t().isImportSpecifier(node)) {
+      return node.importKind === "type" || node.importKind === "typeof";
+    } else {
+      return false;
+    }
+  }
+
+};
+exports.Flow = Flow;
+const RestProperty = {
+  types: ["RestElement"],
+
+  checkPath(path) {
+    return path.parentPath && path.parentPath.isObjectPattern();
+  }
+
+};
+exports.RestProperty = RestProperty;
+const SpreadProperty = {
+  types: ["RestElement"],
+
+  checkPath(path) {
+    return path.parentPath && path.parentPath.isObjectExpression();
+  }
+
+};
+exports.SpreadProperty = SpreadProperty;
+const ExistentialTypeParam = {
+  types: ["ExistsTypeAnnotation"]
+};
+exports.ExistentialTypeParam = ExistentialTypeParam;
+const NumericLiteralTypeAnnotation = {
+  types: ["NumberLiteralTypeAnnotation"]
+};
+exports.NumericLiteralTypeAnnotation = NumericLiteralTypeAnnotation;
+const ForAwaitStatement = {
+  types: ["ForOfStatement"],
+
+  checkPath({
+    node
+  }) {
+    return node.await === true;
+  }
+
+};
+exports.ForAwaitStatement = ForAwaitStatement;
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/modification.js b/node_modules/@babel/traverse/lib/path/modification.js
new file mode 100644
index 00000000..946dceb2
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/modification.js
@@ -0,0 +1,227 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.insertBefore = insertBefore;
+exports._containerInsert = _containerInsert;
+exports._containerInsertBefore = _containerInsertBefore;
+exports._containerInsertAfter = _containerInsertAfter;
+exports.insertAfter = insertAfter;
+exports.updateSiblingKeys = updateSiblingKeys;
+exports._verifyNodeList = _verifyNodeList;
+exports.unshiftContainer = unshiftContainer;
+exports.pushContainer = pushContainer;
+exports.hoist = hoist;
+
+var _cache = require("../cache");
+
+var _hoister = _interopRequireDefault(require("./lib/hoister"));
+
+var _index = _interopRequireDefault(require("./index"));
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function insertBefore(nodes) {
+  this._assertUnremoved();
+
+  nodes = this._verifyNodeList(nodes);
+  const parentPath = this.parentPath;
+
+  if (parentPath.isExpressionStatement() || parentPath.isLabeledStatement() || parentPath.isExportNamedDeclaration() || parentPath.isExportDefaultDeclaration() && this.isDeclaration()) {
+    return parentPath.insertBefore(nodes);
+  } else if (this.isNodeType("Expression") && this.listKey !== "params" && this.listKey !== "arguments" || parentPath.isForStatement() && this.key === "init") {
+    if (this.node) nodes.push(this.node);
+    return this.replaceExpressionWithStatements(nodes);
+  } else if (Array.isArray(this.container)) {
+    return this._containerInsertBefore(nodes);
+  } else if (this.isStatementOrBlock()) {
+    const shouldInsertCurrentNode = this.node && (!this.isExpressionStatement() || this.node.expression != null);
+    this.replaceWith(t().blockStatement(shouldInsertCurrentNode ? [this.node] : []));
+    return this.unshiftContainer("body", nodes);
+  } else {
+    throw new Error("We don't know what to do with this node type. " + "We were previously a Statement but we can't fit in here?");
+  }
+}
+
+function _containerInsert(from, nodes) {
+  this.updateSiblingKeys(from, nodes.length);
+  const paths = [];
+  this.container.splice(from, 0, ...nodes);
+
+  for (let i = 0; i < nodes.length; i++) {
+    const to = from + i;
+    const path = this.getSibling(to);
+    paths.push(path);
+
+    if (this.context && this.context.queue) {
+      path.pushContext(this.context);
+    }
+  }
+
+  const contexts = this._getQueueContexts();
+
+  for (var _i = 0; _i < paths.length; _i++) {
+    const path = paths[_i];
+    path.setScope();
+    path.debug("Inserted.");
+
+    for (var _iterator = contexts, _isArray = Array.isArray(_iterator), _i2 = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i2 >= _iterator.length) break;
+        _ref = _iterator[_i2++];
+      } else {
+        _i2 = _iterator.next();
+        if (_i2.done) break;
+        _ref = _i2.value;
+      }
+
+      const context = _ref;
+      context.maybeQueue(path, true);
+    }
+  }
+
+  return paths;
+}
+
+function _containerInsertBefore(nodes) {
+  return this._containerInsert(this.key, nodes);
+}
+
+function _containerInsertAfter(nodes) {
+  return this._containerInsert(this.key + 1, nodes);
+}
+
+function insertAfter(nodes) {
+  this._assertUnremoved();
+
+  nodes = this._verifyNodeList(nodes);
+  const parentPath = this.parentPath;
+
+  if (parentPath.isExpressionStatement() || parentPath.isLabeledStatement() || parentPath.isExportNamedDeclaration() || parentPath.isExportDefaultDeclaration() && this.isDeclaration()) {
+    return parentPath.insertAfter(nodes);
+  } else if (this.isNodeType("Expression") || parentPath.isForStatement() && this.key === "init") {
+    if (this.node) {
+      let scope = this.scope;
+
+      if (parentPath.isMethod({
+        computed: true,
+        key: this.node
+      })) {
+        scope = scope.parent;
+      }
+
+      const temp = scope.generateDeclaredUidIdentifier();
+      nodes.unshift(t().expressionStatement(t().assignmentExpression("=", t().cloneNode(temp), this.node)));
+      nodes.push(t().expressionStatement(t().cloneNode(temp)));
+    }
+
+    return this.replaceExpressionWithStatements(nodes);
+  } else if (Array.isArray(this.container)) {
+    return this._containerInsertAfter(nodes);
+  } else if (this.isStatementOrBlock()) {
+    const shouldInsertCurrentNode = this.node && (!this.isExpressionStatement() || this.node.expression != null);
+    this.replaceWith(t().blockStatement(shouldInsertCurrentNode ? [this.node] : []));
+    return this.pushContainer("body", nodes);
+  } else {
+    throw new Error("We don't know what to do with this node type. " + "We were previously a Statement but we can't fit in here?");
+  }
+}
+
+function updateSiblingKeys(fromIndex, incrementBy) {
+  if (!this.parent) return;
+
+  const paths = _cache.path.get(this.parent);
+
+  for (let i = 0; i < paths.length; i++) {
+    const path = paths[i];
+
+    if (path.key >= fromIndex) {
+      path.key += incrementBy;
+    }
+  }
+}
+
+function _verifyNodeList(nodes) {
+  if (!nodes) {
+    return [];
+  }
+
+  if (nodes.constructor !== Array) {
+    nodes = [nodes];
+  }
+
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    let msg;
+
+    if (!node) {
+      msg = "has falsy node";
+    } else if (typeof node !== "object") {
+      msg = "contains a non-object node";
+    } else if (!node.type) {
+      msg = "without a type";
+    } else if (node instanceof _index.default) {
+      msg = "has a NodePath when it expected a raw object";
+    }
+
+    if (msg) {
+      const type = Array.isArray(node) ? "array" : typeof node;
+      throw new Error(`Node list ${msg} with the index of ${i} and type of ${type}`);
+    }
+  }
+
+  return nodes;
+}
+
+function unshiftContainer(listKey, nodes) {
+  this._assertUnremoved();
+
+  nodes = this._verifyNodeList(nodes);
+
+  const path = _index.default.get({
+    parentPath: this,
+    parent: this.node,
+    container: this.node[listKey],
+    listKey,
+    key: 0
+  });
+
+  return path.insertBefore(nodes);
+}
+
+function pushContainer(listKey, nodes) {
+  this._assertUnremoved();
+
+  nodes = this._verifyNodeList(nodes);
+  const container = this.node[listKey];
+
+  const path = _index.default.get({
+    parentPath: this,
+    parent: this.node,
+    container: container,
+    listKey,
+    key: container.length
+  });
+
+  return path.replaceWithMultiple(nodes);
+}
+
+function hoist(scope = this.scope) {
+  const hoister = new _hoister.default(this, scope);
+  return hoister.run();
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/removal.js b/node_modules/@babel/traverse/lib/path/removal.js
new file mode 100644
index 00000000..9f4ba97b
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/removal.js
@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.remove = remove;
+exports._removeFromScope = _removeFromScope;
+exports._callRemovalHooks = _callRemovalHooks;
+exports._remove = _remove;
+exports._markRemoved = _markRemoved;
+exports._assertUnremoved = _assertUnremoved;
+
+var _removalHooks = require("./lib/removal-hooks");
+
+function remove() {
+  this._assertUnremoved();
+
+  this.resync();
+
+  this._removeFromScope();
+
+  if (this._callRemovalHooks()) {
+    this._markRemoved();
+
+    return;
+  }
+
+  this.shareCommentsWithSiblings();
+
+  this._remove();
+
+  this._markRemoved();
+}
+
+function _removeFromScope() {
+  const bindings = this.getBindingIdentifiers();
+  Object.keys(bindings).forEach(name => this.scope.removeBinding(name));
+}
+
+function _callRemovalHooks() {
+  var _arr = _removalHooks.hooks;
+
+  for (var _i = 0; _i < _arr.length; _i++) {
+    const fn = _arr[_i];
+    if (fn(this, this.parentPath)) return true;
+  }
+}
+
+function _remove() {
+  if (Array.isArray(this.container)) {
+    this.container.splice(this.key, 1);
+    this.updateSiblingKeys(this.key, -1);
+  } else {
+    this._replaceWith(null);
+  }
+}
+
+function _markRemoved() {
+  this.shouldSkip = true;
+  this.removed = true;
+  this.node = null;
+}
+
+function _assertUnremoved() {
+  if (this.removed) {
+    throw this.buildCodeFrameError("NodePath has been removed so is read-only.");
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/path/replacement.js b/node_modules/@babel/traverse/lib/path/replacement.js
new file mode 100644
index 00000000..011eb312
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/path/replacement.js
@@ -0,0 +1,273 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.replaceWithMultiple = replaceWithMultiple;
+exports.replaceWithSourceString = replaceWithSourceString;
+exports.replaceWith = replaceWith;
+exports._replaceWith = _replaceWith;
+exports.replaceExpressionWithStatements = replaceExpressionWithStatements;
+exports.replaceInline = replaceInline;
+
+function _codeFrame() {
+  const data = require("@babel/code-frame");
+
+  _codeFrame = function _codeFrame() {
+    return data;
+  };
+
+  return data;
+}
+
+var _index = _interopRequireDefault(require("../index"));
+
+var _index2 = _interopRequireDefault(require("./index"));
+
+function _babylon() {
+  const data = require("babylon");
+
+  _babylon = function _babylon() {
+    return data;
+  };
+
+  return data;
+}
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const hoistVariablesVisitor = {
+  Function(path) {
+    path.skip();
+  },
+
+  VariableDeclaration(path) {
+    if (path.node.kind !== "var") return;
+    const bindings = path.getBindingIdentifiers();
+
+    for (const key in bindings) {
+      path.scope.push({
+        id: bindings[key]
+      });
+    }
+
+    const exprs = [];
+    var _arr = path.node.declarations;
+
+    for (var _i = 0; _i < _arr.length; _i++) {
+      const declar = _arr[_i];
+
+      if (declar.init) {
+        exprs.push(t().expressionStatement(t().assignmentExpression("=", declar.id, declar.init)));
+      }
+    }
+
+    path.replaceWithMultiple(exprs);
+  }
+
+};
+
+function replaceWithMultiple(nodes) {
+  this.resync();
+  nodes = this._verifyNodeList(nodes);
+  t().inheritLeadingComments(nodes[0], this.node);
+  t().inheritTrailingComments(nodes[nodes.length - 1], this.node);
+  this.node = this.container[this.key] = null;
+  const paths = this.insertAfter(nodes);
+
+  if (this.node) {
+    this.requeue();
+  } else {
+    this.remove();
+  }
+
+  return paths;
+}
+
+function replaceWithSourceString(replacement) {
+  this.resync();
+
+  try {
+    replacement = `(${replacement})`;
+    replacement = (0, _babylon().parse)(replacement);
+  } catch (err) {
+    const loc = err.loc;
+
+    if (loc) {
+      err.message += " - make sure this is an expression.\n" + (0, _codeFrame().codeFrameColumns)(replacement, {
+        start: {
+          line: loc.line,
+          column: loc.column + 1
+        }
+      });
+      err.code = "BABEL_REPLACE_SOURCE_ERROR";
+    }
+
+    throw err;
+  }
+
+  replacement = replacement.program.body[0].expression;
+
+  _index.default.removeProperties(replacement);
+
+  return this.replaceWith(replacement);
+}
+
+function replaceWith(replacement) {
+  this.resync();
+
+  if (this.removed) {
+    throw new Error("You can't replace this node, we've already removed it");
+  }
+
+  if (replacement instanceof _index2.default) {
+    replacement = replacement.node;
+  }
+
+  if (!replacement) {
+    throw new Error("You passed `path.replaceWith()` a falsy node, use `path.remove()` instead");
+  }
+
+  if (this.node === replacement) {
+    return [this];
+  }
+
+  if (this.isProgram() && !t().isProgram(replacement)) {
+    throw new Error("You can only replace a Program root node with another Program node");
+  }
+
+  if (Array.isArray(replacement)) {
+    throw new Error("Don't use `path.replaceWith()` with an array of nodes, use `path.replaceWithMultiple()`");
+  }
+
+  if (typeof replacement === "string") {
+    throw new Error("Don't use `path.replaceWith()` with a source string, use `path.replaceWithSourceString()`");
+  }
+
+  let nodePath = "";
+
+  if (this.isNodeType("Statement") && t().isExpression(replacement)) {
+    if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement) && !this.parentPath.isExportDefaultDeclaration()) {
+      replacement = t().expressionStatement(replacement);
+      nodePath = "expression";
+    }
+  }
+
+  if (this.isNodeType("Expression") && t().isStatement(replacement)) {
+    if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement)) {
+      return this.replaceExpressionWithStatements([replacement]);
+    }
+  }
+
+  const oldNode = this.node;
+
+  if (oldNode) {
+    t().inheritsComments(replacement, oldNode);
+    t().removeComments(oldNode);
+  }
+
+  this._replaceWith(replacement);
+
+  this.type = replacement.type;
+  this.setScope();
+  this.requeue();
+  return [nodePath ? this.get(nodePath) : this];
+}
+
+function _replaceWith(node) {
+  if (!this.container) {
+    throw new ReferenceError("Container is falsy");
+  }
+
+  if (this.inList) {
+    t().validate(this.parent, this.key, [node]);
+  } else {
+    t().validate(this.parent, this.key, node);
+  }
+
+  this.debug(`Replace with ${node && node.type}`);
+  this.node = this.container[this.key] = node;
+}
+
+function replaceExpressionWithStatements(nodes) {
+  this.resync();
+  const toSequenceExpression = t().toSequenceExpression(nodes, this.scope);
+
+  if (toSequenceExpression) {
+    return this.replaceWith(toSequenceExpression)[0].get("expressions");
+  }
+
+  const container = t().arrowFunctionExpression([], t().blockStatement(nodes));
+  this.replaceWith(t().callExpression(container, []));
+  this.traverse(hoistVariablesVisitor);
+  const completionRecords = this.get("callee").getCompletionRecords();
+
+  for (var _iterator = completionRecords, _isArray = Array.isArray(_iterator), _i2 = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref;
+
+    if (_isArray) {
+      if (_i2 >= _iterator.length) break;
+      _ref = _iterator[_i2++];
+    } else {
+      _i2 = _iterator.next();
+      if (_i2.done) break;
+      _ref = _i2.value;
+    }
+
+    const path = _ref;
+    if (!path.isExpressionStatement()) continue;
+    const loop = path.findParent(path => path.isLoop());
+
+    if (loop) {
+      let uid = loop.getData("expressionReplacementReturnUid");
+
+      if (!uid) {
+        const callee = this.get("callee");
+        uid = callee.scope.generateDeclaredUidIdentifier("ret");
+        callee.get("body").pushContainer("body", t().returnStatement(t().cloneNode(uid)));
+        loop.setData("expressionReplacementReturnUid", uid);
+      } else {
+        uid = t().identifier(uid.name);
+      }
+
+      path.get("expression").replaceWith(t().assignmentExpression("=", t().cloneNode(uid), path.node.expression));
+    } else {
+      path.replaceWith(t().returnStatement(path.node.expression));
+    }
+  }
+
+  const callee = this.get("callee");
+  callee.arrowFunctionToExpression();
+  return callee.get("body.body");
+}
+
+function replaceInline(nodes) {
+  this.resync();
+
+  if (Array.isArray(nodes)) {
+    if (Array.isArray(this.container)) {
+      nodes = this._verifyNodeList(nodes);
+
+      const paths = this._containerInsertAfter(nodes);
+
+      this.remove();
+      return paths;
+    } else {
+      return this.replaceWithMultiple(nodes);
+    }
+  } else {
+    return this.replaceWith(nodes);
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/scope/binding.js b/node_modules/@babel/traverse/lib/scope/binding.js
new file mode 100644
index 00000000..d19f1168
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/scope/binding.js
@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+class Binding {
+  constructor({
+    identifier,
+    scope,
+    path,
+    kind
+  }) {
+    this.identifier = identifier;
+    this.scope = scope;
+    this.path = path;
+    this.kind = kind;
+    this.constantViolations = [];
+    this.constant = true;
+    this.referencePaths = [];
+    this.referenced = false;
+    this.references = 0;
+    this.clearValue();
+  }
+
+  deoptValue() {
+    this.clearValue();
+    this.hasDeoptedValue = true;
+  }
+
+  setValue(value) {
+    if (this.hasDeoptedValue) return;
+    this.hasValue = true;
+    this.value = value;
+  }
+
+  clearValue() {
+    this.hasDeoptedValue = false;
+    this.hasValue = false;
+    this.value = null;
+  }
+
+  reassign(path) {
+    this.constant = false;
+
+    if (this.constantViolations.indexOf(path) !== -1) {
+      return;
+    }
+
+    this.constantViolations.push(path);
+  }
+
+  reference(path) {
+    if (this.referencePaths.indexOf(path) !== -1) {
+      return;
+    }
+
+    this.referenced = true;
+    this.references++;
+    this.referencePaths.push(path);
+  }
+
+  dereference() {
+    this.references--;
+    this.referenced = !!this.references;
+  }
+
+}
+
+exports.default = Binding;
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/scope/index.js b/node_modules/@babel/traverse/lib/scope/index.js
new file mode 100644
index 00000000..4c200ba6
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/scope/index.js
@@ -0,0 +1,1006 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _includes() {
+  const data = _interopRequireDefault(require("lodash/includes"));
+
+  _includes = function _includes() {
+    return data;
+  };
+
+  return data;
+}
+
+function _repeat() {
+  const data = _interopRequireDefault(require("lodash/repeat"));
+
+  _repeat = function _repeat() {
+    return data;
+  };
+
+  return data;
+}
+
+var _renamer = _interopRequireDefault(require("./lib/renamer"));
+
+var _index = _interopRequireDefault(require("../index"));
+
+function _defaults() {
+  const data = _interopRequireDefault(require("lodash/defaults"));
+
+  _defaults = function _defaults() {
+    return data;
+  };
+
+  return data;
+}
+
+var _binding = _interopRequireDefault(require("./binding"));
+
+function _globals() {
+  const data = _interopRequireDefault(require("globals"));
+
+  _globals = function _globals() {
+    return data;
+  };
+
+  return data;
+}
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+var _cache = require("../cache");
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function gatherNodeParts(node, parts) {
+  if (t().isModuleDeclaration(node)) {
+    if (node.source) {
+      gatherNodeParts(node.source, parts);
+    } else if (node.specifiers && node.specifiers.length) {
+      var _arr = node.specifiers;
+
+      for (var _i = 0; _i < _arr.length; _i++) {
+        const specifier = _arr[_i];
+        gatherNodeParts(specifier, parts);
+      }
+    } else if (node.declaration) {
+      gatherNodeParts(node.declaration, parts);
+    }
+  } else if (t().isModuleSpecifier(node)) {
+    gatherNodeParts(node.local, parts);
+  } else if (t().isMemberExpression(node)) {
+    gatherNodeParts(node.object, parts);
+    gatherNodeParts(node.property, parts);
+  } else if (t().isIdentifier(node)) {
+    parts.push(node.name);
+  } else if (t().isLiteral(node)) {
+    parts.push(node.value);
+  } else if (t().isCallExpression(node)) {
+    gatherNodeParts(node.callee, parts);
+  } else if (t().isObjectExpression(node) || t().isObjectPattern(node)) {
+    var _arr2 = node.properties;
+
+    for (var _i2 = 0; _i2 < _arr2.length; _i2++) {
+      const prop = _arr2[_i2];
+      gatherNodeParts(prop.key || prop.argument, parts);
+    }
+  } else if (t().isPrivateName(node)) {
+    gatherNodeParts(node.id, parts);
+  } else if (t().isThisExpression(node)) {
+    parts.push("this");
+  } else if (t().isSuper(node)) {
+    parts.push("super");
+  }
+}
+
+const collectorVisitor = {
+  For(path) {
+    var _arr3 = t().FOR_INIT_KEYS;
+
+    for (var _i3 = 0; _i3 < _arr3.length; _i3++) {
+      const key = _arr3[_i3];
+      const declar = path.get(key);
+
+      if (declar.isVar()) {
+        const parentScope = path.scope.getFunctionParent() || path.scope.getProgramParent();
+        parentScope.registerBinding("var", declar);
+      }
+    }
+  },
+
+  Declaration(path) {
+    if (path.isBlockScoped()) return;
+
+    if (path.isExportDeclaration() && path.get("declaration").isDeclaration()) {
+      return;
+    }
+
+    const parent = path.scope.getFunctionParent() || path.scope.getProgramParent();
+    parent.registerDeclaration(path);
+  },
+
+  ReferencedIdentifier(path, state) {
+    state.references.push(path);
+  },
+
+  ForXStatement(path, state) {
+    const left = path.get("left");
+
+    if (left.isPattern() || left.isIdentifier()) {
+      state.constantViolations.push(path);
+    }
+  },
+
+  ExportDeclaration: {
+    exit(path) {
+      const node = path.node,
+            scope = path.scope;
+      const declar = node.declaration;
+
+      if (t().isClassDeclaration(declar) || t().isFunctionDeclaration(declar)) {
+        const id = declar.id;
+        if (!id) return;
+        const binding = scope.getBinding(id.name);
+        if (binding) binding.reference(path);
+      } else if (t().isVariableDeclaration(declar)) {
+        var _arr4 = declar.declarations;
+
+        for (var _i4 = 0; _i4 < _arr4.length; _i4++) {
+          const decl = _arr4[_i4];
+          const ids = t().getBindingIdentifiers(decl);
+
+          for (const name in ids) {
+            const binding = scope.getBinding(name);
+            if (binding) binding.reference(path);
+          }
+        }
+      }
+    }
+
+  },
+
+  LabeledStatement(path) {
+    path.scope.getProgramParent().addGlobal(path.node);
+    path.scope.getBlockParent().registerDeclaration(path);
+  },
+
+  AssignmentExpression(path, state) {
+    state.assignments.push(path);
+  },
+
+  UpdateExpression(path, state) {
+    state.constantViolations.push(path);
+  },
+
+  UnaryExpression(path, state) {
+    if (path.node.operator === "delete") {
+      state.constantViolations.push(path);
+    }
+  },
+
+  BlockScoped(path) {
+    let scope = path.scope;
+    if (scope.path === path) scope = scope.parent;
+    scope.getBlockParent().registerDeclaration(path);
+  },
+
+  ClassDeclaration(path) {
+    const id = path.node.id;
+    if (!id) return;
+    const name = id.name;
+    path.scope.bindings[name] = path.scope.getBinding(name);
+  },
+
+  Block(path) {
+    const paths = path.get("body");
+    var _arr5 = paths;
+
+    for (var _i5 = 0; _i5 < _arr5.length; _i5++) {
+      const bodyPath = _arr5[_i5];
+
+      if (bodyPath.isFunctionDeclaration()) {
+        path.scope.getBlockParent().registerDeclaration(bodyPath);
+      }
+    }
+  }
+
+};
+let uid = 0;
+
+class Scope {
+  constructor(path) {
+    const node = path.node;
+
+    const cached = _cache.scope.get(node);
+
+    if (cached && cached.path === path) {
+      return cached;
+    }
+
+    _cache.scope.set(node, this);
+
+    this.uid = uid++;
+    this.block = node;
+    this.path = path;
+    this.labels = new Map();
+  }
+
+  get parent() {
+    const parent = this.path.findParent(p => p.isScope());
+    return parent && parent.scope;
+  }
+
+  get parentBlock() {
+    return this.path.parent;
+  }
+
+  get hub() {
+    return this.path.hub;
+  }
+
+  traverse(node, opts, state) {
+    (0, _index.default)(node, opts, this, state, this.path);
+  }
+
+  generateDeclaredUidIdentifier(name) {
+    const id = this.generateUidIdentifier(name);
+    this.push({
+      id
+    });
+    return t().cloneNode(id);
+  }
+
+  generateUidIdentifier(name) {
+    return t().identifier(this.generateUid(name));
+  }
+
+  generateUid(name = "temp") {
+    name = t().toIdentifier(name).replace(/^_+/, "").replace(/[0-9]+$/g, "");
+    let uid;
+    let i = 0;
+
+    do {
+      uid = this._generateUid(name, i);
+      i++;
+    } while (this.hasLabel(uid) || this.hasBinding(uid) || this.hasGlobal(uid) || this.hasReference(uid));
+
+    const program = this.getProgramParent();
+    program.references[uid] = true;
+    program.uids[uid] = true;
+    return uid;
+  }
+
+  _generateUid(name, i) {
+    let id = name;
+    if (i > 1) id += i;
+    return `_${id}`;
+  }
+
+  generateUidBasedOnNode(parent, defaultName) {
+    let node = parent;
+
+    if (t().isAssignmentExpression(parent)) {
+      node = parent.left;
+    } else if (t().isVariableDeclarator(parent)) {
+      node = parent.id;
+    } else if (t().isObjectProperty(node) || t().isObjectMethod(node)) {
+      node = node.key;
+    }
+
+    const parts = [];
+    gatherNodeParts(node, parts);
+    let id = parts.join("$");
+    id = id.replace(/^_/, "") || defaultName || "ref";
+    return this.generateUid(id.slice(0, 20));
+  }
+
+  generateUidIdentifierBasedOnNode(parent, defaultName) {
+    return t().identifier(this.generateUidBasedOnNode(parent, defaultName));
+  }
+
+  isStatic(node) {
+    if (t().isThisExpression(node) || t().isSuper(node)) {
+      return true;
+    }
+
+    if (t().isIdentifier(node)) {
+      const binding = this.getBinding(node.name);
+
+      if (binding) {
+        return binding.constant;
+      } else {
+        return this.hasBinding(node.name);
+      }
+    }
+
+    return false;
+  }
+
+  maybeGenerateMemoised(node, dontPush) {
+    if (this.isStatic(node)) {
+      return null;
+    } else {
+      const id = this.generateUidIdentifierBasedOnNode(node);
+
+      if (!dontPush) {
+        this.push({
+          id
+        });
+        return t().cloneNode(id);
+      }
+
+      return id;
+    }
+  }
+
+  checkBlockScopedCollisions(local, kind, name, id) {
+    if (kind === "param") return;
+    if (local.kind === "local") return;
+    if (kind === "hoisted" && local.kind === "let") return;
+    const duplicate = kind === "let" || local.kind === "let" || local.kind === "const" || local.kind === "module" || local.kind === "param" && (kind === "let" || kind === "const");
+
+    if (duplicate) {
+      throw this.hub.file.buildCodeFrameError(id, `Duplicate declaration "${name}"`, TypeError);
+    }
+  }
+
+  rename(oldName, newName, block) {
+    const binding = this.getBinding(oldName);
+
+    if (binding) {
+      newName = newName || this.generateUidIdentifier(oldName).name;
+      return new _renamer.default(binding, oldName, newName).rename(block);
+    }
+  }
+
+  _renameFromMap(map, oldName, newName, value) {
+    if (map[oldName]) {
+      map[newName] = value;
+      map[oldName] = null;
+    }
+  }
+
+  dump() {
+    const sep = (0, _repeat().default)("-", 60);
+    console.log(sep);
+    let scope = this;
+
+    do {
+      console.log("#", scope.block.type);
+
+      for (const name in scope.bindings) {
+        const binding = scope.bindings[name];
+        console.log(" -", name, {
+          constant: binding.constant,
+          references: binding.references,
+          violations: binding.constantViolations.length,
+          kind: binding.kind
+        });
+      }
+    } while (scope = scope.parent);
+
+    console.log(sep);
+  }
+
+  toArray(node, i) {
+    const file = this.hub.file;
+
+    if (t().isIdentifier(node)) {
+      const binding = this.getBinding(node.name);
+
+      if (binding && binding.constant && binding.path.isGenericType("Array")) {
+        return node;
+      }
+    }
+
+    if (t().isArrayExpression(node)) {
+      return node;
+    }
+
+    if (t().isIdentifier(node, {
+      name: "arguments"
+    })) {
+      return t().callExpression(t().memberExpression(t().memberExpression(t().memberExpression(t().identifier("Array"), t().identifier("prototype")), t().identifier("slice")), t().identifier("call")), [node]);
+    }
+
+    let helperName;
+    const args = [node];
+
+    if (i === true) {
+      helperName = "toConsumableArray";
+    } else if (i) {
+      args.push(t().numericLiteral(i));
+      helperName = "slicedToArray";
+    } else {
+      helperName = "toArray";
+    }
+
+    return t().callExpression(file.addHelper(helperName), args);
+  }
+
+  hasLabel(name) {
+    return !!this.getLabel(name);
+  }
+
+  getLabel(name) {
+    return this.labels.get(name);
+  }
+
+  registerLabel(path) {
+    this.labels.set(path.node.label.name, path);
+  }
+
+  registerDeclaration(path) {
+    if (path.isFlow()) return;
+
+    if (path.isLabeledStatement()) {
+      this.registerLabel(path);
+    } else if (path.isFunctionDeclaration()) {
+      this.registerBinding("hoisted", path.get("id"), path);
+    } else if (path.isVariableDeclaration()) {
+      const declarations = path.get("declarations");
+      var _arr6 = declarations;
+
+      for (var _i6 = 0; _i6 < _arr6.length; _i6++) {
+        const declar = _arr6[_i6];
+        this.registerBinding(path.node.kind, declar);
+      }
+    } else if (path.isClassDeclaration()) {
+      this.registerBinding("let", path);
+    } else if (path.isImportDeclaration()) {
+      const specifiers = path.get("specifiers");
+      var _arr7 = specifiers;
+
+      for (var _i7 = 0; _i7 < _arr7.length; _i7++) {
+        const specifier = _arr7[_i7];
+        this.registerBinding("module", specifier);
+      }
+    } else if (path.isExportDeclaration()) {
+      const declar = path.get("declaration");
+
+      if (declar.isClassDeclaration() || declar.isFunctionDeclaration() || declar.isVariableDeclaration()) {
+        this.registerDeclaration(declar);
+      }
+    } else {
+      this.registerBinding("unknown", path);
+    }
+  }
+
+  buildUndefinedNode() {
+    if (this.hasBinding("undefined")) {
+      return t().unaryExpression("void", t().numericLiteral(0), true);
+    } else {
+      return t().identifier("undefined");
+    }
+  }
+
+  registerConstantViolation(path) {
+    const ids = path.getBindingIdentifiers();
+
+    for (const name in ids) {
+      const binding = this.getBinding(name);
+      if (binding) binding.reassign(path);
+    }
+  }
+
+  registerBinding(kind, path, bindingPath = path) {
+    if (!kind) throw new ReferenceError("no `kind`");
+
+    if (path.isVariableDeclaration()) {
+      const declarators = path.get("declarations");
+
+      for (var _iterator = declarators, _isArray = Array.isArray(_iterator), _i8 = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+        var _ref;
+
+        if (_isArray) {
+          if (_i8 >= _iterator.length) break;
+          _ref = _iterator[_i8++];
+        } else {
+          _i8 = _iterator.next();
+          if (_i8.done) break;
+          _ref = _i8.value;
+        }
+
+        const declar = _ref;
+        this.registerBinding(kind, declar);
+      }
+
+      return;
+    }
+
+    const parent = this.getProgramParent();
+    const ids = path.getBindingIdentifiers(true);
+
+    for (const name in ids) {
+      var _arr8 = ids[name];
+
+      for (var _i9 = 0; _i9 < _arr8.length; _i9++) {
+        const id = _arr8[_i9];
+        const local = this.getOwnBinding(name);
+
+        if (local) {
+          if (local.identifier === id) continue;
+          this.checkBlockScopedCollisions(local, kind, name, id);
+        }
+
+        parent.references[name] = true;
+
+        if (local) {
+          this.registerConstantViolation(bindingPath);
+        } else {
+          this.bindings[name] = new _binding.default({
+            identifier: id,
+            scope: this,
+            path: bindingPath,
+            kind: kind
+          });
+        }
+      }
+    }
+  }
+
+  addGlobal(node) {
+    this.globals[node.name] = node;
+  }
+
+  hasUid(name) {
+    let scope = this;
+
+    do {
+      if (scope.uids[name]) return true;
+    } while (scope = scope.parent);
+
+    return false;
+  }
+
+  hasGlobal(name) {
+    let scope = this;
+
+    do {
+      if (scope.globals[name]) return true;
+    } while (scope = scope.parent);
+
+    return false;
+  }
+
+  hasReference(name) {
+    let scope = this;
+
+    do {
+      if (scope.references[name]) return true;
+    } while (scope = scope.parent);
+
+    return false;
+  }
+
+  isPure(node, constantsOnly) {
+    if (t().isIdentifier(node)) {
+      const binding = this.getBinding(node.name);
+      if (!binding) return false;
+      if (constantsOnly) return binding.constant;
+      return true;
+    } else if (t().isClass(node)) {
+      if (node.superClass && !this.isPure(node.superClass, constantsOnly)) {
+        return false;
+      }
+
+      return this.isPure(node.body, constantsOnly);
+    } else if (t().isClassBody(node)) {
+      for (var _iterator2 = node.body, _isArray2 = Array.isArray(_iterator2), _i10 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+        var _ref2;
+
+        if (_isArray2) {
+          if (_i10 >= _iterator2.length) break;
+          _ref2 = _iterator2[_i10++];
+        } else {
+          _i10 = _iterator2.next();
+          if (_i10.done) break;
+          _ref2 = _i10.value;
+        }
+
+        const method = _ref2;
+        if (!this.isPure(method, constantsOnly)) return false;
+      }
+
+      return true;
+    } else if (t().isBinary(node)) {
+      return this.isPure(node.left, constantsOnly) && this.isPure(node.right, constantsOnly);
+    } else if (t().isArrayExpression(node)) {
+      var _arr9 = node.elements;
+
+      for (var _i11 = 0; _i11 < _arr9.length; _i11++) {
+        const elem = _arr9[_i11];
+        if (!this.isPure(elem, constantsOnly)) return false;
+      }
+
+      return true;
+    } else if (t().isObjectExpression(node)) {
+      var _arr10 = node.properties;
+
+      for (var _i12 = 0; _i12 < _arr10.length; _i12++) {
+        const prop = _arr10[_i12];
+        if (!this.isPure(prop, constantsOnly)) return false;
+      }
+
+      return true;
+    } else if (t().isClassMethod(node)) {
+      if (node.computed && !this.isPure(node.key, constantsOnly)) return false;
+      if (node.kind === "get" || node.kind === "set") return false;
+      return true;
+    } else if (t().isProperty(node)) {
+      if (node.computed && !this.isPure(node.key, constantsOnly)) return false;
+      return this.isPure(node.value, constantsOnly);
+    } else if (t().isUnaryExpression(node)) {
+      return this.isPure(node.argument, constantsOnly);
+    } else if (t().isTaggedTemplateExpression(node)) {
+      return t().matchesPattern(node.tag, "String.raw") && !this.hasBinding("String", true) && this.isPure(node.quasi, constantsOnly);
+    } else if (t().isTemplateLiteral(node)) {
+      var _arr11 = node.expressions;
+
+      for (var _i13 = 0; _i13 < _arr11.length; _i13++) {
+        const expression = _arr11[_i13];
+        if (!this.isPure(expression, constantsOnly)) return false;
+      }
+
+      return true;
+    } else {
+      return t().isPureish(node);
+    }
+  }
+
+  setData(key, val) {
+    return this.data[key] = val;
+  }
+
+  getData(key) {
+    let scope = this;
+
+    do {
+      const data = scope.data[key];
+      if (data != null) return data;
+    } while (scope = scope.parent);
+  }
+
+  removeData(key) {
+    let scope = this;
+
+    do {
+      const data = scope.data[key];
+      if (data != null) scope.data[key] = null;
+    } while (scope = scope.parent);
+  }
+
+  init() {
+    if (!this.references) this.crawl();
+  }
+
+  crawl() {
+    const path = this.path;
+    this.references = Object.create(null);
+    this.bindings = Object.create(null);
+    this.globals = Object.create(null);
+    this.uids = Object.create(null);
+    this.data = Object.create(null);
+
+    if (path.isLoop()) {
+      var _arr12 = t().FOR_INIT_KEYS;
+
+      for (var _i14 = 0; _i14 < _arr12.length; _i14++) {
+        const key = _arr12[_i14];
+        const node = path.get(key);
+        if (node.isBlockScoped()) this.registerBinding(node.node.kind, node);
+      }
+    }
+
+    if (path.isFunctionExpression() && path.has("id")) {
+      if (!path.get("id").node[t().NOT_LOCAL_BINDING]) {
+        this.registerBinding("local", path.get("id"), path);
+      }
+    }
+
+    if (path.isClassExpression() && path.has("id")) {
+      if (!path.get("id").node[t().NOT_LOCAL_BINDING]) {
+        this.registerBinding("local", path);
+      }
+    }
+
+    if (path.isFunction()) {
+      const params = path.get("params");
+
+      for (var _iterator3 = params, _isArray3 = Array.isArray(_iterator3), _i15 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
+        var _ref3;
+
+        if (_isArray3) {
+          if (_i15 >= _iterator3.length) break;
+          _ref3 = _iterator3[_i15++];
+        } else {
+          _i15 = _iterator3.next();
+          if (_i15.done) break;
+          _ref3 = _i15.value;
+        }
+
+        const param = _ref3;
+        this.registerBinding("param", param);
+      }
+    }
+
+    if (path.isCatchClause()) {
+      this.registerBinding("let", path);
+    }
+
+    const parent = this.getProgramParent();
+    if (parent.crawling) return;
+    const state = {
+      references: [],
+      constantViolations: [],
+      assignments: []
+    };
+    this.crawling = true;
+    path.traverse(collectorVisitor, state);
+    this.crawling = false;
+
+    for (var _iterator4 = state.assignments, _isArray4 = Array.isArray(_iterator4), _i16 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
+      var _ref4;
+
+      if (_isArray4) {
+        if (_i16 >= _iterator4.length) break;
+        _ref4 = _iterator4[_i16++];
+      } else {
+        _i16 = _iterator4.next();
+        if (_i16.done) break;
+        _ref4 = _i16.value;
+      }
+
+      const path = _ref4;
+      const ids = path.getBindingIdentifiers();
+      let programParent;
+
+      for (const name in ids) {
+        if (path.scope.getBinding(name)) continue;
+        programParent = programParent || path.scope.getProgramParent();
+        programParent.addGlobal(ids[name]);
+      }
+
+      path.scope.registerConstantViolation(path);
+    }
+
+    for (var _iterator5 = state.references, _isArray5 = Array.isArray(_iterator5), _i17 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) {
+      var _ref5;
+
+      if (_isArray5) {
+        if (_i17 >= _iterator5.length) break;
+        _ref5 = _iterator5[_i17++];
+      } else {
+        _i17 = _iterator5.next();
+        if (_i17.done) break;
+        _ref5 = _i17.value;
+      }
+
+      const ref = _ref5;
+      const binding = ref.scope.getBinding(ref.node.name);
+
+      if (binding) {
+        binding.reference(ref);
+      } else {
+        ref.scope.getProgramParent().addGlobal(ref.node);
+      }
+    }
+
+    for (var _iterator6 = state.constantViolations, _isArray6 = Array.isArray(_iterator6), _i18 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) {
+      var _ref6;
+
+      if (_isArray6) {
+        if (_i18 >= _iterator6.length) break;
+        _ref6 = _iterator6[_i18++];
+      } else {
+        _i18 = _iterator6.next();
+        if (_i18.done) break;
+        _ref6 = _i18.value;
+      }
+
+      const path = _ref6;
+      path.scope.registerConstantViolation(path);
+    }
+  }
+
+  push(opts) {
+    let path = this.path;
+
+    if (!path.isBlockStatement() && !path.isProgram()) {
+      path = this.getBlockParent().path;
+    }
+
+    if (path.isSwitchStatement()) {
+      path = (this.getFunctionParent() || this.getProgramParent()).path;
+    }
+
+    if (path.isLoop() || path.isCatchClause() || path.isFunction()) {
+      path.ensureBlock();
+      path = path.get("body");
+    }
+
+    const unique = opts.unique;
+    const kind = opts.kind || "var";
+    const blockHoist = opts._blockHoist == null ? 2 : opts._blockHoist;
+    const dataKey = `declaration:${kind}:${blockHoist}`;
+    let declarPath = !unique && path.getData(dataKey);
+
+    if (!declarPath) {
+      const declar = t().variableDeclaration(kind, []);
+      declar._blockHoist = blockHoist;
+
+      var _path$unshiftContaine = path.unshiftContainer("body", [declar]);
+
+      declarPath = _path$unshiftContaine[0];
+      if (!unique) path.setData(dataKey, declarPath);
+    }
+
+    const declarator = t().variableDeclarator(opts.id, opts.init);
+    declarPath.node.declarations.push(declarator);
+    this.registerBinding(kind, declarPath.get("declarations").pop());
+  }
+
+  getProgramParent() {
+    let scope = this;
+
+    do {
+      if (scope.path.isProgram()) {
+        return scope;
+      }
+    } while (scope = scope.parent);
+
+    throw new Error("Couldn't find a Program");
+  }
+
+  getFunctionParent() {
+    let scope = this;
+
+    do {
+      if (scope.path.isFunctionParent()) {
+        return scope;
+      }
+    } while (scope = scope.parent);
+
+    return null;
+  }
+
+  getBlockParent() {
+    let scope = this;
+
+    do {
+      if (scope.path.isBlockParent()) {
+        return scope;
+      }
+    } while (scope = scope.parent);
+
+    throw new Error("We couldn't find a BlockStatement, For, Switch, Function, Loop or Program...");
+  }
+
+  getAllBindings() {
+    const ids = Object.create(null);
+    let scope = this;
+
+    do {
+      (0, _defaults().default)(ids, scope.bindings);
+      scope = scope.parent;
+    } while (scope);
+
+    return ids;
+  }
+
+  getAllBindingsOfKind() {
+    const ids = Object.create(null);
+    var _arr13 = arguments;
+
+    for (var _i19 = 0; _i19 < _arr13.length; _i19++) {
+      const kind = _arr13[_i19];
+      let scope = this;
+
+      do {
+        for (const name in scope.bindings) {
+          const binding = scope.bindings[name];
+          if (binding.kind === kind) ids[name] = binding;
+        }
+
+        scope = scope.parent;
+      } while (scope);
+    }
+
+    return ids;
+  }
+
+  bindingIdentifierEquals(name, node) {
+    return this.getBindingIdentifier(name) === node;
+  }
+
+  getBinding(name) {
+    let scope = this;
+
+    do {
+      const binding = scope.getOwnBinding(name);
+      if (binding) return binding;
+    } while (scope = scope.parent);
+  }
+
+  getOwnBinding(name) {
+    return this.bindings[name];
+  }
+
+  getBindingIdentifier(name) {
+    const info = this.getBinding(name);
+    return info && info.identifier;
+  }
+
+  getOwnBindingIdentifier(name) {
+    const binding = this.bindings[name];
+    return binding && binding.identifier;
+  }
+
+  hasOwnBinding(name) {
+    return !!this.getOwnBinding(name);
+  }
+
+  hasBinding(name, noGlobals) {
+    if (!name) return false;
+    if (this.hasOwnBinding(name)) return true;
+    if (this.parentHasBinding(name, noGlobals)) return true;
+    if (this.hasUid(name)) return true;
+    if (!noGlobals && (0, _includes().default)(Scope.globals, name)) return true;
+    if (!noGlobals && (0, _includes().default)(Scope.contextVariables, name)) return true;
+    return false;
+  }
+
+  parentHasBinding(name, noGlobals) {
+    return this.parent && this.parent.hasBinding(name, noGlobals);
+  }
+
+  moveBindingTo(name, scope) {
+    const info = this.getBinding(name);
+
+    if (info) {
+      info.scope.removeOwnBinding(name);
+      info.scope = scope;
+      scope.bindings[name] = info;
+    }
+  }
+
+  removeOwnBinding(name) {
+    delete this.bindings[name];
+  }
+
+  removeBinding(name) {
+    const info = this.getBinding(name);
+
+    if (info) {
+      info.scope.removeOwnBinding(name);
+    }
+
+    let scope = this;
+
+    do {
+      if (scope.uids[name]) {
+        scope.uids[name] = false;
+      }
+    } while (scope = scope.parent);
+  }
+
+}
+
+exports.default = Scope;
+Scope.globals = Object.keys(_globals().default.builtin);
+Scope.contextVariables = ["arguments", "undefined", "Infinity", "NaN"];
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/scope/lib/renamer.js b/node_modules/@babel/traverse/lib/scope/lib/renamer.js
new file mode 100644
index 00000000..47016e47
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/scope/lib/renamer.js
@@ -0,0 +1,130 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _binding = _interopRequireDefault(require("../binding"));
+
+function _helperSplitExportDeclaration() {
+  const data = _interopRequireDefault(require("@babel/helper-split-export-declaration"));
+
+  _helperSplitExportDeclaration = function _helperSplitExportDeclaration() {
+    return data;
+  };
+
+  return data;
+}
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const renameVisitor = {
+  ReferencedIdentifier({
+    node
+  }, state) {
+    if (node.name === state.oldName) {
+      node.name = state.newName;
+    }
+  },
+
+  Scope(path, state) {
+    if (!path.scope.bindingIdentifierEquals(state.oldName, state.binding.identifier)) {
+      path.skip();
+    }
+  },
+
+  "AssignmentExpression|Declaration"(path, state) {
+    const ids = path.getOuterBindingIdentifiers();
+
+    for (const name in ids) {
+      if (name === state.oldName) ids[name].name = state.newName;
+    }
+  }
+
+};
+
+class Renamer {
+  constructor(binding, oldName, newName) {
+    this.newName = newName;
+    this.oldName = oldName;
+    this.binding = binding;
+  }
+
+  maybeConvertFromExportDeclaration(parentDeclar) {
+    const maybeExportDeclar = parentDeclar.parentPath;
+
+    if (!maybeExportDeclar.isExportDeclaration()) {
+      return;
+    }
+
+    if (maybeExportDeclar.isExportDefaultDeclaration() && !maybeExportDeclar.get("declaration").node.id) {
+      return;
+    }
+
+    (0, _helperSplitExportDeclaration().default)(maybeExportDeclar);
+  }
+
+  maybeConvertFromClassFunctionDeclaration(path) {
+    return;
+    if (!path.isFunctionDeclaration() && !path.isClassDeclaration()) return;
+    if (this.binding.kind !== "hoisted") return;
+    path.node.id = t().identifier(this.oldName);
+    path.node._blockHoist = 3;
+    path.replaceWith(t().variableDeclaration("let", [t().variableDeclarator(t().identifier(this.newName), t().toExpression(path.node))]));
+  }
+
+  maybeConvertFromClassFunctionExpression(path) {
+    return;
+    if (!path.isFunctionExpression() && !path.isClassExpression()) return;
+    if (this.binding.kind !== "local") return;
+    path.node.id = t().identifier(this.oldName);
+    this.binding.scope.parent.push({
+      id: t().identifier(this.newName)
+    });
+    path.replaceWith(t().assignmentExpression("=", t().identifier(this.newName), path.node));
+  }
+
+  rename(block) {
+    const binding = this.binding,
+          oldName = this.oldName,
+          newName = this.newName;
+    const scope = binding.scope,
+          path = binding.path;
+    const parentDeclar = path.find(path => path.isDeclaration() || path.isFunctionExpression() || path.isClassExpression());
+
+    if (parentDeclar) {
+      this.maybeConvertFromExportDeclaration(parentDeclar);
+    }
+
+    scope.traverse(block || scope.block, renameVisitor, this);
+
+    if (!block) {
+      scope.removeOwnBinding(oldName);
+      scope.bindings[newName] = binding;
+      this.binding.identifier.name = newName;
+    }
+
+    if (binding.type === "hoisted") {}
+
+    if (parentDeclar) {
+      this.maybeConvertFromClassFunctionDeclaration(parentDeclar);
+      this.maybeConvertFromClassFunctionExpression(parentDeclar);
+    }
+  }
+
+}
+
+exports.default = Renamer;
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/lib/visitors.js b/node_modules/@babel/traverse/lib/visitors.js
new file mode 100644
index 00000000..bff50dfc
--- /dev/null
+++ b/node_modules/@babel/traverse/lib/visitors.js
@@ -0,0 +1,298 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.explode = explode;
+exports.verify = verify;
+exports.merge = merge;
+
+var virtualTypes = _interopRequireWildcard(require("./path/lib/virtual-types"));
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _clone() {
+  const data = _interopRequireDefault(require("lodash/clone"));
+
+  _clone = function _clone() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function explode(visitor) {
+  if (visitor._exploded) return visitor;
+  visitor._exploded = true;
+
+  for (const nodeType in visitor) {
+    if (shouldIgnoreKey(nodeType)) continue;
+    const parts = nodeType.split("|");
+    if (parts.length === 1) continue;
+    const fns = visitor[nodeType];
+    delete visitor[nodeType];
+
+    for (var _iterator = parts, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i >= _iterator.length) break;
+        _ref = _iterator[_i++];
+      } else {
+        _i = _iterator.next();
+        if (_i.done) break;
+        _ref = _i.value;
+      }
+
+      const part = _ref;
+      visitor[part] = fns;
+    }
+  }
+
+  verify(visitor);
+  delete visitor.__esModule;
+  ensureEntranceObjects(visitor);
+  ensureCallbackArrays(visitor);
+
+  var _arr = Object.keys(visitor);
+
+  for (var _i2 = 0; _i2 < _arr.length; _i2++) {
+    const nodeType = _arr[_i2];
+    if (shouldIgnoreKey(nodeType)) continue;
+    const wrapper = virtualTypes[nodeType];
+    if (!wrapper) continue;
+    const fns = visitor[nodeType];
+
+    for (const type in fns) {
+      fns[type] = wrapCheck(wrapper, fns[type]);
+    }
+
+    delete visitor[nodeType];
+
+    if (wrapper.types) {
+      var _arr2 = wrapper.types;
+
+      for (var _i4 = 0; _i4 < _arr2.length; _i4++) {
+        const type = _arr2[_i4];
+
+        if (visitor[type]) {
+          mergePair(visitor[type], fns);
+        } else {
+          visitor[type] = fns;
+        }
+      }
+    } else {
+      mergePair(visitor, fns);
+    }
+  }
+
+  for (const nodeType in visitor) {
+    if (shouldIgnoreKey(nodeType)) continue;
+    const fns = visitor[nodeType];
+    let aliases = t().FLIPPED_ALIAS_KEYS[nodeType];
+    const deprecratedKey = t().DEPRECATED_KEYS[nodeType];
+
+    if (deprecratedKey) {
+      console.trace(`Visitor defined for ${nodeType} but it has been renamed to ${deprecratedKey}`);
+      aliases = [deprecratedKey];
+    }
+
+    if (!aliases) continue;
+    delete visitor[nodeType];
+
+    for (var _iterator2 = aliases, _isArray2 = Array.isArray(_iterator2), _i3 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+      var _ref2;
+
+      if (_isArray2) {
+        if (_i3 >= _iterator2.length) break;
+        _ref2 = _iterator2[_i3++];
+      } else {
+        _i3 = _iterator2.next();
+        if (_i3.done) break;
+        _ref2 = _i3.value;
+      }
+
+      const alias = _ref2;
+      const existing = visitor[alias];
+
+      if (existing) {
+        mergePair(existing, fns);
+      } else {
+        visitor[alias] = (0, _clone().default)(fns);
+      }
+    }
+  }
+
+  for (const nodeType in visitor) {
+    if (shouldIgnoreKey(nodeType)) continue;
+    ensureCallbackArrays(visitor[nodeType]);
+  }
+
+  return visitor;
+}
+
+function verify(visitor) {
+  if (visitor._verified) return;
+
+  if (typeof visitor === "function") {
+    throw new Error("You passed `traverse()` a function when it expected a visitor object, " + "are you sure you didn't mean `{ enter: Function }`?");
+  }
+
+  for (const nodeType in visitor) {
+    if (nodeType === "enter" || nodeType === "exit") {
+      validateVisitorMethods(nodeType, visitor[nodeType]);
+    }
+
+    if (shouldIgnoreKey(nodeType)) continue;
+
+    if (t().TYPES.indexOf(nodeType) < 0) {
+      throw new Error(`You gave us a visitor for the node type ${nodeType} but it's not a valid type`);
+    }
+
+    const visitors = visitor[nodeType];
+
+    if (typeof visitors === "object") {
+      for (const visitorKey in visitors) {
+        if (visitorKey === "enter" || visitorKey === "exit") {
+          validateVisitorMethods(`${nodeType}.${visitorKey}`, visitors[visitorKey]);
+        } else {
+          throw new Error("You passed `traverse()` a visitor object with the property " + `${nodeType} that has the invalid property ${visitorKey}`);
+        }
+      }
+    }
+  }
+
+  visitor._verified = true;
+}
+
+function validateVisitorMethods(path, val) {
+  const fns = [].concat(val);
+
+  for (var _iterator3 = fns, _isArray3 = Array.isArray(_iterator3), _i5 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
+    var _ref3;
+
+    if (_isArray3) {
+      if (_i5 >= _iterator3.length) break;
+      _ref3 = _iterator3[_i5++];
+    } else {
+      _i5 = _iterator3.next();
+      if (_i5.done) break;
+      _ref3 = _i5.value;
+    }
+
+    const fn = _ref3;
+
+    if (typeof fn !== "function") {
+      throw new TypeError(`Non-function found defined in ${path} with type ${typeof fn}`);
+    }
+  }
+}
+
+function merge(visitors, states = [], wrapper) {
+  const rootVisitor = {};
+
+  for (let i = 0; i < visitors.length; i++) {
+    const visitor = visitors[i];
+    const state = states[i];
+    explode(visitor);
+
+    for (const type in visitor) {
+      let visitorType = visitor[type];
+
+      if (state || wrapper) {
+        visitorType = wrapWithStateOrWrapper(visitorType, state, wrapper);
+      }
+
+      const nodeVisitor = rootVisitor[type] = rootVisitor[type] || {};
+      mergePair(nodeVisitor, visitorType);
+    }
+  }
+
+  return rootVisitor;
+}
+
+function wrapWithStateOrWrapper(oldVisitor, state, wrapper) {
+  const newVisitor = {};
+
+  for (const key in oldVisitor) {
+    let fns = oldVisitor[key];
+    if (!Array.isArray(fns)) continue;
+    fns = fns.map(function (fn) {
+      let newFn = fn;
+
+      if (state) {
+        newFn = function newFn(path) {
+          return fn.call(state, path, state);
+        };
+      }
+
+      if (wrapper) {
+        newFn = wrapper(state.key, key, newFn);
+      }
+
+      return newFn;
+    });
+    newVisitor[key] = fns;
+  }
+
+  return newVisitor;
+}
+
+function ensureEntranceObjects(obj) {
+  for (const key in obj) {
+    if (shouldIgnoreKey(key)) continue;
+    const fns = obj[key];
+
+    if (typeof fns === "function") {
+      obj[key] = {
+        enter: fns
+      };
+    }
+  }
+}
+
+function ensureCallbackArrays(obj) {
+  if (obj.enter && !Array.isArray(obj.enter)) obj.enter = [obj.enter];
+  if (obj.exit && !Array.isArray(obj.exit)) obj.exit = [obj.exit];
+}
+
+function wrapCheck(wrapper, fn) {
+  const newFn = function newFn(path) {
+    if (wrapper.checkPath(path)) {
+      return fn.apply(this, arguments);
+    }
+  };
+
+  newFn.toString = () => fn.toString();
+
+  return newFn;
+}
+
+function shouldIgnoreKey(key) {
+  if (key[0] === "_") return true;
+  if (key === "enter" || key === "exit" || key === "shouldSkip") return true;
+
+  if (key === "blacklist" || key === "noScope" || key === "skipKeys") {
+    return true;
+  }
+
+  return false;
+}
+
+function mergePair(dest, src) {
+  for (const key in src) {
+    dest[key] = [].concat(dest[key] || [], src[key]);
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/node_modules/.bin/babylon b/node_modules/@babel/traverse/node_modules/.bin/babylon
new file mode 120000
index 00000000..5acfefcc
--- /dev/null
+++ b/node_modules/@babel/traverse/node_modules/.bin/babylon
@@ -0,0 +1 @@
+../../../../babylon/bin/babylon.js
\ No newline at end of file
diff --git a/node_modules/@babel/traverse/node_modules/debug/CHANGELOG.md b/node_modules/@babel/traverse/node_modules/debug/CHANGELOG.md
new file mode 100644
index 00000000..820d21e3
--- /dev/null
+++ b/node_modules/@babel/traverse/node_modules/debug/CHANGELOG.md
@@ -0,0 +1,395 @@
+
+3.1.0 / 2017-09-26
+==================
+
+  * Add `DEBUG_HIDE_DATE` env var (#486)
+  * Remove ReDoS regexp in %o formatter (#504)
+  * Remove "component" from package.json
+  * Remove `component.json`
+  * Ignore package-lock.json
+  * Examples: fix colors printout
+  * Fix: browser detection
+  * Fix: spelling mistake (#496, @EdwardBetts)
+
+3.0.1 / 2017-08-24
+==================
+
+  * Fix: Disable colors in Edge and Internet Explorer (#489)
+
+3.0.0 / 2017-08-08
+==================
+
+  * Breaking: Remove DEBUG_FD (#406)
+  * Breaking: Use `Date#toISOString()` instead to `Date#toUTCString()` when output is not a TTY (#418)
+  * Breaking: Make millisecond timer namespace specific and allow 'always enabled' output (#408)
+  * Addition: document `enabled` flag (#465)
+  * Addition: add 256 colors mode (#481)
+  * Addition: `enabled()` updates existing debug instances, add `destroy()` function (#440)
+  * Update: component: update "ms" to v2.0.0
+  * Update: separate the Node and Browser tests in Travis-CI
+  * Update: refactor Readme, fixed documentation, added "Namespace Colors" section, redid screenshots
+  * Update: separate Node.js and web browser examples for organization
+  * Update: update "browserify" to v14.4.0
+  * Fix: fix Readme typo (#473)
+
+2.6.9 / 2017-09-22
+==================
+
+  * remove ReDoS regexp in %o formatter (#504)
+
+2.6.8 / 2017-05-18
+==================
+
+  * Fix: Check for undefined on browser globals (#462, @marbemac)
+
+2.6.7 / 2017-05-16
+==================
+
+  * Fix: Update ms to 2.0.0 to fix regular expression denial of service vulnerability (#458, @hubdotcom)
+  * Fix: Inline extend function in node implementation (#452, @dougwilson)
+  * Docs: Fix typo (#455, @msasad)
+
+2.6.5 / 2017-04-27
+==================
+  
+  * Fix: null reference check on window.documentElement.style.WebkitAppearance (#447, @thebigredgeek)
+  * Misc: clean up browser reference checks (#447, @thebigredgeek)
+  * Misc: add npm-debug.log to .gitignore (@thebigredgeek)
+
+
+2.6.4 / 2017-04-20
+==================
+
+  * Fix: bug that would occur if process.env.DEBUG is a non-string value. (#444, @LucianBuzzo)
+  * Chore: ignore bower.json in npm installations. (#437, @joaovieira)
+  * Misc: update "ms" to v0.7.3 (@tootallnate)
+
+2.6.3 / 2017-03-13
+==================
+
+  * Fix: Electron reference to `process.env.DEBUG` (#431, @paulcbetts)
+  * Docs: Changelog fix (@thebigredgeek)
+
+2.6.2 / 2017-03-10
+==================
+
+  * Fix: DEBUG_MAX_ARRAY_LENGTH (#420, @slavaGanzin)
+  * Docs: Add backers and sponsors from Open Collective (#422, @piamancini)
+  * Docs: Add Slackin invite badge (@tootallnate)
+
+2.6.1 / 2017-02-10
+==================
+
+  * Fix: Module's `export default` syntax fix for IE8 `Expected identifier` error
+  * Fix: Whitelist DEBUG_FD for values 1 and 2 only (#415, @pi0)
+  * Fix: IE8 "Expected identifier" error (#414, @vgoma)
+  * Fix: Namespaces would not disable once enabled (#409, @musikov)
+
+2.6.0 / 2016-12-28
+==================
+
+  * Fix: added better null pointer checks for browser useColors (@thebigredgeek)
+  * Improvement: removed explicit `window.debug` export (#404, @tootallnate)
+  * Improvement: deprecated `DEBUG_FD` environment variable (#405, @tootallnate)
+
+2.5.2 / 2016-12-25
+==================
+
+  * Fix: reference error on window within webworkers (#393, @KlausTrainer)
+  * Docs: fixed README typo (#391, @lurch)
+  * Docs: added notice about v3 api discussion (@thebigredgeek)
+
+2.5.1 / 2016-12-20
+==================
+
+  * Fix: babel-core compatibility
+
+2.5.0 / 2016-12-20
+==================
+
+  * Fix: wrong reference in bower file (@thebigredgeek)
+  * Fix: webworker compatibility (@thebigredgeek)
+  * Fix: output formatting issue (#388, @kribblo)
+  * Fix: babel-loader compatibility (#383, @escwald)
+  * Misc: removed built asset from repo and publications (@thebigredgeek)
+  * Misc: moved source files to /src (#378, @yamikuronue)
+  * Test: added karma integration and replaced babel with browserify for browser tests (#378, @yamikuronue)
+  * Test: coveralls integration (#378, @yamikuronue)
+  * Docs: simplified language in the opening paragraph (#373, @yamikuronue)
+
+2.4.5 / 2016-12-17
+==================
+
+  * Fix: `navigator` undefined in Rhino (#376, @jochenberger)
+  * Fix: custom log function (#379, @hsiliev)
+  * Improvement: bit of cleanup + linting fixes (@thebigredgeek)
+  * Improvement: rm non-maintainted `dist/` dir (#375, @freewil)
+  * Docs: simplified language in the opening paragraph. (#373, @yamikuronue)
+
+2.4.4 / 2016-12-14
+==================
+
+  * Fix: work around debug being loaded in preload scripts for electron (#368, @paulcbetts)
+
+2.4.3 / 2016-12-14
+==================
+
+  * Fix: navigation.userAgent error for react native (#364, @escwald)
+
+2.4.2 / 2016-12-14
+==================
+
+  * Fix: browser colors (#367, @tootallnate)
+  * Misc: travis ci integration (@thebigredgeek)
+  * Misc: added linting and testing boilerplate with sanity check (@thebigredgeek)
+
+2.4.1 / 2016-12-13
+==================
+
+  * Fix: typo that broke the package (#356)
+
+2.4.0 / 2016-12-13
+==================
+
+  * Fix: bower.json references unbuilt src entry point (#342, @justmatt)
+  * Fix: revert "handle regex special characters" (@tootallnate)
+  * Feature: configurable util.inspect()`options for NodeJS (#327, @tootallnate)
+  * Feature: %O`(big O) pretty-prints objects (#322, @tootallnate)
+  * Improvement: allow colors in workers (#335, @botverse)
+  * Improvement: use same color for same namespace. (#338, @lchenay)
+
+2.3.3 / 2016-11-09
+==================
+
+  * Fix: Catch `JSON.stringify()` errors (#195, Jovan Alleyne)
+  * Fix: Returning `localStorage` saved values (#331, Levi Thomason)
+  * Improvement: Don't create an empty object when no `process` (Nathan Rajlich)
+
+2.3.2 / 2016-11-09
+==================
+
+  * Fix: be super-safe in index.js as well (@TooTallNate)
+  * Fix: should check whether process exists (Tom Newby)
+
+2.3.1 / 2016-11-09
+==================
+
+  * Fix: Added electron compatibility (#324, @paulcbetts)
+  * Improvement: Added performance optimizations (@tootallnate)
+  * Readme: Corrected PowerShell environment variable example (#252, @gimre)
+  * Misc: Removed yarn lock file from source control (#321, @fengmk2)
+
+2.3.0 / 2016-11-07
+==================
+
+  * Fix: Consistent placement of ms diff at end of output (#215, @gorangajic)
+  * Fix: Escaping of regex special characters in namespace strings (#250, @zacronos)
+  * Fix: Fixed bug causing crash on react-native (#282, @vkarpov15)
+  * Feature: Enabled ES6+ compatible import via default export (#212 @bucaran)
+  * Feature: Added %O formatter to reflect Chrome's console.log capability (#279, @oncletom)
+  * Package: Update "ms" to 0.7.2 (#315, @DevSide)
+  * Package: removed superfluous version property from bower.json (#207 @kkirsche)
+  * Readme: fix USE_COLORS to DEBUG_COLORS
+  * Readme: Doc fixes for format string sugar (#269, @mlucool)
+  * Readme: Updated docs for DEBUG_FD and DEBUG_COLORS environment variables (#232, @mattlyons0)
+  * Readme: doc fixes for PowerShell (#271 #243, @exoticknight @unreadable)
+  * Readme: better docs for browser support (#224, @matthewmueller)
+  * Tooling: Added yarn integration for development (#317, @thebigredgeek)
+  * Misc: Renamed History.md to CHANGELOG.md (@thebigredgeek)
+  * Misc: Added license file (#226 #274, @CantemoInternal @sdaitzman)
+  * Misc: Updated contributors (@thebigredgeek)
+
+2.2.0 / 2015-05-09
+==================
+
+  * package: update "ms" to v0.7.1 (#202, @dougwilson)
+  * README: add logging to file example (#193, @DanielOchoa)
+  * README: fixed a typo (#191, @amir-s)
+  * browser: expose `storage` (#190, @stephenmathieson)
+  * Makefile: add a `distclean` target (#189, @stephenmathieson)
+
+2.1.3 / 2015-03-13
+==================
+
+  * Updated stdout/stderr example (#186)
+  * Updated example/stdout.js to match debug current behaviour
+  * Renamed example/stderr.js to stdout.js
+  * Update Readme.md (#184)
+  * replace high intensity foreground color for bold (#182, #183)
+
+2.1.2 / 2015-03-01
+==================
+
+  * dist: recompile
+  * update "ms" to v0.7.0
+  * package: update "browserify" to v9.0.3
+  * component: fix "ms.js" repo location
+  * changed bower package name
+  * updated documentation about using debug in a browser
+  * fix: security error on safari (#167, #168, @yields)
+
+2.1.1 / 2014-12-29
+==================
+
+  * browser: use `typeof` to check for `console` existence
+  * browser: check for `console.log` truthiness (fix IE 8/9)
+  * browser: add support for Chrome apps
+  * Readme: added Windows usage remarks
+  * Add `bower.json` to properly support bower install
+
+2.1.0 / 2014-10-15
+==================
+
+  * node: implement `DEBUG_FD` env variable support
+  * package: update "browserify" to v6.1.0
+  * package: add "license" field to package.json (#135, @panuhorsmalahti)
+
+2.0.0 / 2014-09-01
+==================
+
+  * package: update "browserify" to v5.11.0
+  * node: use stderr rather than stdout for logging (#29, @stephenmathieson)
+
+1.0.4 / 2014-07-15
+==================
+
+  * dist: recompile
+  * example: remove `console.info()` log usage
+  * example: add "Content-Type" UTF-8 header to browser example
+  * browser: place %c marker after the space character
+  * browser: reset the "content" color via `color: inherit`
+  * browser: add colors support for Firefox >= v31
+  * debug: prefer an instance `log()` function over the global one (#119)
+  * Readme: update documentation about styled console logs for FF v31 (#116, @wryk)
+
+1.0.3 / 2014-07-09
+==================
+
+  * Add support for multiple wildcards in namespaces (#122, @seegno)
+  * browser: fix lint
+
+1.0.2 / 2014-06-10
+==================
+
+  * browser: update color palette (#113, @gscottolson)
+  * common: make console logging function configurable (#108, @timoxley)
+  * node: fix %o colors on old node <= 0.8.x
+  * Makefile: find node path using shell/which (#109, @timoxley)
+
+1.0.1 / 2014-06-06
+==================
+
+  * browser: use `removeItem()` to clear localStorage
+  * browser, node: don't set DEBUG if namespaces is undefined (#107, @leedm777)
+  * package: add "contributors" section
+  * node: fix comment typo
+  * README: list authors
+
+1.0.0 / 2014-06-04
+==================
+
+  * make ms diff be global, not be scope
+  * debug: ignore empty strings in enable()
+  * node: make DEBUG_COLORS able to disable coloring
+  * *: export the `colors` array
+  * npmignore: don't publish the `dist` dir
+  * Makefile: refactor to use browserify
+  * package: add "browserify" as a dev dependency
+  * Readme: add Web Inspector Colors section
+  * node: reset terminal color for the debug content
+  * node: map "%o" to `util.inspect()`
+  * browser: map "%j" to `JSON.stringify()`
+  * debug: add custom "formatters"
+  * debug: use "ms" module for humanizing the diff
+  * Readme: add "bash" syntax highlighting
+  * browser: add Firebug color support
+  * browser: add colors for WebKit browsers
+  * node: apply log to `console`
+  * rewrite: abstract common logic for Node & browsers
+  * add .jshintrc file
+
+0.8.1 / 2014-04-14
+==================
+
+  * package: re-add the "component" section
+
+0.8.0 / 2014-03-30
+==================
+
+  * add `enable()` method for nodejs. Closes #27
+  * change from stderr to stdout
+  * remove unnecessary index.js file
+
+0.7.4 / 2013-11-13
+==================
+
+  * remove "browserify" key from package.json (fixes something in browserify)
+
+0.7.3 / 2013-10-30
+==================
+
+  * fix: catch localStorage security error when cookies are blocked (Chrome)
+  * add debug(err) support. Closes #46
+  * add .browser prop to package.json. Closes #42
+
+0.7.2 / 2013-02-06
+==================
+
+  * fix package.json
+  * fix: Mobile Safari (private mode) is broken with debug
+  * fix: Use unicode to send escape character to shell instead of octal to work with strict mode javascript
+
+0.7.1 / 2013-02-05
+==================
+
+  * add repository URL to package.json
+  * add DEBUG_COLORED to force colored output
+  * add browserify support
+  * fix component. Closes #24
+
+0.7.0 / 2012-05-04
+==================
+
+  * Added .component to package.json
+  * Added debug.component.js build
+
+0.6.0 / 2012-03-16
+==================
+
+  * Added support for "-" prefix in DEBUG [Vinay Pulim]
+  * Added `.enabled` flag to the node version [TooTallNate]
+
+0.5.0 / 2012-02-02
+==================
+
+  * Added: humanize diffs. Closes #8
+  * Added `debug.disable()` to the CS variant
+  * Removed padding. Closes #10
+  * Fixed: persist client-side variant again. Closes #9
+
+0.4.0 / 2012-02-01
+==================
+
+  * Added browser variant support for older browsers [TooTallNate]
+  * Added `debug.enable('project:*')` to browser variant [TooTallNate]
+  * Added padding to diff (moved it to the right)
+
+0.3.0 / 2012-01-26
+==================
+
+  * Added millisecond diff when isatty, otherwise UTC string
+
+0.2.0 / 2012-01-22
+==================
+
+  * Added wildcard support
+
+0.1.0 / 2011-12-02
+==================
+
+  * Added: remove colors unless stderr isatty [TooTallNate]
+
+0.0.1 / 2010-01-03
+==================
+
+  * Initial release
diff --git a/node_modules/@babel/traverse/node_modules/debug/LICENSE b/node_modules/@babel/traverse/node_modules/debug/LICENSE
new file mode 100644
index 00000000..658c933d
--- /dev/null
+++ b/node_modules/@babel/traverse/node_modules/debug/LICENSE
@@ -0,0 +1,19 @@
+(The MIT License)
+
+Copyright (c) 2014 TJ Holowaychuk <tj@vision-media.ca>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software 
+and associated documentation files (the 'Software'), to deal in the Software without restriction, 
+including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial 
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT 
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
diff --git a/node_modules/@babel/traverse/node_modules/debug/README.md b/node_modules/@babel/traverse/node_modules/debug/README.md
new file mode 100644
index 00000000..0ee7634d
--- /dev/null
+++ b/node_modules/@babel/traverse/node_modules/debug/README.md
@@ -0,0 +1,437 @@
+# debug
+[![Build Status](https://travis-ci.org/visionmedia/debug.svg?branch=master)](https://travis-ci.org/visionmedia/debug)  [![Coverage Status](https://coveralls.io/repos/github/visionmedia/debug/badge.svg?branch=master)](https://coveralls.io/github/visionmedia/debug?branch=master)  [![Slack](https://visionmedia-community-slackin.now.sh/badge.svg)](https://visionmedia-community-slackin.now.sh/) [![OpenCollective](https://opencollective.com/debug/backers/badge.svg)](#backers)
+[![OpenCollective](https://opencollective.com/debug/sponsors/badge.svg)](#sponsors)
+
+<img width="647" src="https://user-images.githubusercontent.com/71256/29091486-fa38524c-7c37-11e7-895f-e7ec8e1039b6.png">
+
+A tiny JavaScript debugging utility modelled after Node.js core's debugging
+technique. Works in Node.js and web browsers.
+
+## Installation
+
+```bash
+$ npm install debug
+```
+
+## Usage
+
+`debug` exposes a function; simply pass this function the name of your module, and it will return a decorated version of `console.error` for you to pass debug statements to. This will allow you to toggle the debug output for different parts of your module as well as the module as a whole.
+
+Example [_app.js_](./examples/node/app.js):
+
+```js
+var debug = require('debug')('http')
+  , http = require('http')
+  , name = 'My App';
+
+// fake app
+
+debug('booting %o', name);
+
+http.createServer(function(req, res){
+  debug(req.method + ' ' + req.url);
+  res.end('hello\n');
+}).listen(3000, function(){
+  debug('listening');
+});
+
+// fake worker of some kind
+
+require('./worker');
+```
+
+Example [_worker.js_](./examples/node/worker.js):
+
+```js
+var a = require('debug')('worker:a')
+  , b = require('debug')('worker:b');
+
+function work() {
+  a('doing lots of uninteresting work');
+  setTimeout(work, Math.random() * 1000);
+}
+
+work();
+
+function workb() {
+  b('doing some work');
+  setTimeout(workb, Math.random() * 2000);
+}
+
+workb();
+```
+
+The `DEBUG` environment variable is then used to enable these based on space or
+comma-delimited names.
+
+Here are some examples:
+
+<img width="647" alt="screen shot 2017-08-08 at 12 53 04 pm" src="https://user-images.githubusercontent.com/71256/29091703-a6302cdc-7c38-11e7-8304-7c0b3bc600cd.png">
+<img width="647" alt="screen shot 2017-08-08 at 12 53 38 pm" src="https://user-images.githubusercontent.com/71256/29091700-a62a6888-7c38-11e7-800b-db911291ca2b.png">
+<img width="647" alt="screen shot 2017-08-08 at 12 53 25 pm" src="https://user-images.githubusercontent.com/71256/29091701-a62ea114-7c38-11e7-826a-2692bedca740.png">
+
+#### Windows command prompt notes
+
+##### CMD
+
+On Windows the environment variable is set using the `set` command.
+
+```cmd
+set DEBUG=*,-not_this
+```
+
+Example:
+
+```cmd
+set DEBUG=* & node app.js
+```
+
+##### PowerShell (VS Code default)
+
+PowerShell uses different syntax to set environment variables.
+
+```cmd
+$env:DEBUG = "*,-not_this"
+```
+
+Example:
+
+```cmd
+$env:DEBUG='app';node app.js
+```
+
+Then, run the program to be debugged as usual.
+
+npm script example:
+```js
+  "windowsDebug": "@powershell -Command $env:DEBUG='*';node app.js",
+```
+
+## Namespace Colors
+
+Every debug instance has a color generated for it based on its namespace name.
+This helps when visually parsing the debug output to identify which debug instance
+a debug line belongs to.
+
+#### Node.js
+
+In Node.js, colors are enabled when stderr is a TTY. You also _should_ install
+the [`supports-color`](https://npmjs.org/supports-color) module alongside debug,
+otherwise debug will only use a small handful of basic colors.
+
+<img width="521" src="https://user-images.githubusercontent.com/71256/29092181-47f6a9e6-7c3a-11e7-9a14-1928d8a711cd.png">
+
+#### Web Browser
+
+Colors are also enabled on "Web Inspectors" that understand the `%c` formatting
+option. These are WebKit web inspectors, Firefox ([since version
+31](https://hacks.mozilla.org/2014/05/editable-box-model-multiple-selection-sublime-text-keys-much-more-firefox-developer-tools-episode-31/))
+and the Firebug plugin for Firefox (any version).
+
+<img width="524" src="https://user-images.githubusercontent.com/71256/29092033-b65f9f2e-7c39-11e7-8e32-f6f0d8e865c1.png">
+
+
+## Millisecond diff
+
+When actively developing an application it can be useful to see when the time spent between one `debug()` call and the next. Suppose for example you invoke `debug()` before requesting a resource, and after as well, the "+NNNms" will show you how much time was spent between calls.
+
+<img width="647" src="https://user-images.githubusercontent.com/71256/29091486-fa38524c-7c37-11e7-895f-e7ec8e1039b6.png">
+
+When stdout is not a TTY, `Date#toISOString()` is used, making it more useful for logging the debug information as shown below:
+
+<img width="647" src="https://user-images.githubusercontent.com/71256/29091956-6bd78372-7c39-11e7-8c55-c948396d6edd.png">
+
+
+## Conventions
+
+If you're using this in one or more of your libraries, you _should_ use the name of your library so that developers may toggle debugging as desired without guessing names. If you have more than one debuggers you _should_ prefix them with your library name and use ":" to separate features. For example "bodyParser" from Connect would then be "connect:bodyParser".  If you append a "*" to the end of your name, it will always be enabled regardless of the setting of the DEBUG environment variable.  You can then use it for normal output as well as debug output.
+
+## Wildcards
+
+The `*` character may be used as a wildcard. Suppose for example your library has
+debuggers named "connect:bodyParser", "connect:compress", "connect:session",
+instead of listing all three with
+`DEBUG=connect:bodyParser,connect:compress,connect:session`, you may simply do
+`DEBUG=connect:*`, or to run everything using this module simply use `DEBUG=*`.
+
+You can also exclude specific debuggers by prefixing them with a "-" character.
+For example, `DEBUG=*,-connect:*` would include all debuggers except those
+starting with "connect:".
+
+## Environment Variables
+
+When running through Node.js, you can set a few environment variables that will
+change the behavior of the debug logging:
+
+| Name      | Purpose                                         |
+|-----------|-------------------------------------------------|
+| `DEBUG`   | Enables/disables specific debugging namespaces. |
+| `DEBUG_HIDE_DATE` | Hide date from debug output (non-TTY).  |
+| `DEBUG_COLORS`| Whether or not to use colors in the debug output. |
+| `DEBUG_DEPTH` | Object inspection depth.                    |
+| `DEBUG_SHOW_HIDDEN` | Shows hidden properties on inspected objects. |
+
+
+__Note:__ The environment variables beginning with `DEBUG_` end up being
+converted into an Options object that gets used with `%o`/`%O` formatters.
+See the Node.js documentation for
+[`util.inspect()`](https://nodejs.org/api/util.html#util_util_inspect_object_options)
+for the complete list.
+
+## Formatters
+
+Debug uses [printf-style](https://wikipedia.org/wiki/Printf_format_string) formatting.
+Below are the officially supported formatters:
+
+| Formatter | Representation |
+|-----------|----------------|
+| `%O`      | Pretty-print an Object on multiple lines. |
+| `%o`      | Pretty-print an Object all on a single line. |
+| `%s`      | String. |
+| `%d`      | Number (both integer and float). |
+| `%j`      | JSON. Replaced with the string '[Circular]' if the argument contains circular references. |
+| `%%`      | Single percent sign ('%'). This does not consume an argument. |
+
+
+### Custom formatters
+
+You can add custom formatters by extending the `debug.formatters` object.
+For example, if you wanted to add support for rendering a Buffer as hex with
+`%h`, you could do something like:
+
+```js
+const createDebug = require('debug')
+createDebug.formatters.h = (v) => {
+  return v.toString('hex')
+}
+
+// …elsewhere
+const debug = createDebug('foo')
+debug('this is hex: %h', new Buffer('hello world'))
+//   foo this is hex: 68656c6c6f20776f726c6421 +0ms
+```
+
+
+## Browser Support
+
+You can build a browser-ready script using [browserify](https://github.com/substack/node-browserify),
+or just use the [browserify-as-a-service](https://wzrd.in/) [build](https://wzrd.in/standalone/debug@latest),
+if you don't want to build it yourself.
+
+Debug's enable state is currently persisted by `localStorage`.
+Consider the situation shown below where you have `worker:a` and `worker:b`,
+and wish to debug both. You can enable this using `localStorage.debug`:
+
+```js
+localStorage.debug = 'worker:*'
+```
+
+And then refresh the page.
+
+```js
+a = debug('worker:a');
+b = debug('worker:b');
+
+setInterval(function(){
+  a('doing some work');
+}, 1000);
+
+setInterval(function(){
+  b('doing some work');
+}, 1200);
+```
+
+
+## Output streams
+
+  By default `debug` will log to stderr, however this can be configured per-namespace by overriding the `log` method:
+
+Example [_stdout.js_](./examples/node/stdout.js):
+
+```js
+var debug = require('debug');
+var error = debug('app:error');
+
+// by default stderr is used
+error('goes to stderr!');
+
+var log = debug('app:log');
+// set this namespace to log via console.log
+log.log = console.log.bind(console); // don't forget to bind to console!
+log('goes to stdout');
+error('still goes to stderr!');
+
+// set all output to go via console.info
+// overrides all per-namespace log settings
+debug.log = console.info.bind(console);
+error('now goes to stdout via console.info');
+log('still goes to stdout, but via console.info now');
+```
+
+## Extend
+You can simply extend debugger 
+```js
+const log = require('debug')('auth');
+
+//creates new debug instance with extended namespace
+const logSign = log.extend('sign');
+const logLogin = log.extend('login');
+
+log('hello'); // auth hello
+logSign('hello'); //auth:sign hello
+logLogin('hello'); //auth:login hello
+```
+
+## Set dynamically
+
+You can also enable debug dynamically by calling the `enable()` method :
+
+```js
+let debug = require('debug');
+
+console.log(1, debug.enabled('test'));
+
+debug.enable('test');
+console.log(2, debug.enabled('test'));
+
+debug.disable();
+console.log(3, debug.enabled('test'));
+
+```
+
+print :   
+```
+1 false
+2 true
+3 false
+```
+
+Usage :  
+`enable(namespaces)`  
+`namespaces` can include modes separated by a colon and wildcards.
+   
+Note that calling `enable()` completely overrides previously set DEBUG variable : 
+
+```
+$ DEBUG=foo node -e 'var dbg = require("debug"); dbg.enable("bar"); console.log(dbg.enabled("foo"))'
+=> false
+```
+
+## Checking whether a debug target is enabled
+
+After you've created a debug instance, you can determine whether or not it is
+enabled by checking the `enabled` property:
+
+```javascript
+const debug = require('debug')('http');
+
+if (debug.enabled) {
+  // do stuff...
+}
+```
+
+You can also manually toggle this property to force the debug instance to be
+enabled or disabled.
+
+
+## Authors
+
+ - TJ Holowaychuk
+ - Nathan Rajlich
+ - Andrew Rhyne
+
+## Backers
+
+Support us with a monthly donation and help us continue our activities. [[Become a backer](https://opencollective.com/debug#backer)]
+
+<a href="https://opencollective.com/debug/backer/0/website" target="_blank"><img src="https://opencollective.com/debug/backer/0/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/1/website" target="_blank"><img src="https://opencollective.com/debug/backer/1/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/2/website" target="_blank"><img src="https://opencollective.com/debug/backer/2/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/3/website" target="_blank"><img src="https://opencollective.com/debug/backer/3/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/4/website" target="_blank"><img src="https://opencollective.com/debug/backer/4/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/5/website" target="_blank"><img src="https://opencollective.com/debug/backer/5/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/6/website" target="_blank"><img src="https://opencollective.com/debug/backer/6/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/7/website" target="_blank"><img src="https://opencollective.com/debug/backer/7/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/8/website" target="_blank"><img src="https://opencollective.com/debug/backer/8/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/9/website" target="_blank"><img src="https://opencollective.com/debug/backer/9/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/10/website" target="_blank"><img src="https://opencollective.com/debug/backer/10/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/11/website" target="_blank"><img src="https://opencollective.com/debug/backer/11/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/12/website" target="_blank"><img src="https://opencollective.com/debug/backer/12/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/13/website" target="_blank"><img src="https://opencollective.com/debug/backer/13/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/14/website" target="_blank"><img src="https://opencollective.com/debug/backer/14/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/15/website" target="_blank"><img src="https://opencollective.com/debug/backer/15/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/16/website" target="_blank"><img src="https://opencollective.com/debug/backer/16/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/17/website" target="_blank"><img src="https://opencollective.com/debug/backer/17/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/18/website" target="_blank"><img src="https://opencollective.com/debug/backer/18/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/19/website" target="_blank"><img src="https://opencollective.com/debug/backer/19/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/20/website" target="_blank"><img src="https://opencollective.com/debug/backer/20/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/21/website" target="_blank"><img src="https://opencollective.com/debug/backer/21/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/22/website" target="_blank"><img src="https://opencollective.com/debug/backer/22/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/23/website" target="_blank"><img src="https://opencollective.com/debug/backer/23/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/24/website" target="_blank"><img src="https://opencollective.com/debug/backer/24/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/25/website" target="_blank"><img src="https://opencollective.com/debug/backer/25/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/26/website" target="_blank"><img src="https://opencollective.com/debug/backer/26/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/27/website" target="_blank"><img src="https://opencollective.com/debug/backer/27/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/28/website" target="_blank"><img src="https://opencollective.com/debug/backer/28/avatar.svg"></a>
+<a href="https://opencollective.com/debug/backer/29/website" target="_blank"><img src="https://opencollective.com/debug/backer/29/avatar.svg"></a>
+
+
+## Sponsors
+
+Become a sponsor and get your logo on our README on Github with a link to your site. [[Become a sponsor](https://opencollective.com/debug#sponsor)]
+
+<a href="https://opencollective.com/debug/sponsor/0/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/0/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/1/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/1/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/2/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/2/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/3/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/3/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/4/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/4/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/5/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/5/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/6/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/6/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/7/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/7/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/8/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/8/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/9/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/9/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/10/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/10/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/11/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/11/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/12/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/12/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/13/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/13/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/14/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/14/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/15/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/15/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/16/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/16/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/17/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/17/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/18/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/18/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/19/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/19/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/20/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/20/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/21/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/21/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/22/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/22/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/23/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/23/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/24/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/24/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/25/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/25/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/26/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/26/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/27/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/27/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/28/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/28/avatar.svg"></a>
+<a href="https://opencollective.com/debug/sponsor/29/website" target="_blank"><img src="https://opencollective.com/debug/sponsor/29/avatar.svg"></a>
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2014-2017 TJ Holowaychuk &lt;tj@vision-media.ca&gt;
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/@babel/traverse/node_modules/debug/dist/debug.js b/node_modules/@babel/traverse/node_modules/debug/dist/debug.js
new file mode 100644
index 00000000..f271e01c
--- /dev/null
+++ b/node_modules/@babel/traverse/node_modules/debug/dist/debug.js
@@ -0,0 +1,886 @@
+"use strict";
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+(function (f) {
+  if ((typeof exports === "undefined" ? "undefined" : _typeof(exports)) === "object" && typeof module !== "undefined") {
+    module.exports = f();
+  } else if (typeof define === "function" && define.amd) {
+    define([], f);
+  } else {
+    var g;
+
+    if (typeof window !== "undefined") {
+      g = window;
+    } else if (typeof global !== "undefined") {
+      g = global;
+    } else if (typeof self !== "undefined") {
+      g = self;
+    } else {
+      g = this;
+    }
+
+    g.debug = f();
+  }
+})(function () {
+  var define, module, exports;
+  return function () {
+    function r(e, n, t) {
+      function o(i, f) {
+        if (!n[i]) {
+          if (!e[i]) {
+            var c = "function" == typeof require && require;
+            if (!f && c) return c(i, !0);
+            if (u) return u(i, !0);
+            var a = new Error("Cannot find module '" + i + "'");
+            throw a.code = "MODULE_NOT_FOUND", a;
+          }
+
+          var p = n[i] = {
+            exports: {}
+          };
+          e[i][0].call(p.exports, function (r) {
+            var n = e[i][1][r];
+            return o(n || r);
+          }, p, p.exports, r, e, n, t);
+        }
+
+        return n[i].exports;
+      }
+
+      for (var u = "function" == typeof require && require, i = 0; i < t.length; i++) {
+        o(t[i]);
+      }
+
+      return o;
+    }
+
+    return r;
+  }()({
+    1: [function (require, module, exports) {
+      /**
+       * Helpers.
+       */
+      var s = 1000;
+      var m = s * 60;
+      var h = m * 60;
+      var d = h * 24;
+      var w = d * 7;
+      var y = d * 365.25;
+      /**
+       * Parse or format the given `val`.
+       *
+       * Options:
+       *
+       *  - `long` verbose formatting [false]
+       *
+       * @param {String|Number} val
+       * @param {Object} [options]
+       * @throws {Error} throw an error if val is not a non-empty string or a number
+       * @return {String|Number}
+       * @api public
+       */
+
+      module.exports = function (val, options) {
+        options = options || {};
+
+        var type = _typeof(val);
+
+        if (type === 'string' && val.length > 0) {
+          return parse(val);
+        } else if (type === 'number' && isNaN(val) === false) {
+          return options.long ? fmtLong(val) : fmtShort(val);
+        }
+
+        throw new Error('val is not a non-empty string or a valid number. val=' + JSON.stringify(val));
+      };
+      /**
+       * Parse the given `str` and return milliseconds.
+       *
+       * @param {String} str
+       * @return {Number}
+       * @api private
+       */
+
+
+      function parse(str) {
+        str = String(str);
+
+        if (str.length > 100) {
+          return;
+        }
+
+        var match = /^((?:\d+)?\-?\d?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str);
+
+        if (!match) {
+          return;
+        }
+
+        var n = parseFloat(match[1]);
+        var type = (match[2] || 'ms').toLowerCase();
+
+        switch (type) {
+          case 'years':
+          case 'year':
+          case 'yrs':
+          case 'yr':
+          case 'y':
+            return n * y;
+
+          case 'weeks':
+          case 'week':
+          case 'w':
+            return n * w;
+
+          case 'days':
+          case 'day':
+          case 'd':
+            return n * d;
+
+          case 'hours':
+          case 'hour':
+          case 'hrs':
+          case 'hr':
+          case 'h':
+            return n * h;
+
+          case 'minutes':
+          case 'minute':
+          case 'mins':
+          case 'min':
+          case 'm':
+            return n * m;
+
+          case 'seconds':
+          case 'second':
+          case 'secs':
+          case 'sec':
+          case 's':
+            return n * s;
+
+          case 'milliseconds':
+          case 'millisecond':
+          case 'msecs':
+          case 'msec':
+          case 'ms':
+            return n;
+
+          default:
+            return undefined;
+        }
+      }
+      /**
+       * Short format for `ms`.
+       *
+       * @param {Number} ms
+       * @return {String}
+       * @api private
+       */
+
+
+      function fmtShort(ms) {
+        var msAbs = Math.abs(ms);
+
+        if (msAbs >= d) {
+          return Math.round(ms / d) + 'd';
+        }
+
+        if (msAbs >= h) {
+          return Math.round(ms / h) + 'h';
+        }
+
+        if (msAbs >= m) {
+          return Math.round(ms / m) + 'm';
+        }
+
+        if (msAbs >= s) {
+          return Math.round(ms / s) + 's';
+        }
+
+        return ms + 'ms';
+      }
+      /**
+       * Long format for `ms`.
+       *
+       * @param {Number} ms
+       * @return {String}
+       * @api private
+       */
+
+
+      function fmtLong(ms) {
+        var msAbs = Math.abs(ms);
+
+        if (msAbs >= d) {
+          return plural(ms, msAbs, d, 'day');
+        }
+
+        if (msAbs >= h) {
+          return plural(ms, msAbs, h, 'hour');
+        }
+
+        if (msAbs >= m) {
+          return plural(ms, msAbs, m, 'minute');
+        }
+
+        if (msAbs >= s) {
+          return plural(ms, msAbs, s, 'second');
+        }
+
+        return ms + ' ms';
+      }
+      /**
+       * Pluralization helper.
+       */
+
+
+      function plural(ms, msAbs, n, name) {
+        var isPlural = msAbs >= n * 1.5;
+        return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+      }
+    }, {}],
+    2: [function (require, module, exports) {
+      // shim for using process in browser
+      var process = module.exports = {}; // cached from whatever global is present so that test runners that stub it
+      // don't break things.  But we need to wrap it in a try catch in case it is
+      // wrapped in strict mode code which doesn't define any globals.  It's inside a
+      // function because try/catches deoptimize in certain engines.
+
+      var cachedSetTimeout;
+      var cachedClearTimeout;
+
+      function defaultSetTimout() {
+        throw new Error('setTimeout has not been defined');
+      }
+
+      function defaultClearTimeout() {
+        throw new Error('clearTimeout has not been defined');
+      }
+
+      (function () {
+        try {
+          if (typeof setTimeout === 'function') {
+            cachedSetTimeout = setTimeout;
+          } else {
+            cachedSetTimeout = defaultSetTimout;
+          }
+        } catch (e) {
+          cachedSetTimeout = defaultSetTimout;
+        }
+
+        try {
+          if (typeof clearTimeout === 'function') {
+            cachedClearTimeout = clearTimeout;
+          } else {
+            cachedClearTimeout = defaultClearTimeout;
+          }
+        } catch (e) {
+          cachedClearTimeout = defaultClearTimeout;
+        }
+      })();
+
+      function runTimeout(fun) {
+        if (cachedSetTimeout === setTimeout) {
+          //normal enviroments in sane situations
+          return setTimeout(fun, 0);
+        } // if setTimeout wasn't available but was latter defined
+
+
+        if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+          cachedSetTimeout = setTimeout;
+          return setTimeout(fun, 0);
+        }
+
+        try {
+          // when when somebody has screwed with setTimeout but no I.E. maddness
+          return cachedSetTimeout(fun, 0);
+        } catch (e) {
+          try {
+            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+            return cachedSetTimeout.call(null, fun, 0);
+          } catch (e) {
+            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
+            return cachedSetTimeout.call(this, fun, 0);
+          }
+        }
+      }
+
+      function runClearTimeout(marker) {
+        if (cachedClearTimeout === clearTimeout) {
+          //normal enviroments in sane situations
+          return clearTimeout(marker);
+        } // if clearTimeout wasn't available but was latter defined
+
+
+        if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+          cachedClearTimeout = clearTimeout;
+          return clearTimeout(marker);
+        }
+
+        try {
+          // when when somebody has screwed with setTimeout but no I.E. maddness
+          return cachedClearTimeout(marker);
+        } catch (e) {
+          try {
+            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
+            return cachedClearTimeout.call(null, marker);
+          } catch (e) {
+            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
+            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
+            return cachedClearTimeout.call(this, marker);
+          }
+        }
+      }
+
+      var queue = [];
+      var draining = false;
+      var currentQueue;
+      var queueIndex = -1;
+
+      function cleanUpNextTick() {
+        if (!draining || !currentQueue) {
+          return;
+        }
+
+        draining = false;
+
+        if (currentQueue.length) {
+          queue = currentQueue.concat(queue);
+        } else {
+          queueIndex = -1;
+        }
+
+        if (queue.length) {
+          drainQueue();
+        }
+      }
+
+      function drainQueue() {
+        if (draining) {
+          return;
+        }
+
+        var timeout = runTimeout(cleanUpNextTick);
+        draining = true;
+        var len = queue.length;
+
+        while (len) {
+          currentQueue = queue;
+          queue = [];
+
+          while (++queueIndex < len) {
+            if (currentQueue) {
+              currentQueue[queueIndex].run();
+            }
+          }
+
+          queueIndex = -1;
+          len = queue.length;
+        }
+
+        currentQueue = null;
+        draining = false;
+        runClearTimeout(timeout);
+      }
+
+      process.nextTick = function (fun) {
+        var args = new Array(arguments.length - 1);
+
+        if (arguments.length > 1) {
+          for (var i = 1; i < arguments.length; i++) {
+            args[i - 1] = arguments[i];
+          }
+        }
+
+        queue.push(new Item(fun, args));
+
+        if (queue.length === 1 && !draining) {
+          runTimeout(drainQueue);
+        }
+      }; // v8 likes predictible objects
+
+
+      function Item(fun, array) {
+        this.fun = fun;
+        this.array = array;
+      }
+
+      Item.prototype.run = function () {
+        this.fun.apply(null, this.array);
+      };
+
+      process.title = 'browser';
+      process.browser = true;
+      process.env = {};
+      process.argv = [];
+      process.version = ''; // empty string to avoid regexp issues
+
+      process.versions = {};
+
+      function noop() {}
+
+      process.on = noop;
+      process.addListener = noop;
+      process.once = noop;
+      process.off = noop;
+      process.removeListener = noop;
+      process.removeAllListeners = noop;
+      process.emit = noop;
+      process.prependListener = noop;
+      process.prependOnceListener = noop;
+
+      process.listeners = function (name) {
+        return [];
+      };
+
+      process.binding = function (name) {
+        throw new Error('process.binding is not supported');
+      };
+
+      process.cwd = function () {
+        return '/';
+      };
+
+      process.chdir = function (dir) {
+        throw new Error('process.chdir is not supported');
+      };
+
+      process.umask = function () {
+        return 0;
+      };
+    }, {}],
+    3: [function (require, module, exports) {
+      /**
+       * This is the common logic for both the Node.js and web browser
+       * implementations of `debug()`.
+       */
+      function setup(env) {
+        createDebug.debug = createDebug;
+        createDebug.default = createDebug;
+        createDebug.coerce = coerce;
+        createDebug.disable = disable;
+        createDebug.enable = enable;
+        createDebug.enabled = enabled;
+        createDebug.humanize = require('ms');
+        Object.keys(env).forEach(function (key) {
+          createDebug[key] = env[key];
+        });
+        /**
+        * Active `debug` instances.
+        */
+
+        createDebug.instances = [];
+        /**
+        * The currently active debug mode names, and names to skip.
+        */
+
+        createDebug.names = [];
+        createDebug.skips = [];
+        /**
+        * Map of special "%n" handling functions, for the debug "format" argument.
+        *
+        * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+        */
+
+        createDebug.formatters = {};
+        /**
+        * Selects a color for a debug namespace
+        * @param {String} namespace The namespace string for the for the debug instance to be colored
+        * @return {Number|String} An ANSI color code for the given namespace
+        * @api private
+        */
+
+        function selectColor(namespace) {
+          var hash = 0;
+
+          for (var i = 0; i < namespace.length; i++) {
+            hash = (hash << 5) - hash + namespace.charCodeAt(i);
+            hash |= 0; // Convert to 32bit integer
+          }
+
+          return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+        }
+
+        createDebug.selectColor = selectColor;
+        /**
+        * Create a debugger with the given `namespace`.
+        *
+        * @param {String} namespace
+        * @return {Function}
+        * @api public
+        */
+
+        function createDebug(namespace) {
+          var prevTime;
+
+          function debug() {
+            for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+              args[_key] = arguments[_key];
+            }
+
+            // Disabled?
+            if (!debug.enabled) {
+              return;
+            }
+
+            var self = debug; // Set `diff` timestamp
+
+            var curr = Number(new Date());
+            var ms = curr - (prevTime || curr);
+            self.diff = ms;
+            self.prev = prevTime;
+            self.curr = curr;
+            prevTime = curr;
+            args[0] = createDebug.coerce(args[0]);
+
+            if (typeof args[0] !== 'string') {
+              // Anything else let's inspect with %O
+              args.unshift('%O');
+            } // Apply any `formatters` transformations
+
+
+            var index = 0;
+            args[0] = args[0].replace(/%([a-zA-Z%])/g, function (match, format) {
+              // If we encounter an escaped % then don't increase the array index
+              if (match === '%%') {
+                return match;
+              }
+
+              index++;
+              var formatter = createDebug.formatters[format];
+
+              if (typeof formatter === 'function') {
+                var val = args[index];
+                match = formatter.call(self, val); // Now we need to remove `args[index]` since it's inlined in the `format`
+
+                args.splice(index, 1);
+                index--;
+              }
+
+              return match;
+            }); // Apply env-specific formatting (colors, etc.)
+
+            createDebug.formatArgs.call(self, args);
+            var logFn = self.log || createDebug.log;
+            logFn.apply(self, args);
+          }
+
+          debug.namespace = namespace;
+          debug.enabled = createDebug.enabled(namespace);
+          debug.useColors = createDebug.useColors();
+          debug.color = selectColor(namespace);
+          debug.destroy = destroy;
+          debug.extend = extend; // Debug.formatArgs = formatArgs;
+          // debug.rawLog = rawLog;
+          // env-specific initialization logic for debug instances
+
+          if (typeof createDebug.init === 'function') {
+            createDebug.init(debug);
+          }
+
+          createDebug.instances.push(debug);
+          return debug;
+        }
+
+        function destroy() {
+          var index = createDebug.instances.indexOf(this);
+
+          if (index !== -1) {
+            createDebug.instances.splice(index, 1);
+            return true;
+          }
+
+          return false;
+        }
+
+        function extend(namespace, delimiter) {
+          return createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
+        }
+        /**
+        * Enables a debug mode by namespaces. This can include modes
+        * separated by a colon and wildcards.
+        *
+        * @param {String} namespaces
+        * @api public
+        */
+
+
+        function enable(namespaces) {
+          createDebug.save(namespaces);
+          createDebug.names = [];
+          createDebug.skips = [];
+          var i;
+          var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
+          var len = split.length;
+
+          for (i = 0; i < len; i++) {
+            if (!split[i]) {
+              // ignore empty strings
+              continue;
+            }
+
+            namespaces = split[i].replace(/\*/g, '.*?');
+
+            if (namespaces[0] === '-') {
+              createDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
+            } else {
+              createDebug.names.push(new RegExp('^' + namespaces + '$'));
+            }
+          }
+
+          for (i = 0; i < createDebug.instances.length; i++) {
+            var instance = createDebug.instances[i];
+            instance.enabled = createDebug.enabled(instance.namespace);
+          }
+        }
+        /**
+        * Disable debug output.
+        *
+        * @api public
+        */
+
+
+        function disable() {
+          createDebug.enable('');
+        }
+        /**
+        * Returns true if the given mode name is enabled, false otherwise.
+        *
+        * @param {String} name
+        * @return {Boolean}
+        * @api public
+        */
+
+
+        function enabled(name) {
+          if (name[name.length - 1] === '*') {
+            return true;
+          }
+
+          var i;
+          var len;
+
+          for (i = 0, len = createDebug.skips.length; i < len; i++) {
+            if (createDebug.skips[i].test(name)) {
+              return false;
+            }
+          }
+
+          for (i = 0, len = createDebug.names.length; i < len; i++) {
+            if (createDebug.names[i].test(name)) {
+              return true;
+            }
+          }
+
+          return false;
+        }
+        /**
+        * Coerce `val`.
+        *
+        * @param {Mixed} val
+        * @return {Mixed}
+        * @api private
+        */
+
+
+        function coerce(val) {
+          if (val instanceof Error) {
+            return val.stack || val.message;
+          }
+
+          return val;
+        }
+
+        createDebug.enable(createDebug.load());
+        return createDebug;
+      }
+
+      module.exports = setup;
+    }, {
+      "ms": 1
+    }],
+    4: [function (require, module, exports) {
+      (function (process) {
+        /* eslint-env browser */
+
+        /**
+         * This is the web browser implementation of `debug()`.
+         */
+        exports.log = log;
+        exports.formatArgs = formatArgs;
+        exports.save = save;
+        exports.load = load;
+        exports.useColors = useColors;
+        exports.storage = localstorage();
+        /**
+         * Colors.
+         */
+
+        exports.colors = ['#0000CC', '#0000FF', '#0033CC', '#0033FF', '#0066CC', '#0066FF', '#0099CC', '#0099FF', '#00CC00', '#00CC33', '#00CC66', '#00CC99', '#00CCCC', '#00CCFF', '#3300CC', '#3300FF', '#3333CC', '#3333FF', '#3366CC', '#3366FF', '#3399CC', '#3399FF', '#33CC00', '#33CC33', '#33CC66', '#33CC99', '#33CCCC', '#33CCFF', '#6600CC', '#6600FF', '#6633CC', '#6633FF', '#66CC00', '#66CC33', '#9900CC', '#9900FF', '#9933CC', '#9933FF', '#99CC00', '#99CC33', '#CC0000', '#CC0033', '#CC0066', '#CC0099', '#CC00CC', '#CC00FF', '#CC3300', '#CC3333', '#CC3366', '#CC3399', '#CC33CC', '#CC33FF', '#CC6600', '#CC6633', '#CC9900', '#CC9933', '#CCCC00', '#CCCC33', '#FF0000', '#FF0033', '#FF0066', '#FF0099', '#FF00CC', '#FF00FF', '#FF3300', '#FF3333', '#FF3366', '#FF3399', '#FF33CC', '#FF33FF', '#FF6600', '#FF6633', '#FF9900', '#FF9933', '#FFCC00', '#FFCC33'];
+        /**
+         * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+         * and the Firebug extension (any Firefox version) are known
+         * to support "%c" CSS customizations.
+         *
+         * TODO: add a `localStorage` variable to explicitly enable/disable colors
+         */
+        // eslint-disable-next-line complexity
+
+        function useColors() {
+          // NB: In an Electron preload script, document will be defined but not fully
+          // initialized. Since we know we're in Chrome, we'll just detect this case
+          // explicitly
+          if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
+            return true;
+          } // Internet Explorer and Edge do not support colors.
+
+
+          if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+            return false;
+          } // Is webkit? http://stackoverflow.com/a/16459606/376773
+          // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
+
+
+          return typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+          typeof window !== 'undefined' && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+          // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+          typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+          typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+        }
+        /**
+         * Colorize log arguments if enabled.
+         *
+         * @api public
+         */
+
+
+        function formatArgs(args) {
+          args[0] = (this.useColors ? '%c' : '') + this.namespace + (this.useColors ? ' %c' : ' ') + args[0] + (this.useColors ? '%c ' : ' ') + '+' + module.exports.humanize(this.diff);
+
+          if (!this.useColors) {
+            return;
+          }
+
+          var c = 'color: ' + this.color;
+          args.splice(1, 0, c, 'color: inherit'); // The final "%c" is somewhat tricky, because there could be other
+          // arguments passed either before or after the %c, so we need to
+          // figure out the correct index to insert the CSS into
+
+          var index = 0;
+          var lastC = 0;
+          args[0].replace(/%[a-zA-Z%]/g, function (match) {
+            if (match === '%%') {
+              return;
+            }
+
+            index++;
+
+            if (match === '%c') {
+              // We only are interested in the *last* %c
+              // (the user may have provided their own)
+              lastC = index;
+            }
+          });
+          args.splice(lastC, 0, c);
+        }
+        /**
+         * Invokes `console.log()` when available.
+         * No-op when `console.log` is not a "function".
+         *
+         * @api public
+         */
+
+
+        function log() {
+          var _console;
+
+          // This hackery is required for IE8/9, where
+          // the `console.log` function doesn't have 'apply'
+          return (typeof console === "undefined" ? "undefined" : _typeof(console)) === 'object' && console.log && (_console = console).log.apply(_console, arguments);
+        }
+        /**
+         * Save `namespaces`.
+         *
+         * @param {String} namespaces
+         * @api private
+         */
+
+
+        function save(namespaces) {
+          try {
+            if (namespaces) {
+              exports.storage.setItem('debug', namespaces);
+            } else {
+              exports.storage.removeItem('debug');
+            }
+          } catch (error) {// Swallow
+            // XXX (@Qix-) should we be logging these?
+          }
+        }
+        /**
+         * Load `namespaces`.
+         *
+         * @return {String} returns the previously persisted debug modes
+         * @api private
+         */
+
+
+        function load() {
+          var r;
+
+          try {
+            r = exports.storage.getItem('debug');
+          } catch (error) {} // Swallow
+          // XXX (@Qix-) should we be logging these?
+          // If debug isn't set in LS, and we're in Electron, try to load $DEBUG
+
+
+          if (!r && typeof process !== 'undefined' && 'env' in process) {
+            r = process.env.DEBUG;
+          }
+
+          return r;
+        }
+        /**
+         * Localstorage attempts to return the localstorage.
+         *
+         * This is necessary because safari throws
+         * when a user disables cookies/localstorage
+         * and you attempt to access it.
+         *
+         * @return {LocalStorage}
+         * @api private
+         */
+
+
+        function localstorage() {
+          try {
+            // TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
+            // The Browser also has localStorage in the global context.
+            return localStorage;
+          } catch (error) {// Swallow
+            // XXX (@Qix-) should we be logging these?
+          }
+        }
+
+        module.exports = require('./common')(exports);
+        var formatters = module.exports.formatters;
+        /**
+         * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+         */
+
+        formatters.j = function (v) {
+          try {
+            return JSON.stringify(v);
+          } catch (error) {
+            return '[UnexpectedJSONParseError]: ' + error.message;
+          }
+        };
+      }).call(this, require('_process'));
+    }, {
+      "./common": 3,
+      "_process": 2
+    }]
+  }, {}, [4])(4);
+});
+
diff --git a/node_modules/@babel/traverse/node_modules/debug/node.js b/node_modules/@babel/traverse/node_modules/debug/node.js
new file mode 100644
index 00000000..7fc36fe6
--- /dev/null
+++ b/node_modules/@babel/traverse/node_modules/debug/node.js
@@ -0,0 +1 @@
+module.exports = require('./src/node');
diff --git a/node_modules/@babel/traverse/node_modules/debug/package.json b/node_modules/@babel/traverse/node_modules/debug/package.json
new file mode 100644
index 00000000..3650bb0b
--- /dev/null
+++ b/node_modules/@babel/traverse/node_modules/debug/package.json
@@ -0,0 +1,51 @@
+{
+  "name": "debug",
+  "version": "3.2.6",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/visionmedia/debug.git"
+  },
+  "description": "small debugging utility",
+  "keywords": [
+    "debug",
+    "log",
+    "debugger"
+  ],
+  "files": [
+    "src",
+    "node.js",
+    "dist/debug.js",
+    "LICENSE",
+    "README.md"
+  ],
+  "author": "TJ Holowaychuk <tj@vision-media.ca>",
+  "contributors": [
+    "Nathan Rajlich <nathan@tootallnate.net> (http://n8.io)",
+    "Andrew Rhyne <rhyneandrew@gmail.com>"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "ms": "^2.1.1"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.0.0",
+    "@babel/core": "^7.0.0",
+    "@babel/preset-env": "^7.0.0",
+    "browserify": "14.4.0",
+    "chai": "^3.5.0",
+    "concurrently": "^3.1.0",
+    "coveralls": "^3.0.2",
+    "istanbul": "^0.4.5",
+    "karma": "^3.0.0",
+    "karma-chai": "^0.1.0",
+    "karma-mocha": "^1.3.0",
+    "karma-phantomjs-launcher": "^1.0.2",
+    "mocha": "^5.2.0",
+    "mocha-lcov-reporter": "^1.2.0",
+    "rimraf": "^2.5.4",
+    "xo": "^0.23.0"
+  },
+  "main": "./src/index.js",
+  "browser": "./src/browser.js",
+  "unpkg": "./dist/debug.js"
+}
diff --git a/node_modules/@babel/traverse/node_modules/debug/src/browser.js b/node_modules/@babel/traverse/node_modules/debug/src/browser.js
new file mode 100644
index 00000000..c924b0ac
--- /dev/null
+++ b/node_modules/@babel/traverse/node_modules/debug/src/browser.js
@@ -0,0 +1,180 @@
+"use strict";
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+/* eslint-env browser */
+
+/**
+ * This is the web browser implementation of `debug()`.
+ */
+exports.log = log;
+exports.formatArgs = formatArgs;
+exports.save = save;
+exports.load = load;
+exports.useColors = useColors;
+exports.storage = localstorage();
+/**
+ * Colors.
+ */
+
+exports.colors = ['#0000CC', '#0000FF', '#0033CC', '#0033FF', '#0066CC', '#0066FF', '#0099CC', '#0099FF', '#00CC00', '#00CC33', '#00CC66', '#00CC99', '#00CCCC', '#00CCFF', '#3300CC', '#3300FF', '#3333CC', '#3333FF', '#3366CC', '#3366FF', '#3399CC', '#3399FF', '#33CC00', '#33CC33', '#33CC66', '#33CC99', '#33CCCC', '#33CCFF', '#6600CC', '#6600FF', '#6633CC', '#6633FF', '#66CC00', '#66CC33', '#9900CC', '#9900FF', '#9933CC', '#9933FF', '#99CC00', '#99CC33', '#CC0000', '#CC0033', '#CC0066', '#CC0099', '#CC00CC', '#CC00FF', '#CC3300', '#CC3333', '#CC3366', '#CC3399', '#CC33CC', '#CC33FF', '#CC6600', '#CC6633', '#CC9900', '#CC9933', '#CCCC00', '#CCCC33', '#FF0000', '#FF0033', '#FF0066', '#FF0099', '#FF00CC', '#FF00FF', '#FF3300', '#FF3333', '#FF3366', '#FF3399', '#FF33CC', '#FF33FF', '#FF6600', '#FF6633', '#FF9900', '#FF9933', '#FFCC00', '#FFCC33'];
+/**
+ * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+ * and the Firebug extension (any Firefox version) are known
+ * to support "%c" CSS customizations.
+ *
+ * TODO: add a `localStorage` variable to explicitly enable/disable colors
+ */
+// eslint-disable-next-line complexity
+
+function useColors() {
+  // NB: In an Electron preload script, document will be defined but not fully
+  // initialized. Since we know we're in Chrome, we'll just detect this case
+  // explicitly
+  if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
+    return true;
+  } // Internet Explorer and Edge do not support colors.
+
+
+  if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+    return false;
+  } // Is webkit? http://stackoverflow.com/a/16459606/376773
+  // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
+
+
+  return typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+  typeof window !== 'undefined' && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+  // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+  typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+  typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+}
+/**
+ * Colorize log arguments if enabled.
+ *
+ * @api public
+ */
+
+
+function formatArgs(args) {
+  args[0] = (this.useColors ? '%c' : '') + this.namespace + (this.useColors ? ' %c' : ' ') + args[0] + (this.useColors ? '%c ' : ' ') + '+' + module.exports.humanize(this.diff);
+
+  if (!this.useColors) {
+    return;
+  }
+
+  var c = 'color: ' + this.color;
+  args.splice(1, 0, c, 'color: inherit'); // The final "%c" is somewhat tricky, because there could be other
+  // arguments passed either before or after the %c, so we need to
+  // figure out the correct index to insert the CSS into
+
+  var index = 0;
+  var lastC = 0;
+  args[0].replace(/%[a-zA-Z%]/g, function (match) {
+    if (match === '%%') {
+      return;
+    }
+
+    index++;
+
+    if (match === '%c') {
+      // We only are interested in the *last* %c
+      // (the user may have provided their own)
+      lastC = index;
+    }
+  });
+  args.splice(lastC, 0, c);
+}
+/**
+ * Invokes `console.log()` when available.
+ * No-op when `console.log` is not a "function".
+ *
+ * @api public
+ */
+
+
+function log() {
+  var _console;
+
+  // This hackery is required for IE8/9, where
+  // the `console.log` function doesn't have 'apply'
+  return (typeof console === "undefined" ? "undefined" : _typeof(console)) === 'object' && console.log && (_console = console).log.apply(_console, arguments);
+}
+/**
+ * Save `namespaces`.
+ *
+ * @param {String} namespaces
+ * @api private
+ */
+
+
+function save(namespaces) {
+  try {
+    if (namespaces) {
+      exports.storage.setItem('debug', namespaces);
+    } else {
+      exports.storage.removeItem('debug');
+    }
+  } catch (error) {// Swallow
+    // XXX (@Qix-) should we be logging these?
+  }
+}
+/**
+ * Load `namespaces`.
+ *
+ * @return {String} returns the previously persisted debug modes
+ * @api private
+ */
+
+
+function load() {
+  var r;
+
+  try {
+    r = exports.storage.getItem('debug');
+  } catch (error) {} // Swallow
+  // XXX (@Qix-) should we be logging these?
+  // If debug isn't set in LS, and we're in Electron, try to load $DEBUG
+
+
+  if (!r && typeof process !== 'undefined' && 'env' in process) {
+    r = process.env.DEBUG;
+  }
+
+  return r;
+}
+/**
+ * Localstorage attempts to return the localstorage.
+ *
+ * This is necessary because safari throws
+ * when a user disables cookies/localstorage
+ * and you attempt to access it.
+ *
+ * @return {LocalStorage}
+ * @api private
+ */
+
+
+function localstorage() {
+  try {
+    // TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
+    // The Browser also has localStorage in the global context.
+    return localStorage;
+  } catch (error) {// Swallow
+    // XXX (@Qix-) should we be logging these?
+  }
+}
+
+module.exports = require('./common')(exports);
+var formatters = module.exports.formatters;
+/**
+ * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+ */
+
+formatters.j = function (v) {
+  try {
+    return JSON.stringify(v);
+  } catch (error) {
+    return '[UnexpectedJSONParseError]: ' + error.message;
+  }
+};
+
diff --git a/node_modules/@babel/traverse/node_modules/debug/src/common.js b/node_modules/@babel/traverse/node_modules/debug/src/common.js
new file mode 100644
index 00000000..e0de3fb5
--- /dev/null
+++ b/node_modules/@babel/traverse/node_modules/debug/src/common.js
@@ -0,0 +1,249 @@
+"use strict";
+
+/**
+ * This is the common logic for both the Node.js and web browser
+ * implementations of `debug()`.
+ */
+function setup(env) {
+  createDebug.debug = createDebug;
+  createDebug.default = createDebug;
+  createDebug.coerce = coerce;
+  createDebug.disable = disable;
+  createDebug.enable = enable;
+  createDebug.enabled = enabled;
+  createDebug.humanize = require('ms');
+  Object.keys(env).forEach(function (key) {
+    createDebug[key] = env[key];
+  });
+  /**
+  * Active `debug` instances.
+  */
+
+  createDebug.instances = [];
+  /**
+  * The currently active debug mode names, and names to skip.
+  */
+
+  createDebug.names = [];
+  createDebug.skips = [];
+  /**
+  * Map of special "%n" handling functions, for the debug "format" argument.
+  *
+  * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+  */
+
+  createDebug.formatters = {};
+  /**
+  * Selects a color for a debug namespace
+  * @param {String} namespace The namespace string for the for the debug instance to be colored
+  * @return {Number|String} An ANSI color code for the given namespace
+  * @api private
+  */
+
+  function selectColor(namespace) {
+    var hash = 0;
+
+    for (var i = 0; i < namespace.length; i++) {
+      hash = (hash << 5) - hash + namespace.charCodeAt(i);
+      hash |= 0; // Convert to 32bit integer
+    }
+
+    return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+  }
+
+  createDebug.selectColor = selectColor;
+  /**
+  * Create a debugger with the given `namespace`.
+  *
+  * @param {String} namespace
+  * @return {Function}
+  * @api public
+  */
+
+  function createDebug(namespace) {
+    var prevTime;
+
+    function debug() {
+      // Disabled?
+      if (!debug.enabled) {
+        return;
+      }
+
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      var self = debug; // Set `diff` timestamp
+
+      var curr = Number(new Date());
+      var ms = curr - (prevTime || curr);
+      self.diff = ms;
+      self.prev = prevTime;
+      self.curr = curr;
+      prevTime = curr;
+      args[0] = createDebug.coerce(args[0]);
+
+      if (typeof args[0] !== 'string') {
+        // Anything else let's inspect with %O
+        args.unshift('%O');
+      } // Apply any `formatters` transformations
+
+
+      var index = 0;
+      args[0] = args[0].replace(/%([a-zA-Z%])/g, function (match, format) {
+        // If we encounter an escaped % then don't increase the array index
+        if (match === '%%') {
+          return match;
+        }
+
+        index++;
+        var formatter = createDebug.formatters[format];
+
+        if (typeof formatter === 'function') {
+          var val = args[index];
+          match = formatter.call(self, val); // Now we need to remove `args[index]` since it's inlined in the `format`
+
+          args.splice(index, 1);
+          index--;
+        }
+
+        return match;
+      }); // Apply env-specific formatting (colors, etc.)
+
+      createDebug.formatArgs.call(self, args);
+      var logFn = self.log || createDebug.log;
+      logFn.apply(self, args);
+    }
+
+    debug.namespace = namespace;
+    debug.enabled = createDebug.enabled(namespace);
+    debug.useColors = createDebug.useColors();
+    debug.color = selectColor(namespace);
+    debug.destroy = destroy;
+    debug.extend = extend; // Debug.formatArgs = formatArgs;
+    // debug.rawLog = rawLog;
+    // env-specific initialization logic for debug instances
+
+    if (typeof createDebug.init === 'function') {
+      createDebug.init(debug);
+    }
+
+    createDebug.instances.push(debug);
+    return debug;
+  }
+
+  function destroy() {
+    var index = createDebug.instances.indexOf(this);
+
+    if (index !== -1) {
+      createDebug.instances.splice(index, 1);
+      return true;
+    }
+
+    return false;
+  }
+
+  function extend(namespace, delimiter) {
+    return createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
+  }
+  /**
+  * Enables a debug mode by namespaces. This can include modes
+  * separated by a colon and wildcards.
+  *
+  * @param {String} namespaces
+  * @api public
+  */
+
+
+  function enable(namespaces) {
+    createDebug.save(namespaces);
+    createDebug.names = [];
+    createDebug.skips = [];
+    var i;
+    var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
+    var len = split.length;
+
+    for (i = 0; i < len; i++) {
+      if (!split[i]) {
+        // ignore empty strings
+        continue;
+      }
+
+      namespaces = split[i].replace(/\*/g, '.*?');
+
+      if (namespaces[0] === '-') {
+        createDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
+      } else {
+        createDebug.names.push(new RegExp('^' + namespaces + '$'));
+      }
+    }
+
+    for (i = 0; i < createDebug.instances.length; i++) {
+      var instance = createDebug.instances[i];
+      instance.enabled = createDebug.enabled(instance.namespace);
+    }
+  }
+  /**
+  * Disable debug output.
+  *
+  * @api public
+  */
+
+
+  function disable() {
+    createDebug.enable('');
+  }
+  /**
+  * Returns true if the given mode name is enabled, false otherwise.
+  *
+  * @param {String} name
+  * @return {Boolean}
+  * @api public
+  */
+
+
+  function enabled(name) {
+    if (name[name.length - 1] === '*') {
+      return true;
+    }
+
+    var i;
+    var len;
+
+    for (i = 0, len = createDebug.skips.length; i < len; i++) {
+      if (createDebug.skips[i].test(name)) {
+        return false;
+      }
+    }
+
+    for (i = 0, len = createDebug.names.length; i < len; i++) {
+      if (createDebug.names[i].test(name)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+  /**
+  * Coerce `val`.
+  *
+  * @param {Mixed} val
+  * @return {Mixed}
+  * @api private
+  */
+
+
+  function coerce(val) {
+    if (val instanceof Error) {
+      return val.stack || val.message;
+    }
+
+    return val;
+  }
+
+  createDebug.enable(createDebug.load());
+  return createDebug;
+}
+
+module.exports = setup;
+
diff --git a/node_modules/@babel/traverse/node_modules/debug/src/index.js b/node_modules/@babel/traverse/node_modules/debug/src/index.js
new file mode 100644
index 00000000..02173159
--- /dev/null
+++ b/node_modules/@babel/traverse/node_modules/debug/src/index.js
@@ -0,0 +1,12 @@
+"use strict";
+
+/**
+ * Detect Electron renderer / nwjs process, which is node, but we should
+ * treat as a browser.
+ */
+if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
+  module.exports = require('./browser.js');
+} else {
+  module.exports = require('./node.js');
+}
+
diff --git a/node_modules/@babel/traverse/node_modules/debug/src/node.js b/node_modules/@babel/traverse/node_modules/debug/src/node.js
new file mode 100644
index 00000000..dbbb5f10
--- /dev/null
+++ b/node_modules/@babel/traverse/node_modules/debug/src/node.js
@@ -0,0 +1,174 @@
+"use strict";
+
+/**
+ * Module dependencies.
+ */
+var tty = require('tty');
+
+var util = require('util');
+/**
+ * This is the Node.js implementation of `debug()`.
+ */
+
+
+exports.init = init;
+exports.log = log;
+exports.formatArgs = formatArgs;
+exports.save = save;
+exports.load = load;
+exports.useColors = useColors;
+/**
+ * Colors.
+ */
+
+exports.colors = [6, 2, 3, 4, 5, 1];
+
+try {
+  // Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
+  // eslint-disable-next-line import/no-extraneous-dependencies
+  var supportsColor = require('supports-color');
+
+  if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+    exports.colors = [20, 21, 26, 27, 32, 33, 38, 39, 40, 41, 42, 43, 44, 45, 56, 57, 62, 63, 68, 69, 74, 75, 76, 77, 78, 79, 80, 81, 92, 93, 98, 99, 112, 113, 128, 129, 134, 135, 148, 149, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 178, 179, 184, 185, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 214, 215, 220, 221];
+  }
+} catch (error) {} // Swallow - we only care if `supports-color` is available; it doesn't have to be.
+
+/**
+ * Build up the default `inspectOpts` object from the environment variables.
+ *
+ *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+ */
+
+
+exports.inspectOpts = Object.keys(process.env).filter(function (key) {
+  return /^debug_/i.test(key);
+}).reduce(function (obj, key) {
+  // Camel-case
+  var prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, function (_, k) {
+    return k.toUpperCase();
+  }); // Coerce string value into JS value
+
+  var val = process.env[key];
+
+  if (/^(yes|on|true|enabled)$/i.test(val)) {
+    val = true;
+  } else if (/^(no|off|false|disabled)$/i.test(val)) {
+    val = false;
+  } else if (val === 'null') {
+    val = null;
+  } else {
+    val = Number(val);
+  }
+
+  obj[prop] = val;
+  return obj;
+}, {});
+/**
+ * Is stdout a TTY? Colored output is enabled when `true`.
+ */
+
+function useColors() {
+  return 'colors' in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+}
+/**
+ * Adds ANSI color escape codes if enabled.
+ *
+ * @api public
+ */
+
+
+function formatArgs(args) {
+  var name = this.namespace,
+      useColors = this.useColors;
+
+  if (useColors) {
+    var c = this.color;
+    var colorCode = "\x1B[3" + (c < 8 ? c : '8;5;' + c);
+    var prefix = "  ".concat(colorCode, ";1m").concat(name, " \x1B[0m");
+    args[0] = prefix + args[0].split('\n').join('\n' + prefix);
+    args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + "\x1B[0m");
+  } else {
+    args[0] = getDate() + name + ' ' + args[0];
+  }
+}
+
+function getDate() {
+  if (exports.inspectOpts.hideDate) {
+    return '';
+  }
+
+  return new Date().toISOString() + ' ';
+}
+/**
+ * Invokes `util.format()` with the specified arguments and writes to stderr.
+ */
+
+
+function log() {
+  return process.stderr.write(util.format.apply(util, arguments) + '\n');
+}
+/**
+ * Save `namespaces`.
+ *
+ * @param {String} namespaces
+ * @api private
+ */
+
+
+function save(namespaces) {
+  if (namespaces) {
+    process.env.DEBUG = namespaces;
+  } else {
+    // If you set a process.env field to null or undefined, it gets cast to the
+    // string 'null' or 'undefined'. Just delete instead.
+    delete process.env.DEBUG;
+  }
+}
+/**
+ * Load `namespaces`.
+ *
+ * @return {String} returns the previously persisted debug modes
+ * @api private
+ */
+
+
+function load() {
+  return process.env.DEBUG;
+}
+/**
+ * Init logic for `debug` instances.
+ *
+ * Create a new `inspectOpts` object in case `useColors` is set
+ * differently for a particular `debug` instance.
+ */
+
+
+function init(debug) {
+  debug.inspectOpts = {};
+  var keys = Object.keys(exports.inspectOpts);
+
+  for (var i = 0; i < keys.length; i++) {
+    debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+  }
+}
+
+module.exports = require('./common')(exports);
+var formatters = module.exports.formatters;
+/**
+ * Map %o to `util.inspect()`, all on a single line.
+ */
+
+formatters.o = function (v) {
+  this.inspectOpts.colors = this.useColors;
+  return util.inspect(v, this.inspectOpts).replace(/\s*\n\s*/g, ' ');
+};
+/**
+ * Map %O to `util.inspect()`, allowing multiple lines if needed.
+ */
+
+
+formatters.O = function (v) {
+  this.inspectOpts.colors = this.useColors;
+  return util.inspect(v, this.inspectOpts);
+};
+
diff --git a/node_modules/@babel/traverse/node_modules/ms/index.js b/node_modules/@babel/traverse/node_modules/ms/index.js
new file mode 100644
index 00000000..72297501
--- /dev/null
+++ b/node_modules/@babel/traverse/node_modules/ms/index.js
@@ -0,0 +1,162 @@
+/**
+ * Helpers.
+ */
+
+var s = 1000;
+var m = s * 60;
+var h = m * 60;
+var d = h * 24;
+var w = d * 7;
+var y = d * 365.25;
+
+/**
+ * Parse or format the given `val`.
+ *
+ * Options:
+ *
+ *  - `long` verbose formatting [false]
+ *
+ * @param {String|Number} val
+ * @param {Object} [options]
+ * @throws {Error} throw an error if val is not a non-empty string or a number
+ * @return {String|Number}
+ * @api public
+ */
+
+module.exports = function(val, options) {
+  options = options || {};
+  var type = typeof val;
+  if (type === 'string' && val.length > 0) {
+    return parse(val);
+  } else if (type === 'number' && isNaN(val) === false) {
+    return options.long ? fmtLong(val) : fmtShort(val);
+  }
+  throw new Error(
+    'val is not a non-empty string or a valid number. val=' +
+      JSON.stringify(val)
+  );
+};
+
+/**
+ * Parse the given `str` and return milliseconds.
+ *
+ * @param {String} str
+ * @return {Number}
+ * @api private
+ */
+
+function parse(str) {
+  str = String(str);
+  if (str.length > 100) {
+    return;
+  }
+  var match = /^((?:\d+)?\-?\d?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+    str
+  );
+  if (!match) {
+    return;
+  }
+  var n = parseFloat(match[1]);
+  var type = (match[2] || 'ms').toLowerCase();
+  switch (type) {
+    case 'years':
+    case 'year':
+    case 'yrs':
+    case 'yr':
+    case 'y':
+      return n * y;
+    case 'weeks':
+    case 'week':
+    case 'w':
+      return n * w;
+    case 'days':
+    case 'day':
+    case 'd':
+      return n * d;
+    case 'hours':
+    case 'hour':
+    case 'hrs':
+    case 'hr':
+    case 'h':
+      return n * h;
+    case 'minutes':
+    case 'minute':
+    case 'mins':
+    case 'min':
+    case 'm':
+      return n * m;
+    case 'seconds':
+    case 'second':
+    case 'secs':
+    case 'sec':
+    case 's':
+      return n * s;
+    case 'milliseconds':
+    case 'millisecond':
+    case 'msecs':
+    case 'msec':
+    case 'ms':
+      return n;
+    default:
+      return undefined;
+  }
+}
+
+/**
+ * Short format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function fmtShort(ms) {
+  var msAbs = Math.abs(ms);
+  if (msAbs >= d) {
+    return Math.round(ms / d) + 'd';
+  }
+  if (msAbs >= h) {
+    return Math.round(ms / h) + 'h';
+  }
+  if (msAbs >= m) {
+    return Math.round(ms / m) + 'm';
+  }
+  if (msAbs >= s) {
+    return Math.round(ms / s) + 's';
+  }
+  return ms + 'ms';
+}
+
+/**
+ * Long format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function fmtLong(ms) {
+  var msAbs = Math.abs(ms);
+  if (msAbs >= d) {
+    return plural(ms, msAbs, d, 'day');
+  }
+  if (msAbs >= h) {
+    return plural(ms, msAbs, h, 'hour');
+  }
+  if (msAbs >= m) {
+    return plural(ms, msAbs, m, 'minute');
+  }
+  if (msAbs >= s) {
+    return plural(ms, msAbs, s, 'second');
+  }
+  return ms + ' ms';
+}
+
+/**
+ * Pluralization helper.
+ */
+
+function plural(ms, msAbs, n, name) {
+  var isPlural = msAbs >= n * 1.5;
+  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+}
diff --git a/node_modules/@babel/traverse/node_modules/ms/license.md b/node_modules/@babel/traverse/node_modules/ms/license.md
new file mode 100644
index 00000000..69b61253
--- /dev/null
+++ b/node_modules/@babel/traverse/node_modules/ms/license.md
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Zeit, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/node_modules/@babel/traverse/node_modules/ms/package.json b/node_modules/@babel/traverse/node_modules/ms/package.json
new file mode 100644
index 00000000..fc28cb39
--- /dev/null
+++ b/node_modules/@babel/traverse/node_modules/ms/package.json
@@ -0,0 +1,37 @@
+{
+  "name": "ms",
+  "version": "2.1.1",
+  "description": "Tiny millisecond conversion utility",
+  "repository": "zeit/ms",
+  "main": "./index",
+  "files": [
+    "index.js"
+  ],
+  "scripts": {
+    "precommit": "lint-staged",
+    "lint": "eslint lib/* bin/*",
+    "test": "mocha tests.js"
+  },
+  "eslintConfig": {
+    "extends": "eslint:recommended",
+    "env": {
+      "node": true,
+      "es6": true
+    }
+  },
+  "lint-staged": {
+    "*.js": [
+      "npm run lint",
+      "prettier --single-quote --write",
+      "git add"
+    ]
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "eslint": "4.12.1",
+    "expect.js": "0.3.1",
+    "husky": "0.14.3",
+    "lint-staged": "5.0.0",
+    "mocha": "4.0.1"
+  }
+}
diff --git a/node_modules/@babel/traverse/node_modules/ms/readme.md b/node_modules/@babel/traverse/node_modules/ms/readme.md
new file mode 100644
index 00000000..bb767293
--- /dev/null
+++ b/node_modules/@babel/traverse/node_modules/ms/readme.md
@@ -0,0 +1,60 @@
+# ms
+
+[![Build Status](https://travis-ci.org/zeit/ms.svg?branch=master)](https://travis-ci.org/zeit/ms)
+[![Slack Channel](http://zeit-slackin.now.sh/badge.svg)](https://zeit.chat/)
+
+Use this package to easily convert various time formats to milliseconds.
+
+## Examples
+
+```js
+ms('2 days')  // 172800000
+ms('1d')      // 86400000
+ms('10h')     // 36000000
+ms('2.5 hrs') // 9000000
+ms('2h')      // 7200000
+ms('1m')      // 60000
+ms('5s')      // 5000
+ms('1y')      // 31557600000
+ms('100')     // 100
+ms('-3 days') // -259200000
+ms('-1h')     // -3600000
+ms('-200')    // -200
+```
+
+### Convert from Milliseconds
+
+```js
+ms(60000)             // "1m"
+ms(2 * 60000)         // "2m"
+ms(-3 * 60000)        // "-3m"
+ms(ms('10 hours'))    // "10h"
+```
+
+### Time Format Written-Out
+
+```js
+ms(60000, { long: true })             // "1 minute"
+ms(2 * 60000, { long: true })         // "2 minutes"
+ms(-3 * 60000, { long: true })        // "-3 minutes"
+ms(ms('10 hours'), { long: true })    // "10 hours"
+```
+
+## Features
+
+- Works both in [Node.js](https://nodejs.org) and in the browser
+- If a number is supplied to `ms`, a string with a unit is returned
+- If a string that contains the number is supplied, it returns it as a number (e.g.: it returns `100` for `'100'`)
+- If you pass a string with a number and a valid unit, the number of equivalent milliseconds is returned
+
+## Related Packages
+
+- [ms.macro](https://github.com/knpwrs/ms.macro) - Run `ms` as a macro at build-time.
+
+## Caught a Bug?
+
+1. [Fork](https://help.github.com/articles/fork-a-repo/) this repository to your own GitHub account and then [clone](https://help.github.com/articles/cloning-a-repository/) it to your local device
+2. Link the package to the global module directory: `npm link`
+3. Within the module you want to test your local development instance of ms, just link it to the dependencies: `npm link ms`. Instead of the default one from npm, Node.js will now use your clone of ms!
+
+As always, you can run the tests using: `npm test`
diff --git a/node_modules/@babel/traverse/package.json b/node_modules/@babel/traverse/package.json
new file mode 100644
index 00000000..9031034f
--- /dev/null
+++ b/node_modules/@babel/traverse/package.json
@@ -0,0 +1,25 @@
+{
+  "name": "@babel/traverse",
+  "version": "7.0.0-beta.47",
+  "description": "The Babel Traverse module maintains the overall tree state, and is responsible for replacing, removing, and adding nodes",
+  "author": "Sebastian McKenzie <sebmck@gmail.com>",
+  "homepage": "https://babeljs.io/",
+  "license": "MIT",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-traverse",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/code-frame": "7.0.0-beta.47",
+    "@babel/generator": "7.0.0-beta.47",
+    "@babel/helper-function-name": "7.0.0-beta.47",
+    "@babel/helper-split-export-declaration": "7.0.0-beta.47",
+    "@babel/types": "7.0.0-beta.47",
+    "babylon": "7.0.0-beta.47",
+    "debug": "^3.1.0",
+    "globals": "^11.1.0",
+    "invariant": "^2.2.0",
+    "lodash": "^4.17.5"
+  },
+  "devDependencies": {
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/types/README.md b/node_modules/@babel/types/README.md
new file mode 100644
index 00000000..d4b183a2
--- /dev/null
+++ b/node_modules/@babel/types/README.md
@@ -0,0 +1,2955 @@
+# @babel/types
+
+> This module contains methods for building ASTs manually and for checking the types of AST nodes.
+
+## Install
+
+```sh
+npm install --save-dev @babel/types
+```
+
+## API
+### anyTypeAnnotation
+```javascript
+t.anyTypeAnnotation()
+```
+
+See also `t.isAnyTypeAnnotation(node, opts)` and `t.assertAnyTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowType`, `FlowBaseAnnotation`
+
+
+---
+
+### arrayExpression
+```javascript
+t.arrayExpression(elements)
+```
+
+See also `t.isArrayExpression(node, opts)` and `t.assertArrayExpression(node, opts)`.
+
+Aliases: `Expression`
+
+ - `elements`: `Array<null | Expression | SpreadElement>` (default: `[]`)
+
+---
+
+### arrayPattern
+```javascript
+t.arrayPattern(elements)
+```
+
+See also `t.isArrayPattern(node, opts)` and `t.assertArrayPattern(node, opts)`.
+
+Aliases: `Pattern`, `PatternLike`, `LVal`
+
+ - `elements`: `Array<PatternLike>` (required)
+ - `decorators`: `Array<Decorator>` (default: `null`)
+ - `typeAnnotation`: `TypeAnnotation | TSTypeAnnotation | Noop` (default: `null`)
+
+---
+
+### arrayTypeAnnotation
+```javascript
+t.arrayTypeAnnotation(elementType)
+```
+
+See also `t.isArrayTypeAnnotation(node, opts)` and `t.assertArrayTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowType`
+
+ - `elementType`: `FlowType` (required)
+
+---
+
+### arrowFunctionExpression
+```javascript
+t.arrowFunctionExpression(params, body, async)
+```
+
+See also `t.isArrowFunctionExpression(node, opts)` and `t.assertArrowFunctionExpression(node, opts)`.
+
+Aliases: `Scopable`, `Function`, `BlockParent`, `FunctionParent`, `Expression`, `Pureish`
+
+ - `params`: `Array<LVal>` (required)
+ - `body`: `BlockStatement | Expression` (required)
+ - `async`: `boolean` (default: `false`)
+ - `expression`: `boolean` (default: `null`)
+ - `generator`: `boolean` (default: `false`)
+ - `returnType`: `TypeAnnotation | TSTypeAnnotation | Noop` (default: `null`)
+ - `typeParameters`: `TypeParameterDeclaration | TSTypeParameterDeclaration | Noop` (default: `null`)
+
+---
+
+### assignmentExpression
+```javascript
+t.assignmentExpression(operator, left, right)
+```
+
+See also `t.isAssignmentExpression(node, opts)` and `t.assertAssignmentExpression(node, opts)`.
+
+Aliases: `Expression`
+
+ - `operator`: `string` (required)
+ - `left`: `LVal` (required)
+ - `right`: `Expression` (required)
+
+---
+
+### assignmentPattern
+```javascript
+t.assignmentPattern(left, right)
+```
+
+See also `t.isAssignmentPattern(node, opts)` and `t.assertAssignmentPattern(node, opts)`.
+
+Aliases: `Pattern`, `PatternLike`, `LVal`
+
+ - `left`: `Identifier | ObjectPattern | ArrayPattern` (required)
+ - `right`: `Expression` (required)
+ - `decorators`: `Array<Decorator>` (default: `null`)
+ - `typeAnnotation`: `TypeAnnotation | TSTypeAnnotation | Noop` (default: `null`)
+
+---
+
+### awaitExpression
+```javascript
+t.awaitExpression(argument)
+```
+
+See also `t.isAwaitExpression(node, opts)` and `t.assertAwaitExpression(node, opts)`.
+
+Aliases: `Expression`, `Terminatorless`
+
+ - `argument`: `Expression` (required)
+
+---
+
+### binaryExpression
+```javascript
+t.binaryExpression(operator, left, right)
+```
+
+See also `t.isBinaryExpression(node, opts)` and `t.assertBinaryExpression(node, opts)`.
+
+Aliases: `Binary`, `Expression`
+
+ - `operator`: `"+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<="` (required)
+ - `left`: `Expression` (required)
+ - `right`: `Expression` (required)
+
+---
+
+### bindExpression
+```javascript
+t.bindExpression(object, callee)
+```
+
+See also `t.isBindExpression(node, opts)` and `t.assertBindExpression(node, opts)`.
+
+Aliases: `Expression`
+
+ - `object` (required)
+ - `callee` (required)
+
+---
+
+### blockStatement
+```javascript
+t.blockStatement(body, directives)
+```
+
+See also `t.isBlockStatement(node, opts)` and `t.assertBlockStatement(node, opts)`.
+
+Aliases: `Scopable`, `BlockParent`, `Block`, `Statement`
+
+ - `body`: `Array<Statement>` (required)
+ - `directives`: `Array<Directive>` (default: `[]`)
+
+---
+
+### booleanLiteral
+```javascript
+t.booleanLiteral(value)
+```
+
+See also `t.isBooleanLiteral(node, opts)` and `t.assertBooleanLiteral(node, opts)`.
+
+Aliases: `Expression`, `Pureish`, `Literal`, `Immutable`
+
+ - `value`: `boolean` (required)
+
+---
+
+### booleanLiteralTypeAnnotation
+```javascript
+t.booleanLiteralTypeAnnotation(value)
+```
+
+See also `t.isBooleanLiteralTypeAnnotation(node, opts)` and `t.assertBooleanLiteralTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowType`
+
+ - `value`: `boolean` (required)
+
+---
+
+### booleanTypeAnnotation
+```javascript
+t.booleanTypeAnnotation()
+```
+
+See also `t.isBooleanTypeAnnotation(node, opts)` and `t.assertBooleanTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowType`, `FlowBaseAnnotation`
+
+
+---
+
+### breakStatement
+```javascript
+t.breakStatement(label)
+```
+
+See also `t.isBreakStatement(node, opts)` and `t.assertBreakStatement(node, opts)`.
+
+Aliases: `Statement`, `Terminatorless`, `CompletionStatement`
+
+ - `label`: `Identifier` (default: `null`)
+
+---
+
+### callExpression
+```javascript
+t.callExpression(callee, arguments)
+```
+
+See also `t.isCallExpression(node, opts)` and `t.assertCallExpression(node, opts)`.
+
+Aliases: `Expression`
+
+ - `callee`: `Expression` (required)
+ - `arguments`: `Array<Expression | SpreadElement | JSXNamespacedName>` (required)
+ - `optional`: `true | false` (default: `null`)
+ - `typeParameters`: `TypeParameterInstantiation | TSTypeParameterInstantiation` (default: `null`)
+
+---
+
+### catchClause
+```javascript
+t.catchClause(param, body)
+```
+
+See also `t.isCatchClause(node, opts)` and `t.assertCatchClause(node, opts)`.
+
+Aliases: `Scopable`, `BlockParent`
+
+ - `param`: `Identifier` (default: `null`)
+ - `body`: `BlockStatement` (required)
+
+---
+
+### classBody
+```javascript
+t.classBody(body)
+```
+
+See also `t.isClassBody(node, opts)` and `t.assertClassBody(node, opts)`.
+
+ - `body`: `Array<ClassMethod | ClassProperty | ClassPrivateProperty | TSDeclareMethod | TSIndexSignature>` (required)
+
+---
+
+### classDeclaration
+```javascript
+t.classDeclaration(id, superClass, body, decorators)
+```
+
+See also `t.isClassDeclaration(node, opts)` and `t.assertClassDeclaration(node, opts)`.
+
+Aliases: `Scopable`, `Class`, `Statement`, `Declaration`, `Pureish`
+
+ - `id`: `Identifier` (default: `null`)
+ - `superClass`: `Expression` (default: `null`)
+ - `body`: `ClassBody` (required)
+ - `decorators`: `Array<Decorator>` (default: `null`)
+ - `abstract`: `boolean` (default: `null`)
+ - `declare`: `boolean` (default: `null`)
+ - `implements`: `Array<TSExpressionWithTypeArguments | ClassImplements>` (default: `null`)
+ - `mixins` (default: `null`)
+ - `superTypeParameters`: `TypeParameterInstantiation | TSTypeParameterInstantiation` (default: `null`)
+ - `typeParameters`: `TypeParameterDeclaration | TSTypeParameterDeclaration | Noop` (default: `null`)
+
+---
+
+### classExpression
+```javascript
+t.classExpression(id, superClass, body, decorators)
+```
+
+See also `t.isClassExpression(node, opts)` and `t.assertClassExpression(node, opts)`.
+
+Aliases: `Scopable`, `Class`, `Expression`, `Pureish`
+
+ - `id`: `Identifier` (default: `null`)
+ - `superClass`: `Expression` (default: `null`)
+ - `body`: `ClassBody` (required)
+ - `decorators`: `Array<Decorator>` (default: `null`)
+ - `implements`: `Array<TSExpressionWithTypeArguments | ClassImplements>` (default: `null`)
+ - `mixins` (default: `null`)
+ - `superTypeParameters`: `TypeParameterInstantiation | TSTypeParameterInstantiation` (default: `null`)
+ - `typeParameters`: `TypeParameterDeclaration | TSTypeParameterDeclaration | Noop` (default: `null`)
+
+---
+
+### classImplements
+```javascript
+t.classImplements(id, typeParameters)
+```
+
+See also `t.isClassImplements(node, opts)` and `t.assertClassImplements(node, opts)`.
+
+Aliases: `Flow`
+
+ - `id`: `Identifier` (required)
+ - `typeParameters`: `TypeParameterInstantiation` (default: `null`)
+
+---
+
+### classMethod
+```javascript
+t.classMethod(kind, key, params, body, computed, static)
+```
+
+See also `t.isClassMethod(node, opts)` and `t.assertClassMethod(node, opts)`.
+
+Aliases: `Function`, `Scopable`, `BlockParent`, `FunctionParent`, `Method`
+
+ - `kind`: `"get" | "set" | "method" | "constructor"` (default: `'method'`)
+ - `key`: if computed then `Expression` else `Identifier | Literal` (required)
+ - `params`: `Array<LVal>` (required)
+ - `body`: `BlockStatement` (required)
+ - `computed`: `boolean` (default: `false`)
+ - `static`: `boolean` (default: `null`)
+ - `abstract`: `boolean` (default: `null`)
+ - `access`: `"public" | "private" | "protected"` (default: `null`)
+ - `accessibility`: `"public" | "private" | "protected"` (default: `null`)
+ - `async`: `boolean` (default: `false`)
+ - `decorators`: `Array<Decorator>` (default: `null`)
+ - `generator`: `boolean` (default: `false`)
+ - `optional`: `boolean` (default: `null`)
+ - `returnType`: `TypeAnnotation | TSTypeAnnotation | Noop` (default: `null`)
+ - `typeParameters`: `TypeParameterDeclaration | TSTypeParameterDeclaration | Noop` (default: `null`)
+
+---
+
+### classPrivateProperty
+```javascript
+t.classPrivateProperty(key, value)
+```
+
+See also `t.isClassPrivateProperty(node, opts)` and `t.assertClassPrivateProperty(node, opts)`.
+
+Aliases: `Property`, `Private`
+
+ - `key`: `PrivateName` (required)
+ - `value`: `Expression` (default: `null`)
+
+---
+
+### classProperty
+```javascript
+t.classProperty(key, value, typeAnnotation, decorators, computed)
+```
+
+See also `t.isClassProperty(node, opts)` and `t.assertClassProperty(node, opts)`.
+
+Aliases: `Property`
+
+ - `key`: `Identifier | StringLiteral | NumericLiteral | Expression` (required)
+ - `value`: `Expression` (default: `null`)
+ - `typeAnnotation`: `TypeAnnotation | TSTypeAnnotation | Noop` (default: `null`)
+ - `decorators`: `Array<Decorator>` (default: `null`)
+ - `computed`: `boolean` (default: `false`)
+ - `abstract`: `boolean` (default: `null`)
+ - `accessibility`: `"public" | "private" | "protected"` (default: `null`)
+ - `definite`: `boolean` (default: `null`)
+ - `optional`: `boolean` (default: `null`)
+ - `readonly`: `boolean` (default: `null`)
+ - `static`: `boolean` (default: `null`)
+
+---
+
+### conditionalExpression
+```javascript
+t.conditionalExpression(test, consequent, alternate)
+```
+
+See also `t.isConditionalExpression(node, opts)` and `t.assertConditionalExpression(node, opts)`.
+
+Aliases: `Expression`, `Conditional`
+
+ - `test`: `Expression` (required)
+ - `consequent`: `Expression` (required)
+ - `alternate`: `Expression` (required)
+
+---
+
+### continueStatement
+```javascript
+t.continueStatement(label)
+```
+
+See also `t.isContinueStatement(node, opts)` and `t.assertContinueStatement(node, opts)`.
+
+Aliases: `Statement`, `Terminatorless`, `CompletionStatement`
+
+ - `label`: `Identifier` (default: `null`)
+
+---
+
+### debuggerStatement
+```javascript
+t.debuggerStatement()
+```
+
+See also `t.isDebuggerStatement(node, opts)` and `t.assertDebuggerStatement(node, opts)`.
+
+Aliases: `Statement`
+
+
+---
+
+### declareClass
+```javascript
+t.declareClass(id, typeParameters, extends, body)
+```
+
+See also `t.isDeclareClass(node, opts)` and `t.assertDeclareClass(node, opts)`.
+
+Aliases: `Flow`, `FlowDeclaration`, `Statement`, `Declaration`
+
+ - `id`: `Identifier` (required)
+ - `typeParameters`: `TypeParameterInstantiation` (default: `null`)
+ - `extends`: `Array<InterfaceExtends>` (default: `null`)
+ - `body`: `ObjectTypeAnnotation` (required)
+ - `implements`: `Array<ClassImplements>` (default: `null`)
+ - `mixins`: `Array<InterfaceExtends>` (default: `null`)
+
+---
+
+### declareExportAllDeclaration
+```javascript
+t.declareExportAllDeclaration(source)
+```
+
+See also `t.isDeclareExportAllDeclaration(node, opts)` and `t.assertDeclareExportAllDeclaration(node, opts)`.
+
+Aliases: `Flow`, `FlowDeclaration`, `Statement`, `Declaration`
+
+ - `source`: `StringLiteral` (required)
+ - `exportKind`: `["type","value"]` (default: `null`)
+
+---
+
+### declareExportDeclaration
+```javascript
+t.declareExportDeclaration(declaration, specifiers, source)
+```
+
+See also `t.isDeclareExportDeclaration(node, opts)` and `t.assertDeclareExportDeclaration(node, opts)`.
+
+Aliases: `Flow`, `FlowDeclaration`, `Statement`, `Declaration`
+
+ - `declaration`: `Flow` (default: `null`)
+ - `specifiers`: `Array<ExportSpecifier | ExportNamespaceSpecifier>` (default: `null`)
+ - `source`: `StringLiteral` (default: `null`)
+ - `default`: `boolean` (default: `null`)
+
+---
+
+### declareFunction
+```javascript
+t.declareFunction(id)
+```
+
+See also `t.isDeclareFunction(node, opts)` and `t.assertDeclareFunction(node, opts)`.
+
+Aliases: `Flow`, `FlowDeclaration`, `Statement`, `Declaration`
+
+ - `id`: `Identifier` (required)
+ - `predicate`: `DeclaredPredicate` (default: `null`)
+
+---
+
+### declareInterface
+```javascript
+t.declareInterface(id, typeParameters, extends, body)
+```
+
+See also `t.isDeclareInterface(node, opts)` and `t.assertDeclareInterface(node, opts)`.
+
+Aliases: `Flow`, `FlowDeclaration`, `Statement`, `Declaration`
+
+ - `id`: `Identifier` (required)
+ - `typeParameters`: `TypeParameterDeclaration` (default: `null`)
+ - `extends`: `Array<InterfaceExtends>` (default: `null`)
+ - `body`: `ObjectTypeAnnotation` (required)
+ - `implements`: `Array<ClassImplements>` (default: `null`)
+ - `mixins`: `Array<InterfaceExtends>` (default: `null`)
+
+---
+
+### declareModule
+```javascript
+t.declareModule(id, body, kind)
+```
+
+See also `t.isDeclareModule(node, opts)` and `t.assertDeclareModule(node, opts)`.
+
+Aliases: `Flow`, `FlowDeclaration`, `Statement`, `Declaration`
+
+ - `id`: `Identifier | StringLiteral` (required)
+ - `body`: `BlockStatement` (required)
+ - `kind`: `"CommonJS" | "ES"` (default: `null`)
+
+---
+
+### declareModuleExports
+```javascript
+t.declareModuleExports(typeAnnotation)
+```
+
+See also `t.isDeclareModuleExports(node, opts)` and `t.assertDeclareModuleExports(node, opts)`.
+
+Aliases: `Flow`, `FlowDeclaration`, `Statement`, `Declaration`
+
+ - `typeAnnotation`: `TypeAnnotation` (required)
+
+---
+
+### declareOpaqueType
+```javascript
+t.declareOpaqueType(id, typeParameters, supertype)
+```
+
+See also `t.isDeclareOpaqueType(node, opts)` and `t.assertDeclareOpaqueType(node, opts)`.
+
+Aliases: `Flow`, `FlowDeclaration`, `Statement`, `Declaration`
+
+ - `id`: `Identifier` (required)
+ - `typeParameters`: `TypeParameterDeclaration` (default: `null`)
+ - `supertype`: `FlowType` (default: `null`)
+
+---
+
+### declareTypeAlias
+```javascript
+t.declareTypeAlias(id, typeParameters, right)
+```
+
+See also `t.isDeclareTypeAlias(node, opts)` and `t.assertDeclareTypeAlias(node, opts)`.
+
+Aliases: `Flow`, `FlowDeclaration`, `Statement`, `Declaration`
+
+ - `id`: `Identifier` (required)
+ - `typeParameters`: `TypeParameterDeclaration` (default: `null`)
+ - `right`: `FlowType` (required)
+
+---
+
+### declareVariable
+```javascript
+t.declareVariable(id)
+```
+
+See also `t.isDeclareVariable(node, opts)` and `t.assertDeclareVariable(node, opts)`.
+
+Aliases: `Flow`, `FlowDeclaration`, `Statement`, `Declaration`
+
+ - `id`: `Identifier` (required)
+
+---
+
+### declaredPredicate
+```javascript
+t.declaredPredicate(value)
+```
+
+See also `t.isDeclaredPredicate(node, opts)` and `t.assertDeclaredPredicate(node, opts)`.
+
+Aliases: `Flow`, `FlowPredicate`
+
+ - `value`: `Flow` (required)
+
+---
+
+### decorator
+```javascript
+t.decorator(callee, arguments)
+```
+
+See also `t.isDecorator(node, opts)` and `t.assertDecorator(node, opts)`.
+
+ - `callee`: `Expression` (required)
+ - `arguments`: `Array<Expression | SpreadElement>` (default: `null`)
+
+---
+
+### directive
+```javascript
+t.directive(value)
+```
+
+See also `t.isDirective(node, opts)` and `t.assertDirective(node, opts)`.
+
+ - `value`: `DirectiveLiteral` (required)
+
+---
+
+### directiveLiteral
+```javascript
+t.directiveLiteral(value)
+```
+
+See also `t.isDirectiveLiteral(node, opts)` and `t.assertDirectiveLiteral(node, opts)`.
+
+ - `value`: `string` (required)
+
+---
+
+### doExpression
+```javascript
+t.doExpression(body)
+```
+
+See also `t.isDoExpression(node, opts)` and `t.assertDoExpression(node, opts)`.
+
+Aliases: `Expression`
+
+ - `body`: `BlockStatement` (required)
+
+---
+
+### doWhileStatement
+```javascript
+t.doWhileStatement(test, body)
+```
+
+See also `t.isDoWhileStatement(node, opts)` and `t.assertDoWhileStatement(node, opts)`.
+
+Aliases: `Statement`, `BlockParent`, `Loop`, `While`, `Scopable`
+
+ - `test`: `Expression` (required)
+ - `body`: `Statement` (required)
+
+---
+
+### emptyStatement
+```javascript
+t.emptyStatement()
+```
+
+See also `t.isEmptyStatement(node, opts)` and `t.assertEmptyStatement(node, opts)`.
+
+Aliases: `Statement`
+
+
+---
+
+### emptyTypeAnnotation
+```javascript
+t.emptyTypeAnnotation()
+```
+
+See also `t.isEmptyTypeAnnotation(node, opts)` and `t.assertEmptyTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowType`, `FlowBaseAnnotation`
+
+
+---
+
+### existsTypeAnnotation
+```javascript
+t.existsTypeAnnotation()
+```
+
+See also `t.isExistsTypeAnnotation(node, opts)` and `t.assertExistsTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowType`
+
+
+---
+
+### exportAllDeclaration
+```javascript
+t.exportAllDeclaration(source)
+```
+
+See also `t.isExportAllDeclaration(node, opts)` and `t.assertExportAllDeclaration(node, opts)`.
+
+Aliases: `Statement`, `Declaration`, `ModuleDeclaration`, `ExportDeclaration`
+
+ - `source`: `StringLiteral` (required)
+
+---
+
+### exportDefaultDeclaration
+```javascript
+t.exportDefaultDeclaration(declaration)
+```
+
+See also `t.isExportDefaultDeclaration(node, opts)` and `t.assertExportDefaultDeclaration(node, opts)`.
+
+Aliases: `Statement`, `Declaration`, `ModuleDeclaration`, `ExportDeclaration`
+
+ - `declaration`: `FunctionDeclaration | TSDeclareFunction | ClassDeclaration | Expression` (required)
+
+---
+
+### exportDefaultSpecifier
+```javascript
+t.exportDefaultSpecifier(exported)
+```
+
+See also `t.isExportDefaultSpecifier(node, opts)` and `t.assertExportDefaultSpecifier(node, opts)`.
+
+Aliases: `ModuleSpecifier`
+
+ - `exported`: `Identifier` (required)
+
+---
+
+### exportNamedDeclaration
+```javascript
+t.exportNamedDeclaration(declaration, specifiers, source)
+```
+
+See also `t.isExportNamedDeclaration(node, opts)` and `t.assertExportNamedDeclaration(node, opts)`.
+
+Aliases: `Statement`, `Declaration`, `ModuleDeclaration`, `ExportDeclaration`
+
+ - `declaration`: `Declaration` (default: `null`)
+ - `specifiers`: `Array<ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier>` (required)
+ - `source`: `StringLiteral` (default: `null`)
+
+---
+
+### exportNamespaceSpecifier
+```javascript
+t.exportNamespaceSpecifier(exported)
+```
+
+See also `t.isExportNamespaceSpecifier(node, opts)` and `t.assertExportNamespaceSpecifier(node, opts)`.
+
+Aliases: `ModuleSpecifier`
+
+ - `exported`: `Identifier` (required)
+
+---
+
+### exportSpecifier
+```javascript
+t.exportSpecifier(local, exported)
+```
+
+See also `t.isExportSpecifier(node, opts)` and `t.assertExportSpecifier(node, opts)`.
+
+Aliases: `ModuleSpecifier`
+
+ - `local`: `Identifier` (required)
+ - `exported`: `Identifier` (required)
+
+---
+
+### expressionStatement
+```javascript
+t.expressionStatement(expression)
+```
+
+See also `t.isExpressionStatement(node, opts)` and `t.assertExpressionStatement(node, opts)`.
+
+Aliases: `Statement`, `ExpressionWrapper`
+
+ - `expression`: `Expression` (required)
+
+---
+
+### file
+```javascript
+t.file(program, comments, tokens)
+```
+
+See also `t.isFile(node, opts)` and `t.assertFile(node, opts)`.
+
+ - `program`: `Program` (required)
+ - `comments` (required)
+ - `tokens` (required)
+
+---
+
+### forInStatement
+```javascript
+t.forInStatement(left, right, body)
+```
+
+See also `t.isForInStatement(node, opts)` and `t.assertForInStatement(node, opts)`.
+
+Aliases: `Scopable`, `Statement`, `For`, `BlockParent`, `Loop`, `ForXStatement`
+
+ - `left`: `VariableDeclaration | LVal` (required)
+ - `right`: `Expression` (required)
+ - `body`: `Statement` (required)
+
+---
+
+### forOfStatement
+```javascript
+t.forOfStatement(left, right, body)
+```
+
+See also `t.isForOfStatement(node, opts)` and `t.assertForOfStatement(node, opts)`.
+
+Aliases: `Scopable`, `Statement`, `For`, `BlockParent`, `Loop`, `ForXStatement`
+
+ - `left`: `VariableDeclaration | LVal` (required)
+ - `right`: `Expression` (required)
+ - `body`: `Statement` (required)
+ - `await`: `boolean` (default: `false`)
+
+---
+
+### forStatement
+```javascript
+t.forStatement(init, test, update, body)
+```
+
+See also `t.isForStatement(node, opts)` and `t.assertForStatement(node, opts)`.
+
+Aliases: `Scopable`, `Statement`, `For`, `BlockParent`, `Loop`
+
+ - `init`: `VariableDeclaration | Expression` (default: `null`)
+ - `test`: `Expression` (default: `null`)
+ - `update`: `Expression` (default: `null`)
+ - `body`: `Statement` (required)
+
+---
+
+### functionDeclaration
+```javascript
+t.functionDeclaration(id, params, body, generator, async)
+```
+
+See also `t.isFunctionDeclaration(node, opts)` and `t.assertFunctionDeclaration(node, opts)`.
+
+Aliases: `Scopable`, `Function`, `BlockParent`, `FunctionParent`, `Statement`, `Pureish`, `Declaration`
+
+ - `id`: `Identifier` (default: `null`)
+ - `params`: `Array<LVal>` (required)
+ - `body`: `BlockStatement` (required)
+ - `generator`: `boolean` (default: `false`)
+ - `async`: `boolean` (default: `false`)
+ - `declare`: `boolean` (default: `null`)
+ - `returnType`: `TypeAnnotation | TSTypeAnnotation | Noop` (default: `null`)
+ - `typeParameters`: `TypeParameterDeclaration | TSTypeParameterDeclaration | Noop` (default: `null`)
+
+---
+
+### functionExpression
+```javascript
+t.functionExpression(id, params, body, generator, async)
+```
+
+See also `t.isFunctionExpression(node, opts)` and `t.assertFunctionExpression(node, opts)`.
+
+Aliases: `Scopable`, `Function`, `BlockParent`, `FunctionParent`, `Expression`, `Pureish`
+
+ - `id`: `Identifier` (default: `null`)
+ - `params`: `Array<LVal>` (required)
+ - `body`: `BlockStatement` (required)
+ - `generator`: `boolean` (default: `false`)
+ - `async`: `boolean` (default: `false`)
+ - `returnType`: `TypeAnnotation | TSTypeAnnotation | Noop` (default: `null`)
+ - `typeParameters`: `TypeParameterDeclaration | TSTypeParameterDeclaration | Noop` (default: `null`)
+
+---
+
+### functionTypeAnnotation
+```javascript
+t.functionTypeAnnotation(typeParameters, params, rest, returnType)
+```
+
+See also `t.isFunctionTypeAnnotation(node, opts)` and `t.assertFunctionTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowType`
+
+ - `typeParameters`: `TypeParameterDeclaration` (default: `null`)
+ - `params`: `Array<FunctionTypeParam>` (required)
+ - `rest`: `FunctionTypeParam` (default: `null`)
+ - `returnType`: `FlowType` (required)
+
+---
+
+### functionTypeParam
+```javascript
+t.functionTypeParam(name, typeAnnotation)
+```
+
+See also `t.isFunctionTypeParam(node, opts)` and `t.assertFunctionTypeParam(node, opts)`.
+
+Aliases: `Flow`
+
+ - `name`: `Identifier` (default: `null`)
+ - `typeAnnotation`: `FlowType` (required)
+ - `optional`: `boolean` (default: `null`)
+
+---
+
+### genericTypeAnnotation
+```javascript
+t.genericTypeAnnotation(id, typeParameters)
+```
+
+See also `t.isGenericTypeAnnotation(node, opts)` and `t.assertGenericTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowType`
+
+ - `id`: `Identifier` (required)
+ - `typeParameters`: `TypeParameterInstantiation` (default: `null`)
+
+---
+
+### identifier
+```javascript
+t.identifier(name)
+```
+
+See also `t.isIdentifier(node, opts)` and `t.assertIdentifier(node, opts)`.
+
+Aliases: `Expression`, `PatternLike`, `LVal`, `TSEntityName`
+
+ - `name`: `string` (required)
+ - `decorators`: `Array<Decorator>` (default: `null`)
+ - `optional`: `boolean` (default: `null`)
+ - `typeAnnotation`: `TypeAnnotation | TSTypeAnnotation | Noop` (default: `null`)
+
+---
+
+### ifStatement
+```javascript
+t.ifStatement(test, consequent, alternate)
+```
+
+See also `t.isIfStatement(node, opts)` and `t.assertIfStatement(node, opts)`.
+
+Aliases: `Statement`, `Conditional`
+
+ - `test`: `Expression` (required)
+ - `consequent`: `Statement` (required)
+ - `alternate`: `Statement` (default: `null`)
+
+---
+
+### import
+```javascript
+t.import()
+```
+
+See also `t.isImport(node, opts)` and `t.assertImport(node, opts)`.
+
+Aliases: `Expression`
+
+
+---
+
+### importDeclaration
+```javascript
+t.importDeclaration(specifiers, source)
+```
+
+See also `t.isImportDeclaration(node, opts)` and `t.assertImportDeclaration(node, opts)`.
+
+Aliases: `Statement`, `Declaration`, `ModuleDeclaration`
+
+ - `specifiers`: `Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>` (required)
+ - `source`: `StringLiteral` (required)
+
+---
+
+### importDefaultSpecifier
+```javascript
+t.importDefaultSpecifier(local)
+```
+
+See also `t.isImportDefaultSpecifier(node, opts)` and `t.assertImportDefaultSpecifier(node, opts)`.
+
+Aliases: `ModuleSpecifier`
+
+ - `local`: `Identifier` (required)
+
+---
+
+### importNamespaceSpecifier
+```javascript
+t.importNamespaceSpecifier(local)
+```
+
+See also `t.isImportNamespaceSpecifier(node, opts)` and `t.assertImportNamespaceSpecifier(node, opts)`.
+
+Aliases: `ModuleSpecifier`
+
+ - `local`: `Identifier` (required)
+
+---
+
+### importSpecifier
+```javascript
+t.importSpecifier(local, imported)
+```
+
+See also `t.isImportSpecifier(node, opts)` and `t.assertImportSpecifier(node, opts)`.
+
+Aliases: `ModuleSpecifier`
+
+ - `local`: `Identifier` (required)
+ - `imported`: `Identifier` (required)
+ - `importKind`: `null | "type" | "typeof"` (default: `null`)
+
+---
+
+### inferredPredicate
+```javascript
+t.inferredPredicate()
+```
+
+See also `t.isInferredPredicate(node, opts)` and `t.assertInferredPredicate(node, opts)`.
+
+Aliases: `Flow`, `FlowPredicate`
+
+
+---
+
+### interfaceDeclaration
+```javascript
+t.interfaceDeclaration(id, typeParameters, extends, body)
+```
+
+See also `t.isInterfaceDeclaration(node, opts)` and `t.assertInterfaceDeclaration(node, opts)`.
+
+Aliases: `Flow`, `FlowDeclaration`, `Statement`, `Declaration`
+
+ - `id`: `Identifier` (required)
+ - `typeParameters`: `TypeParameterDeclaration` (default: `null`)
+ - `extends`: `Array<InterfaceExtends>` (default: `null`)
+ - `body`: `ObjectTypeAnnotation` (required)
+ - `implements`: `Array<ClassImplements>` (default: `null`)
+ - `mixins`: `Array<InterfaceExtends>` (default: `null`)
+
+---
+
+### interfaceExtends
+```javascript
+t.interfaceExtends(id, typeParameters)
+```
+
+See also `t.isInterfaceExtends(node, opts)` and `t.assertInterfaceExtends(node, opts)`.
+
+Aliases: `Flow`
+
+ - `id`: `Identifier` (required)
+ - `typeParameters`: `TypeParameterInstantiation` (default: `null`)
+
+---
+
+### intersectionTypeAnnotation
+```javascript
+t.intersectionTypeAnnotation(types)
+```
+
+See also `t.isIntersectionTypeAnnotation(node, opts)` and `t.assertIntersectionTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowType`
+
+ - `types`: `Array<FlowType>` (required)
+
+---
+
+### jSXAttribute
+```javascript
+t.jsxAttribute(name, value)
+```
+
+See also `t.isJSXAttribute(node, opts)` and `t.assertJSXAttribute(node, opts)`.
+
+Aliases: `JSX`, `Immutable`
+
+ - `name`: `JSXIdentifier | JSXNamespacedName` (required)
+ - `value`: `JSXElement | JSXFragment | StringLiteral | JSXExpressionContainer` (default: `null`)
+
+---
+
+### jSXClosingElement
+```javascript
+t.jsxClosingElement(name)
+```
+
+See also `t.isJSXClosingElement(node, opts)` and `t.assertJSXClosingElement(node, opts)`.
+
+Aliases: `JSX`, `Immutable`
+
+ - `name`: `JSXIdentifier | JSXMemberExpression` (required)
+
+---
+
+### jSXClosingFragment
+```javascript
+t.jsxClosingFragment()
+```
+
+See also `t.isJSXClosingFragment(node, opts)` and `t.assertJSXClosingFragment(node, opts)`.
+
+Aliases: `JSX`, `Immutable`
+
+
+---
+
+### jSXElement
+```javascript
+t.jsxElement(openingElement, closingElement, children, selfClosing)
+```
+
+See also `t.isJSXElement(node, opts)` and `t.assertJSXElement(node, opts)`.
+
+Aliases: `JSX`, `Immutable`, `Expression`
+
+ - `openingElement`: `JSXOpeningElement` (required)
+ - `closingElement`: `JSXClosingElement` (default: `null`)
+ - `children`: `Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment>` (required)
+ - `selfClosing` (required)
+
+---
+
+### jSXEmptyExpression
+```javascript
+t.jsxEmptyExpression()
+```
+
+See also `t.isJSXEmptyExpression(node, opts)` and `t.assertJSXEmptyExpression(node, opts)`.
+
+Aliases: `JSX`
+
+
+---
+
+### jSXExpressionContainer
+```javascript
+t.jsxExpressionContainer(expression)
+```
+
+See also `t.isJSXExpressionContainer(node, opts)` and `t.assertJSXExpressionContainer(node, opts)`.
+
+Aliases: `JSX`, `Immutable`
+
+ - `expression`: `Expression` (required)
+
+---
+
+### jSXFragment
+```javascript
+t.jsxFragment(openingFragment, closingFragment, children)
+```
+
+See also `t.isJSXFragment(node, opts)` and `t.assertJSXFragment(node, opts)`.
+
+Aliases: `JSX`, `Immutable`, `Expression`
+
+ - `openingFragment`: `JSXOpeningFragment` (required)
+ - `closingFragment`: `JSXClosingFragment` (required)
+ - `children`: `Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment>` (required)
+
+---
+
+### jSXIdentifier
+```javascript
+t.jsxIdentifier(name)
+```
+
+See also `t.isJSXIdentifier(node, opts)` and `t.assertJSXIdentifier(node, opts)`.
+
+Aliases: `JSX`
+
+ - `name`: `string` (required)
+
+---
+
+### jSXMemberExpression
+```javascript
+t.jsxMemberExpression(object, property)
+```
+
+See also `t.isJSXMemberExpression(node, opts)` and `t.assertJSXMemberExpression(node, opts)`.
+
+Aliases: `JSX`
+
+ - `object`: `JSXMemberExpression | JSXIdentifier` (required)
+ - `property`: `JSXIdentifier` (required)
+
+---
+
+### jSXNamespacedName
+```javascript
+t.jsxNamespacedName(namespace, name)
+```
+
+See also `t.isJSXNamespacedName(node, opts)` and `t.assertJSXNamespacedName(node, opts)`.
+
+Aliases: `JSX`
+
+ - `namespace`: `JSXIdentifier` (required)
+ - `name`: `JSXIdentifier` (required)
+
+---
+
+### jSXOpeningElement
+```javascript
+t.jsxOpeningElement(name, attributes, selfClosing)
+```
+
+See also `t.isJSXOpeningElement(node, opts)` and `t.assertJSXOpeningElement(node, opts)`.
+
+Aliases: `JSX`, `Immutable`
+
+ - `name`: `JSXIdentifier | JSXMemberExpression` (required)
+ - `attributes`: `Array<JSXAttribute | JSXSpreadAttribute>` (required)
+ - `selfClosing`: `boolean` (default: `false`)
+
+---
+
+### jSXOpeningFragment
+```javascript
+t.jsxOpeningFragment()
+```
+
+See also `t.isJSXOpeningFragment(node, opts)` and `t.assertJSXOpeningFragment(node, opts)`.
+
+Aliases: `JSX`, `Immutable`
+
+
+---
+
+### jSXSpreadAttribute
+```javascript
+t.jsxSpreadAttribute(argument)
+```
+
+See also `t.isJSXSpreadAttribute(node, opts)` and `t.assertJSXSpreadAttribute(node, opts)`.
+
+Aliases: `JSX`
+
+ - `argument`: `Expression` (required)
+
+---
+
+### jSXSpreadChild
+```javascript
+t.jsxSpreadChild(expression)
+```
+
+See also `t.isJSXSpreadChild(node, opts)` and `t.assertJSXSpreadChild(node, opts)`.
+
+Aliases: `JSX`, `Immutable`
+
+ - `expression`: `Expression` (required)
+
+---
+
+### jSXText
+```javascript
+t.jsxText(value)
+```
+
+See also `t.isJSXText(node, opts)` and `t.assertJSXText(node, opts)`.
+
+Aliases: `JSX`, `Immutable`
+
+ - `value`: `string` (required)
+
+---
+
+### labeledStatement
+```javascript
+t.labeledStatement(label, body)
+```
+
+See also `t.isLabeledStatement(node, opts)` and `t.assertLabeledStatement(node, opts)`.
+
+Aliases: `Statement`
+
+ - `label`: `Identifier` (required)
+ - `body`: `Statement` (required)
+
+---
+
+### logicalExpression
+```javascript
+t.logicalExpression(operator, left, right)
+```
+
+See also `t.isLogicalExpression(node, opts)` and `t.assertLogicalExpression(node, opts)`.
+
+Aliases: `Binary`, `Expression`
+
+ - `operator`: `"||" | "&&" | "??"` (required)
+ - `left`: `Expression` (required)
+ - `right`: `Expression` (required)
+
+---
+
+### memberExpression
+```javascript
+t.memberExpression(object, property, computed, optional)
+```
+
+See also `t.isMemberExpression(node, opts)` and `t.assertMemberExpression(node, opts)`.
+
+Aliases: `Expression`, `LVal`
+
+ - `object`: `Expression` (required)
+ - `property`: if computed then `Expression` else `Identifier` (required)
+ - `computed`: `boolean` (default: `false`)
+ - `optional`: `true | false` (default: `null`)
+
+---
+
+### metaProperty
+```javascript
+t.metaProperty(meta, property)
+```
+
+See also `t.isMetaProperty(node, opts)` and `t.assertMetaProperty(node, opts)`.
+
+Aliases: `Expression`
+
+ - `meta`: `Identifier` (required)
+ - `property`: `Identifier` (required)
+
+---
+
+### mixedTypeAnnotation
+```javascript
+t.mixedTypeAnnotation()
+```
+
+See also `t.isMixedTypeAnnotation(node, opts)` and `t.assertMixedTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowType`, `FlowBaseAnnotation`
+
+
+---
+
+### newExpression
+```javascript
+t.newExpression(callee, arguments)
+```
+
+See also `t.isNewExpression(node, opts)` and `t.assertNewExpression(node, opts)`.
+
+Aliases: `Expression`
+
+ - `callee`: `Expression` (required)
+ - `arguments`: `Array<Expression | SpreadElement | JSXNamespacedName>` (required)
+ - `optional`: `true | false` (default: `null`)
+ - `typeParameters`: `TypeParameterInstantiation | TSTypeParameterInstantiation` (default: `null`)
+
+---
+
+### noop
+```javascript
+t.noop()
+```
+
+See also `t.isNoop(node, opts)` and `t.assertNoop(node, opts)`.
+
+
+---
+
+### nullLiteral
+```javascript
+t.nullLiteral()
+```
+
+See also `t.isNullLiteral(node, opts)` and `t.assertNullLiteral(node, opts)`.
+
+Aliases: `Expression`, `Pureish`, `Literal`, `Immutable`
+
+
+---
+
+### nullLiteralTypeAnnotation
+```javascript
+t.nullLiteralTypeAnnotation()
+```
+
+See also `t.isNullLiteralTypeAnnotation(node, opts)` and `t.assertNullLiteralTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowType`, `FlowBaseAnnotation`
+
+
+---
+
+### nullableTypeAnnotation
+```javascript
+t.nullableTypeAnnotation(typeAnnotation)
+```
+
+See also `t.isNullableTypeAnnotation(node, opts)` and `t.assertNullableTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowType`
+
+ - `typeAnnotation`: `FlowType` (required)
+
+---
+
+### numberLiteralTypeAnnotation
+```javascript
+t.numberLiteralTypeAnnotation(value)
+```
+
+See also `t.isNumberLiteralTypeAnnotation(node, opts)` and `t.assertNumberLiteralTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowType`
+
+ - `value`: `number` (required)
+
+---
+
+### numberTypeAnnotation
+```javascript
+t.numberTypeAnnotation()
+```
+
+See also `t.isNumberTypeAnnotation(node, opts)` and `t.assertNumberTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowType`, `FlowBaseAnnotation`
+
+
+---
+
+### numericLiteral
+```javascript
+t.numericLiteral(value)
+```
+
+See also `t.isNumericLiteral(node, opts)` and `t.assertNumericLiteral(node, opts)`.
+
+Aliases: `Expression`, `Pureish`, `Literal`, `Immutable`
+
+ - `value`: `number` (required)
+
+---
+
+### objectExpression
+```javascript
+t.objectExpression(properties)
+```
+
+See also `t.isObjectExpression(node, opts)` and `t.assertObjectExpression(node, opts)`.
+
+Aliases: `Expression`
+
+ - `properties`: `Array<ObjectMethod | ObjectProperty | SpreadElement>` (required)
+
+---
+
+### objectMethod
+```javascript
+t.objectMethod(kind, key, params, body, computed)
+```
+
+See also `t.isObjectMethod(node, opts)` and `t.assertObjectMethod(node, opts)`.
+
+Aliases: `UserWhitespacable`, `Function`, `Scopable`, `BlockParent`, `FunctionParent`, `Method`, `ObjectMember`
+
+ - `kind`: `"method" | "get" | "set"` (default: `'method'`)
+ - `key`: if computed then `Expression` else `Identifier | Literal` (required)
+ - `params`: `Array<LVal>` (required)
+ - `body`: `BlockStatement` (required)
+ - `computed`: `boolean` (default: `false`)
+ - `async`: `boolean` (default: `false`)
+ - `decorators`: `Array<Decorator>` (default: `null`)
+ - `generator`: `boolean` (default: `false`)
+ - `returnType`: `TypeAnnotation | TSTypeAnnotation | Noop` (default: `null`)
+ - `typeParameters`: `TypeParameterDeclaration | TSTypeParameterDeclaration | Noop` (default: `null`)
+
+---
+
+### objectPattern
+```javascript
+t.objectPattern(properties)
+```
+
+See also `t.isObjectPattern(node, opts)` and `t.assertObjectPattern(node, opts)`.
+
+Aliases: `Pattern`, `PatternLike`, `LVal`
+
+ - `properties`: `Array<RestElement | ObjectProperty>` (required)
+ - `decorators`: `Array<Decorator>` (default: `null`)
+ - `typeAnnotation`: `TypeAnnotation | TSTypeAnnotation | Noop` (default: `null`)
+
+---
+
+### objectProperty
+```javascript
+t.objectProperty(key, value, computed, shorthand, decorators)
+```
+
+See also `t.isObjectProperty(node, opts)` and `t.assertObjectProperty(node, opts)`.
+
+Aliases: `UserWhitespacable`, `Property`, `ObjectMember`
+
+ - `key`: if computed then `Expression` else `Identifier | Literal` (required)
+ - `value`: `Expression | PatternLike` (required)
+ - `computed`: `boolean` (default: `false`)
+ - `shorthand`: `boolean` (default: `false`)
+ - `decorators`: `Array<Decorator>` (default: `null`)
+
+---
+
+### objectTypeAnnotation
+```javascript
+t.objectTypeAnnotation(properties, indexers, callProperties, exact)
+```
+
+See also `t.isObjectTypeAnnotation(node, opts)` and `t.assertObjectTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowType`
+
+ - `properties`: `Array<ObjectTypeProperty | ObjectTypeSpreadProperty>` (required)
+ - `indexers`: `Array<ObjectTypeIndexer>` (default: `null`)
+ - `callProperties`: `Array<ObjectTypeCallProperty>` (default: `null`)
+ - `exact`: `boolean` (default: `false`)
+
+---
+
+### objectTypeCallProperty
+```javascript
+t.objectTypeCallProperty(value)
+```
+
+See also `t.isObjectTypeCallProperty(node, opts)` and `t.assertObjectTypeCallProperty(node, opts)`.
+
+Aliases: `Flow`, `UserWhitespacable`
+
+ - `value`: `FlowType` (required)
+ - `static`: `boolean` (default: `null`)
+
+---
+
+### objectTypeIndexer
+```javascript
+t.objectTypeIndexer(id, key, value, variance)
+```
+
+See also `t.isObjectTypeIndexer(node, opts)` and `t.assertObjectTypeIndexer(node, opts)`.
+
+Aliases: `Flow`, `UserWhitespacable`
+
+ - `id`: `Identifier` (default: `null`)
+ - `key`: `FlowType` (required)
+ - `value`: `FlowType` (required)
+ - `variance`: `Variance` (default: `null`)
+ - `static`: `boolean` (default: `null`)
+
+---
+
+### objectTypeProperty
+```javascript
+t.objectTypeProperty(key, value, variance)
+```
+
+See also `t.isObjectTypeProperty(node, opts)` and `t.assertObjectTypeProperty(node, opts)`.
+
+Aliases: `Flow`, `UserWhitespacable`
+
+ - `key`: `Identifier | StringLiteral` (required)
+ - `value`: `FlowType` (required)
+ - `variance`: `Variance` (default: `null`)
+ - `kind`: `"init" | "get" | "set"` (default: `null`)
+ - `optional`: `boolean` (default: `null`)
+ - `static`: `boolean` (default: `null`)
+
+---
+
+### objectTypeSpreadProperty
+```javascript
+t.objectTypeSpreadProperty(argument)
+```
+
+See also `t.isObjectTypeSpreadProperty(node, opts)` and `t.assertObjectTypeSpreadProperty(node, opts)`.
+
+Aliases: `Flow`, `UserWhitespacable`
+
+ - `argument`: `FlowType` (required)
+
+---
+
+### opaqueType
+```javascript
+t.opaqueType(id, typeParameters, supertype, impltype)
+```
+
+See also `t.isOpaqueType(node, opts)` and `t.assertOpaqueType(node, opts)`.
+
+Aliases: `Flow`, `FlowDeclaration`, `Statement`, `Declaration`
+
+ - `id`: `Identifier` (required)
+ - `typeParameters`: `TypeParameterDeclaration` (default: `null`)
+ - `supertype`: `FlowType` (default: `null`)
+ - `impltype`: `FlowType` (required)
+
+---
+
+### optionalCallExpression
+```javascript
+t.optionalCallExpression(callee, arguments, optional)
+```
+
+See also `t.isOptionalCallExpression(node, opts)` and `t.assertOptionalCallExpression(node, opts)`.
+
+Aliases: `Expression`
+
+ - `callee`: `Expression` (required)
+ - `arguments`: `Array<Expression | SpreadElement | JSXNamespacedName>` (required)
+ - `optional`: `boolean` (required)
+ - `typeParameters`: `TypeParameterInstantiation | TSTypeParameterInstantiation` (default: `null`)
+
+---
+
+### optionalMemberExpression
+```javascript
+t.optionalMemberExpression(object, property, computed, optional)
+```
+
+See also `t.isOptionalMemberExpression(node, opts)` and `t.assertOptionalMemberExpression(node, opts)`.
+
+Aliases: `Expression`
+
+ - `object`: `Expression` (required)
+ - `property`: `any` (required)
+ - `computed`: `boolean` (default: `false`)
+ - `optional`: `boolean` (required)
+
+---
+
+### parenthesizedExpression
+```javascript
+t.parenthesizedExpression(expression)
+```
+
+See also `t.isParenthesizedExpression(node, opts)` and `t.assertParenthesizedExpression(node, opts)`.
+
+Aliases: `Expression`, `ExpressionWrapper`
+
+ - `expression`: `Expression` (required)
+
+---
+
+### privateName
+```javascript
+t.privateName(id)
+```
+
+See also `t.isPrivateName(node, opts)` and `t.assertPrivateName(node, opts)`.
+
+Aliases: `Private`
+
+ - `id`: `Identifier` (required)
+
+---
+
+### program
+```javascript
+t.program(body, directives, sourceType)
+```
+
+See also `t.isProgram(node, opts)` and `t.assertProgram(node, opts)`.
+
+Aliases: `Scopable`, `BlockParent`, `Block`
+
+ - `body`: `Array<Statement>` (required)
+ - `directives`: `Array<Directive>` (default: `[]`)
+ - `sourceType`: `"script" | "module"` (default: `'script'`)
+ - `sourceFile`: `string` (default: `null`)
+
+---
+
+### qualifiedTypeIdentifier
+```javascript
+t.qualifiedTypeIdentifier(id, qualification)
+```
+
+See also `t.isQualifiedTypeIdentifier(node, opts)` and `t.assertQualifiedTypeIdentifier(node, opts)`.
+
+Aliases: `Flow`
+
+ - `id`: `Identifier` (required)
+ - `qualification`: `Identifier | QualifiedTypeIdentifier` (required)
+
+---
+
+### regExpLiteral
+```javascript
+t.regExpLiteral(pattern, flags)
+```
+
+See also `t.isRegExpLiteral(node, opts)` and `t.assertRegExpLiteral(node, opts)`.
+
+Aliases: `Expression`, `Literal`
+
+ - `pattern`: `string` (required)
+ - `flags`: `string` (default: `''`)
+
+---
+
+### restElement
+```javascript
+t.restElement(argument)
+```
+
+See also `t.isRestElement(node, opts)` and `t.assertRestElement(node, opts)`.
+
+Aliases: `LVal`, `PatternLike`
+
+ - `argument`: `LVal` (required)
+ - `decorators`: `Array<Decorator>` (default: `null`)
+ - `typeAnnotation`: `TypeAnnotation | TSTypeAnnotation | Noop` (default: `null`)
+
+---
+
+### returnStatement
+```javascript
+t.returnStatement(argument)
+```
+
+See also `t.isReturnStatement(node, opts)` and `t.assertReturnStatement(node, opts)`.
+
+Aliases: `Statement`, `Terminatorless`, `CompletionStatement`
+
+ - `argument`: `Expression` (default: `null`)
+
+---
+
+### sequenceExpression
+```javascript
+t.sequenceExpression(expressions)
+```
+
+See also `t.isSequenceExpression(node, opts)` and `t.assertSequenceExpression(node, opts)`.
+
+Aliases: `Expression`
+
+ - `expressions`: `Array<Expression>` (required)
+
+---
+
+### spreadElement
+```javascript
+t.spreadElement(argument)
+```
+
+See also `t.isSpreadElement(node, opts)` and `t.assertSpreadElement(node, opts)`.
+
+Aliases: `UnaryLike`
+
+ - `argument`: `Expression` (required)
+
+---
+
+### stringLiteral
+```javascript
+t.stringLiteral(value)
+```
+
+See also `t.isStringLiteral(node, opts)` and `t.assertStringLiteral(node, opts)`.
+
+Aliases: `Expression`, `Pureish`, `Literal`, `Immutable`
+
+ - `value`: `string` (required)
+
+---
+
+### stringLiteralTypeAnnotation
+```javascript
+t.stringLiteralTypeAnnotation(value)
+```
+
+See also `t.isStringLiteralTypeAnnotation(node, opts)` and `t.assertStringLiteralTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowType`
+
+ - `value`: `string` (required)
+
+---
+
+### stringTypeAnnotation
+```javascript
+t.stringTypeAnnotation()
+```
+
+See also `t.isStringTypeAnnotation(node, opts)` and `t.assertStringTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowType`, `FlowBaseAnnotation`
+
+
+---
+
+### super
+```javascript
+t.super()
+```
+
+See also `t.isSuper(node, opts)` and `t.assertSuper(node, opts)`.
+
+Aliases: `Expression`
+
+
+---
+
+### switchCase
+```javascript
+t.switchCase(test, consequent)
+```
+
+See also `t.isSwitchCase(node, opts)` and `t.assertSwitchCase(node, opts)`.
+
+ - `test`: `Expression` (default: `null`)
+ - `consequent`: `Array<Statement>` (required)
+
+---
+
+### switchStatement
+```javascript
+t.switchStatement(discriminant, cases)
+```
+
+See also `t.isSwitchStatement(node, opts)` and `t.assertSwitchStatement(node, opts)`.
+
+Aliases: `Statement`, `BlockParent`, `Scopable`
+
+ - `discriminant`: `Expression` (required)
+ - `cases`: `Array<SwitchCase>` (required)
+
+---
+
+### tSAnyKeyword
+```javascript
+t.tsAnyKeyword()
+```
+
+See also `t.isTSAnyKeyword(node, opts)` and `t.assertTSAnyKeyword(node, opts)`.
+
+Aliases: `TSType`
+
+
+---
+
+### tSArrayType
+```javascript
+t.tsArrayType(elementType)
+```
+
+See also `t.isTSArrayType(node, opts)` and `t.assertTSArrayType(node, opts)`.
+
+Aliases: `TSType`
+
+ - `elementType`: `TSType` (required)
+
+---
+
+### tSAsExpression
+```javascript
+t.tsAsExpression(expression, typeAnnotation)
+```
+
+See also `t.isTSAsExpression(node, opts)` and `t.assertTSAsExpression(node, opts)`.
+
+Aliases: `Expression`
+
+ - `expression`: `Expression` (required)
+ - `typeAnnotation`: `TSType` (required)
+
+---
+
+### tSBooleanKeyword
+```javascript
+t.tsBooleanKeyword()
+```
+
+See also `t.isTSBooleanKeyword(node, opts)` and `t.assertTSBooleanKeyword(node, opts)`.
+
+Aliases: `TSType`
+
+
+---
+
+### tSCallSignatureDeclaration
+```javascript
+t.tsCallSignatureDeclaration(typeParameters, parameters, typeAnnotation)
+```
+
+See also `t.isTSCallSignatureDeclaration(node, opts)` and `t.assertTSCallSignatureDeclaration(node, opts)`.
+
+Aliases: `TSTypeElement`
+
+ - `typeParameters`: `TSTypeParameterDeclaration` (default: `null`)
+ - `parameters`: `Array<Identifier | RestElement>` (default: `null`)
+ - `typeAnnotation`: `TSTypeAnnotation` (default: `null`)
+
+---
+
+### tSConditionalType
+```javascript
+t.tsConditionalType(checkType, extendsType, trueType, falseType)
+```
+
+See also `t.isTSConditionalType(node, opts)` and `t.assertTSConditionalType(node, opts)`.
+
+Aliases: `TSType`
+
+ - `checkType`: `TSType` (required)
+ - `extendsType`: `TSType` (required)
+ - `trueType`: `TSType` (required)
+ - `falseType`: `TSType` (required)
+
+---
+
+### tSConstructSignatureDeclaration
+```javascript
+t.tsConstructSignatureDeclaration(typeParameters, parameters, typeAnnotation)
+```
+
+See also `t.isTSConstructSignatureDeclaration(node, opts)` and `t.assertTSConstructSignatureDeclaration(node, opts)`.
+
+Aliases: `TSTypeElement`
+
+ - `typeParameters`: `TSTypeParameterDeclaration` (default: `null`)
+ - `parameters`: `Array<Identifier | RestElement>` (default: `null`)
+ - `typeAnnotation`: `TSTypeAnnotation` (default: `null`)
+
+---
+
+### tSConstructorType
+```javascript
+t.tsConstructorType(typeParameters, typeAnnotation)
+```
+
+See also `t.isTSConstructorType(node, opts)` and `t.assertTSConstructorType(node, opts)`.
+
+Aliases: `TSType`
+
+ - `typeParameters`: `TSTypeParameterDeclaration` (default: `null`)
+ - `typeAnnotation`: `TSTypeAnnotation` (default: `null`)
+ - `parameters`: `Array<Identifier | RestElement>` (default: `null`)
+
+---
+
+### tSDeclareFunction
+```javascript
+t.tsDeclareFunction(id, typeParameters, params, returnType)
+```
+
+See also `t.isTSDeclareFunction(node, opts)` and `t.assertTSDeclareFunction(node, opts)`.
+
+Aliases: `Statement`, `Declaration`
+
+ - `id`: `Identifier` (default: `null`)
+ - `typeParameters`: `TSTypeParameterDeclaration | Noop` (default: `null`)
+ - `params`: `Array<LVal>` (required)
+ - `returnType`: `TSTypeAnnotation | Noop` (default: `null`)
+ - `async`: `boolean` (default: `false`)
+ - `declare`: `boolean` (default: `null`)
+ - `generator`: `boolean` (default: `false`)
+
+---
+
+### tSDeclareMethod
+```javascript
+t.tsDeclareMethod(decorators, key, typeParameters, params, returnType)
+```
+
+See also `t.isTSDeclareMethod(node, opts)` and `t.assertTSDeclareMethod(node, opts)`.
+
+ - `decorators`: `Array<Decorator>` (default: `null`)
+ - `key`: `Identifier | StringLiteral | NumericLiteral | Expression` (required)
+ - `typeParameters`: `TSTypeParameterDeclaration | Noop` (default: `null`)
+ - `params`: `Array<LVal>` (required)
+ - `returnType`: `TSTypeAnnotation | Noop` (default: `null`)
+ - `abstract`: `boolean` (default: `null`)
+ - `access`: `"public" | "private" | "protected"` (default: `null`)
+ - `accessibility`: `"public" | "private" | "protected"` (default: `null`)
+ - `async`: `boolean` (default: `false`)
+ - `computed`: `boolean` (default: `false`)
+ - `generator`: `boolean` (default: `false`)
+ - `kind`: `"get" | "set" | "method" | "constructor"` (default: `'method'`)
+ - `optional`: `boolean` (default: `null`)
+ - `static`: `boolean` (default: `null`)
+
+---
+
+### tSEnumDeclaration
+```javascript
+t.tsEnumDeclaration(id, members)
+```
+
+See also `t.isTSEnumDeclaration(node, opts)` and `t.assertTSEnumDeclaration(node, opts)`.
+
+Aliases: `Statement`, `Declaration`
+
+ - `id`: `Identifier` (required)
+ - `members`: `Array<TSEnumMember>` (required)
+ - `const`: `boolean` (default: `null`)
+ - `declare`: `boolean` (default: `null`)
+ - `initializer`: `Expression` (default: `null`)
+
+---
+
+### tSEnumMember
+```javascript
+t.tsEnumMember(id, initializer)
+```
+
+See also `t.isTSEnumMember(node, opts)` and `t.assertTSEnumMember(node, opts)`.
+
+ - `id`: `Identifier | StringLiteral` (required)
+ - `initializer`: `Expression` (default: `null`)
+
+---
+
+### tSExportAssignment
+```javascript
+t.tsExportAssignment(expression)
+```
+
+See also `t.isTSExportAssignment(node, opts)` and `t.assertTSExportAssignment(node, opts)`.
+
+Aliases: `Statement`
+
+ - `expression`: `Expression` (required)
+
+---
+
+### tSExpressionWithTypeArguments
+```javascript
+t.tsExpressionWithTypeArguments(expression, typeParameters)
+```
+
+See also `t.isTSExpressionWithTypeArguments(node, opts)` and `t.assertTSExpressionWithTypeArguments(node, opts)`.
+
+Aliases: `TSType`
+
+ - `expression`: `TSEntityName` (required)
+ - `typeParameters`: `TSTypeParameterInstantiation` (default: `null`)
+
+---
+
+### tSExternalModuleReference
+```javascript
+t.tsExternalModuleReference(expression)
+```
+
+See also `t.isTSExternalModuleReference(node, opts)` and `t.assertTSExternalModuleReference(node, opts)`.
+
+ - `expression`: `StringLiteral` (required)
+
+---
+
+### tSFunctionType
+```javascript
+t.tsFunctionType(typeParameters, typeAnnotation)
+```
+
+See also `t.isTSFunctionType(node, opts)` and `t.assertTSFunctionType(node, opts)`.
+
+Aliases: `TSType`
+
+ - `typeParameters`: `TSTypeParameterDeclaration` (default: `null`)
+ - `typeAnnotation`: `TSTypeAnnotation` (default: `null`)
+ - `parameters`: `Array<Identifier | RestElement>` (default: `null`)
+
+---
+
+### tSImportEqualsDeclaration
+```javascript
+t.tsImportEqualsDeclaration(id, moduleReference)
+```
+
+See also `t.isTSImportEqualsDeclaration(node, opts)` and `t.assertTSImportEqualsDeclaration(node, opts)`.
+
+Aliases: `Statement`
+
+ - `id`: `Identifier` (required)
+ - `moduleReference`: `TSEntityName | TSExternalModuleReference` (required)
+ - `isExport`: `boolean` (default: `null`)
+
+---
+
+### tSIndexSignature
+```javascript
+t.tsIndexSignature(parameters, typeAnnotation)
+```
+
+See also `t.isTSIndexSignature(node, opts)` and `t.assertTSIndexSignature(node, opts)`.
+
+Aliases: `TSTypeElement`
+
+ - `parameters`: `Array<Identifier>` (required)
+ - `typeAnnotation`: `TSTypeAnnotation` (default: `null`)
+ - `readonly`: `boolean` (default: `null`)
+
+---
+
+### tSIndexedAccessType
+```javascript
+t.tsIndexedAccessType(objectType, indexType)
+```
+
+See also `t.isTSIndexedAccessType(node, opts)` and `t.assertTSIndexedAccessType(node, opts)`.
+
+Aliases: `TSType`
+
+ - `objectType`: `TSType` (required)
+ - `indexType`: `TSType` (required)
+
+---
+
+### tSInferType
+```javascript
+t.tsInferType(typeParameter)
+```
+
+See also `t.isTSInferType(node, opts)` and `t.assertTSInferType(node, opts)`.
+
+Aliases: `TSType`
+
+ - `typeParameter`: `TSType` (required)
+
+---
+
+### tSInterfaceBody
+```javascript
+t.tsInterfaceBody(body)
+```
+
+See also `t.isTSInterfaceBody(node, opts)` and `t.assertTSInterfaceBody(node, opts)`.
+
+ - `body`: `Array<TSTypeElement>` (required)
+
+---
+
+### tSInterfaceDeclaration
+```javascript
+t.tsInterfaceDeclaration(id, typeParameters, extends, body)
+```
+
+See also `t.isTSInterfaceDeclaration(node, opts)` and `t.assertTSInterfaceDeclaration(node, opts)`.
+
+Aliases: `Statement`, `Declaration`
+
+ - `id`: `Identifier` (required)
+ - `typeParameters`: `TSTypeParameterDeclaration` (default: `null`)
+ - `extends`: `Array<TSExpressionWithTypeArguments>` (default: `null`)
+ - `body`: `TSInterfaceBody` (required)
+ - `declare`: `boolean` (default: `null`)
+
+---
+
+### tSIntersectionType
+```javascript
+t.tsIntersectionType(types)
+```
+
+See also `t.isTSIntersectionType(node, opts)` and `t.assertTSIntersectionType(node, opts)`.
+
+Aliases: `TSType`
+
+ - `types`: `Array<TSType>` (required)
+
+---
+
+### tSLiteralType
+```javascript
+t.tsLiteralType(literal)
+```
+
+See also `t.isTSLiteralType(node, opts)` and `t.assertTSLiteralType(node, opts)`.
+
+Aliases: `TSType`
+
+ - `literal`: `NumericLiteral | StringLiteral | BooleanLiteral` (required)
+
+---
+
+### tSMappedType
+```javascript
+t.tsMappedType(typeParameter, typeAnnotation)
+```
+
+See also `t.isTSMappedType(node, opts)` and `t.assertTSMappedType(node, opts)`.
+
+Aliases: `TSType`
+
+ - `typeParameter`: `TSTypeParameter` (required)
+ - `typeAnnotation`: `TSType` (default: `null`)
+ - `optional`: `boolean` (default: `null`)
+ - `readonly`: `boolean` (default: `null`)
+
+---
+
+### tSMethodSignature
+```javascript
+t.tsMethodSignature(key, typeParameters, parameters, typeAnnotation)
+```
+
+See also `t.isTSMethodSignature(node, opts)` and `t.assertTSMethodSignature(node, opts)`.
+
+Aliases: `TSTypeElement`
+
+ - `key`: `Expression` (required)
+ - `typeParameters`: `TSTypeParameterDeclaration` (default: `null`)
+ - `parameters`: `Array<Identifier | RestElement>` (default: `null`)
+ - `typeAnnotation`: `TSTypeAnnotation` (default: `null`)
+ - `computed`: `boolean` (default: `null`)
+ - `optional`: `boolean` (default: `null`)
+
+---
+
+### tSModuleBlock
+```javascript
+t.tsModuleBlock(body)
+```
+
+See also `t.isTSModuleBlock(node, opts)` and `t.assertTSModuleBlock(node, opts)`.
+
+ - `body`: `Array<Statement>` (required)
+
+---
+
+### tSModuleDeclaration
+```javascript
+t.tsModuleDeclaration(id, body)
+```
+
+See also `t.isTSModuleDeclaration(node, opts)` and `t.assertTSModuleDeclaration(node, opts)`.
+
+Aliases: `Statement`, `Declaration`
+
+ - `id`: `Identifier | StringLiteral` (required)
+ - `body`: `TSModuleBlock | TSModuleDeclaration` (required)
+ - `declare`: `boolean` (default: `null`)
+ - `global`: `boolean` (default: `null`)
+
+---
+
+### tSNamespaceExportDeclaration
+```javascript
+t.tsNamespaceExportDeclaration(id)
+```
+
+See also `t.isTSNamespaceExportDeclaration(node, opts)` and `t.assertTSNamespaceExportDeclaration(node, opts)`.
+
+Aliases: `Statement`
+
+ - `id`: `Identifier` (required)
+
+---
+
+### tSNeverKeyword
+```javascript
+t.tsNeverKeyword()
+```
+
+See also `t.isTSNeverKeyword(node, opts)` and `t.assertTSNeverKeyword(node, opts)`.
+
+Aliases: `TSType`
+
+
+---
+
+### tSNonNullExpression
+```javascript
+t.tsNonNullExpression(expression)
+```
+
+See also `t.isTSNonNullExpression(node, opts)` and `t.assertTSNonNullExpression(node, opts)`.
+
+Aliases: `Expression`
+
+ - `expression`: `Expression` (required)
+
+---
+
+### tSNullKeyword
+```javascript
+t.tsNullKeyword()
+```
+
+See also `t.isTSNullKeyword(node, opts)` and `t.assertTSNullKeyword(node, opts)`.
+
+Aliases: `TSType`
+
+
+---
+
+### tSNumberKeyword
+```javascript
+t.tsNumberKeyword()
+```
+
+See also `t.isTSNumberKeyword(node, opts)` and `t.assertTSNumberKeyword(node, opts)`.
+
+Aliases: `TSType`
+
+
+---
+
+### tSObjectKeyword
+```javascript
+t.tsObjectKeyword()
+```
+
+See also `t.isTSObjectKeyword(node, opts)` and `t.assertTSObjectKeyword(node, opts)`.
+
+Aliases: `TSType`
+
+
+---
+
+### tSParameterProperty
+```javascript
+t.tsParameterProperty(parameter)
+```
+
+See also `t.isTSParameterProperty(node, opts)` and `t.assertTSParameterProperty(node, opts)`.
+
+Aliases: `LVal`
+
+ - `parameter`: `Identifier | AssignmentPattern` (required)
+ - `accessibility`: `"public" | "private" | "protected"` (default: `null`)
+ - `readonly`: `boolean` (default: `null`)
+
+---
+
+### tSParenthesizedType
+```javascript
+t.tsParenthesizedType(typeAnnotation)
+```
+
+See also `t.isTSParenthesizedType(node, opts)` and `t.assertTSParenthesizedType(node, opts)`.
+
+Aliases: `TSType`
+
+ - `typeAnnotation`: `TSType` (required)
+
+---
+
+### tSPropertySignature
+```javascript
+t.tsPropertySignature(key, typeAnnotation, initializer)
+```
+
+See also `t.isTSPropertySignature(node, opts)` and `t.assertTSPropertySignature(node, opts)`.
+
+Aliases: `TSTypeElement`
+
+ - `key`: `Expression` (required)
+ - `typeAnnotation`: `TSTypeAnnotation` (default: `null`)
+ - `initializer`: `Expression` (default: `null`)
+ - `computed`: `boolean` (default: `null`)
+ - `optional`: `boolean` (default: `null`)
+ - `readonly`: `boolean` (default: `null`)
+
+---
+
+### tSQualifiedName
+```javascript
+t.tsQualifiedName(left, right)
+```
+
+See also `t.isTSQualifiedName(node, opts)` and `t.assertTSQualifiedName(node, opts)`.
+
+Aliases: `TSEntityName`
+
+ - `left`: `TSEntityName` (required)
+ - `right`: `Identifier` (required)
+
+---
+
+### tSStringKeyword
+```javascript
+t.tsStringKeyword()
+```
+
+See also `t.isTSStringKeyword(node, opts)` and `t.assertTSStringKeyword(node, opts)`.
+
+Aliases: `TSType`
+
+
+---
+
+### tSSymbolKeyword
+```javascript
+t.tsSymbolKeyword()
+```
+
+See also `t.isTSSymbolKeyword(node, opts)` and `t.assertTSSymbolKeyword(node, opts)`.
+
+Aliases: `TSType`
+
+
+---
+
+### tSThisType
+```javascript
+t.tsThisType()
+```
+
+See also `t.isTSThisType(node, opts)` and `t.assertTSThisType(node, opts)`.
+
+Aliases: `TSType`
+
+
+---
+
+### tSTupleType
+```javascript
+t.tsTupleType(elementTypes)
+```
+
+See also `t.isTSTupleType(node, opts)` and `t.assertTSTupleType(node, opts)`.
+
+Aliases: `TSType`
+
+ - `elementTypes`: `Array<TSType>` (required)
+
+---
+
+### tSTypeAliasDeclaration
+```javascript
+t.tsTypeAliasDeclaration(id, typeParameters, typeAnnotation)
+```
+
+See also `t.isTSTypeAliasDeclaration(node, opts)` and `t.assertTSTypeAliasDeclaration(node, opts)`.
+
+Aliases: `Statement`, `Declaration`
+
+ - `id`: `Identifier` (required)
+ - `typeParameters`: `TSTypeParameterDeclaration` (default: `null`)
+ - `typeAnnotation`: `TSType` (required)
+ - `declare`: `boolean` (default: `null`)
+
+---
+
+### tSTypeAnnotation
+```javascript
+t.tsTypeAnnotation(typeAnnotation)
+```
+
+See also `t.isTSTypeAnnotation(node, opts)` and `t.assertTSTypeAnnotation(node, opts)`.
+
+ - `typeAnnotation`: `TSType` (required)
+
+---
+
+### tSTypeAssertion
+```javascript
+t.tsTypeAssertion(typeAnnotation, expression)
+```
+
+See also `t.isTSTypeAssertion(node, opts)` and `t.assertTSTypeAssertion(node, opts)`.
+
+Aliases: `Expression`
+
+ - `typeAnnotation`: `TSType` (required)
+ - `expression`: `Expression` (required)
+
+---
+
+### tSTypeLiteral
+```javascript
+t.tsTypeLiteral(members)
+```
+
+See also `t.isTSTypeLiteral(node, opts)` and `t.assertTSTypeLiteral(node, opts)`.
+
+Aliases: `TSType`
+
+ - `members`: `Array<TSTypeElement>` (required)
+
+---
+
+### tSTypeOperator
+```javascript
+t.tsTypeOperator(typeAnnotation)
+```
+
+See also `t.isTSTypeOperator(node, opts)` and `t.assertTSTypeOperator(node, opts)`.
+
+Aliases: `TSType`
+
+ - `typeAnnotation`: `TSType` (required)
+ - `operator`: `string` (default: `null`)
+
+---
+
+### tSTypeParameter
+```javascript
+t.tsTypeParameter(constraint, default)
+```
+
+See also `t.isTSTypeParameter(node, opts)` and `t.assertTSTypeParameter(node, opts)`.
+
+ - `constraint`: `TSType` (default: `null`)
+ - `default`: `TSType` (default: `null`)
+ - `name`: `string` (default: `null`)
+
+---
+
+### tSTypeParameterDeclaration
+```javascript
+t.tsTypeParameterDeclaration(params)
+```
+
+See also `t.isTSTypeParameterDeclaration(node, opts)` and `t.assertTSTypeParameterDeclaration(node, opts)`.
+
+ - `params`: `Array<TSTypeParameter>` (required)
+
+---
+
+### tSTypeParameterInstantiation
+```javascript
+t.tsTypeParameterInstantiation(params)
+```
+
+See also `t.isTSTypeParameterInstantiation(node, opts)` and `t.assertTSTypeParameterInstantiation(node, opts)`.
+
+ - `params`: `Array<TSType>` (required)
+
+---
+
+### tSTypePredicate
+```javascript
+t.tsTypePredicate(parameterName, typeAnnotation)
+```
+
+See also `t.isTSTypePredicate(node, opts)` and `t.assertTSTypePredicate(node, opts)`.
+
+Aliases: `TSType`
+
+ - `parameterName`: `Identifier | TSThisType` (required)
+ - `typeAnnotation`: `TSTypeAnnotation` (required)
+
+---
+
+### tSTypeQuery
+```javascript
+t.tsTypeQuery(exprName)
+```
+
+See also `t.isTSTypeQuery(node, opts)` and `t.assertTSTypeQuery(node, opts)`.
+
+Aliases: `TSType`
+
+ - `exprName`: `TSEntityName` (required)
+
+---
+
+### tSTypeReference
+```javascript
+t.tsTypeReference(typeName, typeParameters)
+```
+
+See also `t.isTSTypeReference(node, opts)` and `t.assertTSTypeReference(node, opts)`.
+
+Aliases: `TSType`
+
+ - `typeName`: `TSEntityName` (required)
+ - `typeParameters`: `TSTypeParameterInstantiation` (default: `null`)
+
+---
+
+### tSUndefinedKeyword
+```javascript
+t.tsUndefinedKeyword()
+```
+
+See also `t.isTSUndefinedKeyword(node, opts)` and `t.assertTSUndefinedKeyword(node, opts)`.
+
+Aliases: `TSType`
+
+
+---
+
+### tSUnionType
+```javascript
+t.tsUnionType(types)
+```
+
+See also `t.isTSUnionType(node, opts)` and `t.assertTSUnionType(node, opts)`.
+
+Aliases: `TSType`
+
+ - `types`: `Array<TSType>` (required)
+
+---
+
+### tSVoidKeyword
+```javascript
+t.tsVoidKeyword()
+```
+
+See also `t.isTSVoidKeyword(node, opts)` and `t.assertTSVoidKeyword(node, opts)`.
+
+Aliases: `TSType`
+
+
+---
+
+### taggedTemplateExpression
+```javascript
+t.taggedTemplateExpression(tag, quasi)
+```
+
+See also `t.isTaggedTemplateExpression(node, opts)` and `t.assertTaggedTemplateExpression(node, opts)`.
+
+Aliases: `Expression`
+
+ - `tag`: `Expression` (required)
+ - `quasi`: `TemplateLiteral` (required)
+
+---
+
+### templateElement
+```javascript
+t.templateElement(value, tail)
+```
+
+See also `t.isTemplateElement(node, opts)` and `t.assertTemplateElement(node, opts)`.
+
+ - `value` (required)
+ - `tail`: `boolean` (default: `false`)
+
+---
+
+### templateLiteral
+```javascript
+t.templateLiteral(quasis, expressions)
+```
+
+See also `t.isTemplateLiteral(node, opts)` and `t.assertTemplateLiteral(node, opts)`.
+
+Aliases: `Expression`, `Literal`
+
+ - `quasis`: `Array<TemplateElement>` (required)
+ - `expressions`: `Array<Expression>` (required)
+
+---
+
+### thisExpression
+```javascript
+t.thisExpression()
+```
+
+See also `t.isThisExpression(node, opts)` and `t.assertThisExpression(node, opts)`.
+
+Aliases: `Expression`
+
+
+---
+
+### thisTypeAnnotation
+```javascript
+t.thisTypeAnnotation()
+```
+
+See also `t.isThisTypeAnnotation(node, opts)` and `t.assertThisTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowType`, `FlowBaseAnnotation`
+
+
+---
+
+### throwStatement
+```javascript
+t.throwStatement(argument)
+```
+
+See also `t.isThrowStatement(node, opts)` and `t.assertThrowStatement(node, opts)`.
+
+Aliases: `Statement`, `Terminatorless`, `CompletionStatement`
+
+ - `argument`: `Expression` (required)
+
+---
+
+### tryStatement
+```javascript
+t.tryStatement(block, handler, finalizer)
+```
+
+See also `t.isTryStatement(node, opts)` and `t.assertTryStatement(node, opts)`.
+
+Aliases: `Statement`
+
+ - `block`: `BlockStatement` (required)
+ - `handler`: `CatchClause` (default: `null`)
+ - `finalizer`: `BlockStatement` (default: `null`)
+
+---
+
+### tupleTypeAnnotation
+```javascript
+t.tupleTypeAnnotation(types)
+```
+
+See also `t.isTupleTypeAnnotation(node, opts)` and `t.assertTupleTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowType`
+
+ - `types`: `Array<FlowType>` (required)
+
+---
+
+### typeAlias
+```javascript
+t.typeAlias(id, typeParameters, right)
+```
+
+See also `t.isTypeAlias(node, opts)` and `t.assertTypeAlias(node, opts)`.
+
+Aliases: `Flow`, `FlowDeclaration`, `Statement`, `Declaration`
+
+ - `id`: `Identifier` (required)
+ - `typeParameters`: `TypeParameterDeclaration` (default: `null`)
+ - `right`: `FlowType` (required)
+
+---
+
+### typeAnnotation
+```javascript
+t.typeAnnotation(typeAnnotation)
+```
+
+See also `t.isTypeAnnotation(node, opts)` and `t.assertTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`
+
+ - `typeAnnotation`: `FlowType` (required)
+
+---
+
+### typeCastExpression
+```javascript
+t.typeCastExpression(expression, typeAnnotation)
+```
+
+See also `t.isTypeCastExpression(node, opts)` and `t.assertTypeCastExpression(node, opts)`.
+
+Aliases: `Flow`, `ExpressionWrapper`, `Expression`
+
+ - `expression`: `Expression` (required)
+ - `typeAnnotation`: `TypeAnnotation` (required)
+
+---
+
+### typeParameter
+```javascript
+t.typeParameter(bound, default, variance)
+```
+
+See also `t.isTypeParameter(node, opts)` and `t.assertTypeParameter(node, opts)`.
+
+Aliases: `Flow`
+
+ - `bound`: `TypeAnnotation` (default: `null`)
+ - `default`: `FlowType` (default: `null`)
+ - `variance`: `Variance` (default: `null`)
+ - `name`: `string` (default: `null`)
+
+---
+
+### typeParameterDeclaration
+```javascript
+t.typeParameterDeclaration(params)
+```
+
+See also `t.isTypeParameterDeclaration(node, opts)` and `t.assertTypeParameterDeclaration(node, opts)`.
+
+Aliases: `Flow`
+
+ - `params`: `Array<TypeParameter>` (required)
+
+---
+
+### typeParameterInstantiation
+```javascript
+t.typeParameterInstantiation(params)
+```
+
+See also `t.isTypeParameterInstantiation(node, opts)` and `t.assertTypeParameterInstantiation(node, opts)`.
+
+Aliases: `Flow`
+
+ - `params`: `Array<FlowType>` (required)
+
+---
+
+### typeofTypeAnnotation
+```javascript
+t.typeofTypeAnnotation(argument)
+```
+
+See also `t.isTypeofTypeAnnotation(node, opts)` and `t.assertTypeofTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowType`
+
+ - `argument`: `FlowType` (required)
+
+---
+
+### unaryExpression
+```javascript
+t.unaryExpression(operator, argument, prefix)
+```
+
+See also `t.isUnaryExpression(node, opts)` and `t.assertUnaryExpression(node, opts)`.
+
+Aliases: `UnaryLike`, `Expression`
+
+ - `operator`: `"void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof"` (required)
+ - `argument`: `Expression` (required)
+ - `prefix`: `boolean` (default: `true`)
+
+---
+
+### unionTypeAnnotation
+```javascript
+t.unionTypeAnnotation(types)
+```
+
+See also `t.isUnionTypeAnnotation(node, opts)` and `t.assertUnionTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowType`
+
+ - `types`: `Array<FlowType>` (required)
+
+---
+
+### updateExpression
+```javascript
+t.updateExpression(operator, argument, prefix)
+```
+
+See also `t.isUpdateExpression(node, opts)` and `t.assertUpdateExpression(node, opts)`.
+
+Aliases: `Expression`
+
+ - `operator`: `"++" | "--"` (required)
+ - `argument`: `Expression` (required)
+ - `prefix`: `boolean` (default: `false`)
+
+---
+
+### variableDeclaration
+```javascript
+t.variableDeclaration(kind, declarations)
+```
+
+See also `t.isVariableDeclaration(node, opts)` and `t.assertVariableDeclaration(node, opts)`.
+
+Aliases: `Statement`, `Declaration`
+
+ - `kind`: `"var" | "let" | "const"` (required)
+ - `declarations`: `Array<VariableDeclarator>` (required)
+ - `declare`: `boolean` (default: `null`)
+
+---
+
+### variableDeclarator
+```javascript
+t.variableDeclarator(id, init)
+```
+
+See also `t.isVariableDeclarator(node, opts)` and `t.assertVariableDeclarator(node, opts)`.
+
+ - `id`: `LVal` (required)
+ - `init`: `Expression` (default: `null`)
+ - `definite`: `boolean` (default: `null`)
+
+---
+
+### variance
+```javascript
+t.variance(kind)
+```
+
+See also `t.isVariance(node, opts)` and `t.assertVariance(node, opts)`.
+
+Aliases: `Flow`
+
+ - `kind`: `"minus" | "plus"` (required)
+
+---
+
+### voidTypeAnnotation
+```javascript
+t.voidTypeAnnotation()
+```
+
+See also `t.isVoidTypeAnnotation(node, opts)` and `t.assertVoidTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowType`, `FlowBaseAnnotation`
+
+
+---
+
+### whileStatement
+```javascript
+t.whileStatement(test, body)
+```
+
+See also `t.isWhileStatement(node, opts)` and `t.assertWhileStatement(node, opts)`.
+
+Aliases: `Statement`, `BlockParent`, `Loop`, `While`, `Scopable`
+
+ - `test`: `Expression` (required)
+ - `body`: `BlockStatement | Statement` (required)
+
+---
+
+### withStatement
+```javascript
+t.withStatement(object, body)
+```
+
+See also `t.isWithStatement(node, opts)` and `t.assertWithStatement(node, opts)`.
+
+Aliases: `Statement`
+
+ - `object`: `Expression` (required)
+ - `body`: `BlockStatement | Statement` (required)
+
+---
+
+### yieldExpression
+```javascript
+t.yieldExpression(argument, delegate)
+```
+
+See also `t.isYieldExpression(node, opts)` and `t.assertYieldExpression(node, opts)`.
+
+Aliases: `Expression`, `Terminatorless`
+
+ - `argument`: `Expression` (default: `null`)
+ - `delegate`: `boolean` (default: `false`)
+
+---
diff --git a/node_modules/@babel/types/lib/asserts/assertNode.js b/node_modules/@babel/types/lib/asserts/assertNode.js
new file mode 100644
index 00000000..194ec716
--- /dev/null
+++ b/node_modules/@babel/types/lib/asserts/assertNode.js
@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = assertNode;
+
+var _isNode = _interopRequireDefault(require("../validators/isNode"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function assertNode(node) {
+  if (!(0, _isNode.default)(node)) {
+    const type = node && node.type || JSON.stringify(node);
+    throw new TypeError(`Not a valid node of type "${type}"`);
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/asserts/generated/index.js b/node_modules/@babel/types/lib/asserts/generated/index.js
new file mode 100644
index 00000000..a2a67355
--- /dev/null
+++ b/node_modules/@babel/types/lib/asserts/generated/index.js
@@ -0,0 +1,1294 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assertArrayExpression = assertArrayExpression;
+exports.assertAssignmentExpression = assertAssignmentExpression;
+exports.assertBinaryExpression = assertBinaryExpression;
+exports.assertDirective = assertDirective;
+exports.assertDirectiveLiteral = assertDirectiveLiteral;
+exports.assertBlockStatement = assertBlockStatement;
+exports.assertBreakStatement = assertBreakStatement;
+exports.assertCallExpression = assertCallExpression;
+exports.assertCatchClause = assertCatchClause;
+exports.assertConditionalExpression = assertConditionalExpression;
+exports.assertContinueStatement = assertContinueStatement;
+exports.assertDebuggerStatement = assertDebuggerStatement;
+exports.assertDoWhileStatement = assertDoWhileStatement;
+exports.assertEmptyStatement = assertEmptyStatement;
+exports.assertExpressionStatement = assertExpressionStatement;
+exports.assertFile = assertFile;
+exports.assertForInStatement = assertForInStatement;
+exports.assertForStatement = assertForStatement;
+exports.assertFunctionDeclaration = assertFunctionDeclaration;
+exports.assertFunctionExpression = assertFunctionExpression;
+exports.assertIdentifier = assertIdentifier;
+exports.assertIfStatement = assertIfStatement;
+exports.assertLabeledStatement = assertLabeledStatement;
+exports.assertStringLiteral = assertStringLiteral;
+exports.assertNumericLiteral = assertNumericLiteral;
+exports.assertNullLiteral = assertNullLiteral;
+exports.assertBooleanLiteral = assertBooleanLiteral;
+exports.assertRegExpLiteral = assertRegExpLiteral;
+exports.assertLogicalExpression = assertLogicalExpression;
+exports.assertMemberExpression = assertMemberExpression;
+exports.assertNewExpression = assertNewExpression;
+exports.assertProgram = assertProgram;
+exports.assertObjectExpression = assertObjectExpression;
+exports.assertObjectMethod = assertObjectMethod;
+exports.assertObjectProperty = assertObjectProperty;
+exports.assertRestElement = assertRestElement;
+exports.assertReturnStatement = assertReturnStatement;
+exports.assertSequenceExpression = assertSequenceExpression;
+exports.assertSwitchCase = assertSwitchCase;
+exports.assertSwitchStatement = assertSwitchStatement;
+exports.assertThisExpression = assertThisExpression;
+exports.assertThrowStatement = assertThrowStatement;
+exports.assertTryStatement = assertTryStatement;
+exports.assertUnaryExpression = assertUnaryExpression;
+exports.assertUpdateExpression = assertUpdateExpression;
+exports.assertVariableDeclaration = assertVariableDeclaration;
+exports.assertVariableDeclarator = assertVariableDeclarator;
+exports.assertWhileStatement = assertWhileStatement;
+exports.assertWithStatement = assertWithStatement;
+exports.assertAssignmentPattern = assertAssignmentPattern;
+exports.assertArrayPattern = assertArrayPattern;
+exports.assertArrowFunctionExpression = assertArrowFunctionExpression;
+exports.assertClassBody = assertClassBody;
+exports.assertClassDeclaration = assertClassDeclaration;
+exports.assertClassExpression = assertClassExpression;
+exports.assertExportAllDeclaration = assertExportAllDeclaration;
+exports.assertExportDefaultDeclaration = assertExportDefaultDeclaration;
+exports.assertExportNamedDeclaration = assertExportNamedDeclaration;
+exports.assertExportSpecifier = assertExportSpecifier;
+exports.assertForOfStatement = assertForOfStatement;
+exports.assertImportDeclaration = assertImportDeclaration;
+exports.assertImportDefaultSpecifier = assertImportDefaultSpecifier;
+exports.assertImportNamespaceSpecifier = assertImportNamespaceSpecifier;
+exports.assertImportSpecifier = assertImportSpecifier;
+exports.assertMetaProperty = assertMetaProperty;
+exports.assertClassMethod = assertClassMethod;
+exports.assertObjectPattern = assertObjectPattern;
+exports.assertSpreadElement = assertSpreadElement;
+exports.assertSuper = assertSuper;
+exports.assertTaggedTemplateExpression = assertTaggedTemplateExpression;
+exports.assertTemplateElement = assertTemplateElement;
+exports.assertTemplateLiteral = assertTemplateLiteral;
+exports.assertYieldExpression = assertYieldExpression;
+exports.assertAnyTypeAnnotation = assertAnyTypeAnnotation;
+exports.assertArrayTypeAnnotation = assertArrayTypeAnnotation;
+exports.assertBooleanTypeAnnotation = assertBooleanTypeAnnotation;
+exports.assertBooleanLiteralTypeAnnotation = assertBooleanLiteralTypeAnnotation;
+exports.assertNullLiteralTypeAnnotation = assertNullLiteralTypeAnnotation;
+exports.assertClassImplements = assertClassImplements;
+exports.assertDeclareClass = assertDeclareClass;
+exports.assertDeclareFunction = assertDeclareFunction;
+exports.assertDeclareInterface = assertDeclareInterface;
+exports.assertDeclareModule = assertDeclareModule;
+exports.assertDeclareModuleExports = assertDeclareModuleExports;
+exports.assertDeclareTypeAlias = assertDeclareTypeAlias;
+exports.assertDeclareOpaqueType = assertDeclareOpaqueType;
+exports.assertDeclareVariable = assertDeclareVariable;
+exports.assertDeclareExportDeclaration = assertDeclareExportDeclaration;
+exports.assertDeclareExportAllDeclaration = assertDeclareExportAllDeclaration;
+exports.assertDeclaredPredicate = assertDeclaredPredicate;
+exports.assertExistsTypeAnnotation = assertExistsTypeAnnotation;
+exports.assertFunctionTypeAnnotation = assertFunctionTypeAnnotation;
+exports.assertFunctionTypeParam = assertFunctionTypeParam;
+exports.assertGenericTypeAnnotation = assertGenericTypeAnnotation;
+exports.assertInferredPredicate = assertInferredPredicate;
+exports.assertInterfaceExtends = assertInterfaceExtends;
+exports.assertInterfaceDeclaration = assertInterfaceDeclaration;
+exports.assertIntersectionTypeAnnotation = assertIntersectionTypeAnnotation;
+exports.assertMixedTypeAnnotation = assertMixedTypeAnnotation;
+exports.assertEmptyTypeAnnotation = assertEmptyTypeAnnotation;
+exports.assertNullableTypeAnnotation = assertNullableTypeAnnotation;
+exports.assertNumberLiteralTypeAnnotation = assertNumberLiteralTypeAnnotation;
+exports.assertNumberTypeAnnotation = assertNumberTypeAnnotation;
+exports.assertObjectTypeAnnotation = assertObjectTypeAnnotation;
+exports.assertObjectTypeCallProperty = assertObjectTypeCallProperty;
+exports.assertObjectTypeIndexer = assertObjectTypeIndexer;
+exports.assertObjectTypeProperty = assertObjectTypeProperty;
+exports.assertObjectTypeSpreadProperty = assertObjectTypeSpreadProperty;
+exports.assertOpaqueType = assertOpaqueType;
+exports.assertQualifiedTypeIdentifier = assertQualifiedTypeIdentifier;
+exports.assertStringLiteralTypeAnnotation = assertStringLiteralTypeAnnotation;
+exports.assertStringTypeAnnotation = assertStringTypeAnnotation;
+exports.assertThisTypeAnnotation = assertThisTypeAnnotation;
+exports.assertTupleTypeAnnotation = assertTupleTypeAnnotation;
+exports.assertTypeofTypeAnnotation = assertTypeofTypeAnnotation;
+exports.assertTypeAlias = assertTypeAlias;
+exports.assertTypeAnnotation = assertTypeAnnotation;
+exports.assertTypeCastExpression = assertTypeCastExpression;
+exports.assertTypeParameter = assertTypeParameter;
+exports.assertTypeParameterDeclaration = assertTypeParameterDeclaration;
+exports.assertTypeParameterInstantiation = assertTypeParameterInstantiation;
+exports.assertUnionTypeAnnotation = assertUnionTypeAnnotation;
+exports.assertVariance = assertVariance;
+exports.assertVoidTypeAnnotation = assertVoidTypeAnnotation;
+exports.assertJSXAttribute = assertJSXAttribute;
+exports.assertJSXClosingElement = assertJSXClosingElement;
+exports.assertJSXElement = assertJSXElement;
+exports.assertJSXEmptyExpression = assertJSXEmptyExpression;
+exports.assertJSXExpressionContainer = assertJSXExpressionContainer;
+exports.assertJSXSpreadChild = assertJSXSpreadChild;
+exports.assertJSXIdentifier = assertJSXIdentifier;
+exports.assertJSXMemberExpression = assertJSXMemberExpression;
+exports.assertJSXNamespacedName = assertJSXNamespacedName;
+exports.assertJSXOpeningElement = assertJSXOpeningElement;
+exports.assertJSXSpreadAttribute = assertJSXSpreadAttribute;
+exports.assertJSXText = assertJSXText;
+exports.assertJSXFragment = assertJSXFragment;
+exports.assertJSXOpeningFragment = assertJSXOpeningFragment;
+exports.assertJSXClosingFragment = assertJSXClosingFragment;
+exports.assertNoop = assertNoop;
+exports.assertParenthesizedExpression = assertParenthesizedExpression;
+exports.assertAwaitExpression = assertAwaitExpression;
+exports.assertBindExpression = assertBindExpression;
+exports.assertClassProperty = assertClassProperty;
+exports.assertOptionalMemberExpression = assertOptionalMemberExpression;
+exports.assertOptionalCallExpression = assertOptionalCallExpression;
+exports.assertClassPrivateProperty = assertClassPrivateProperty;
+exports.assertImport = assertImport;
+exports.assertDecorator = assertDecorator;
+exports.assertDoExpression = assertDoExpression;
+exports.assertExportDefaultSpecifier = assertExportDefaultSpecifier;
+exports.assertExportNamespaceSpecifier = assertExportNamespaceSpecifier;
+exports.assertPrivateName = assertPrivateName;
+exports.assertTSParameterProperty = assertTSParameterProperty;
+exports.assertTSDeclareFunction = assertTSDeclareFunction;
+exports.assertTSDeclareMethod = assertTSDeclareMethod;
+exports.assertTSQualifiedName = assertTSQualifiedName;
+exports.assertTSCallSignatureDeclaration = assertTSCallSignatureDeclaration;
+exports.assertTSConstructSignatureDeclaration = assertTSConstructSignatureDeclaration;
+exports.assertTSPropertySignature = assertTSPropertySignature;
+exports.assertTSMethodSignature = assertTSMethodSignature;
+exports.assertTSIndexSignature = assertTSIndexSignature;
+exports.assertTSAnyKeyword = assertTSAnyKeyword;
+exports.assertTSNumberKeyword = assertTSNumberKeyword;
+exports.assertTSObjectKeyword = assertTSObjectKeyword;
+exports.assertTSBooleanKeyword = assertTSBooleanKeyword;
+exports.assertTSStringKeyword = assertTSStringKeyword;
+exports.assertTSSymbolKeyword = assertTSSymbolKeyword;
+exports.assertTSVoidKeyword = assertTSVoidKeyword;
+exports.assertTSUndefinedKeyword = assertTSUndefinedKeyword;
+exports.assertTSNullKeyword = assertTSNullKeyword;
+exports.assertTSNeverKeyword = assertTSNeverKeyword;
+exports.assertTSThisType = assertTSThisType;
+exports.assertTSFunctionType = assertTSFunctionType;
+exports.assertTSConstructorType = assertTSConstructorType;
+exports.assertTSTypeReference = assertTSTypeReference;
+exports.assertTSTypePredicate = assertTSTypePredicate;
+exports.assertTSTypeQuery = assertTSTypeQuery;
+exports.assertTSTypeLiteral = assertTSTypeLiteral;
+exports.assertTSArrayType = assertTSArrayType;
+exports.assertTSTupleType = assertTSTupleType;
+exports.assertTSUnionType = assertTSUnionType;
+exports.assertTSIntersectionType = assertTSIntersectionType;
+exports.assertTSConditionalType = assertTSConditionalType;
+exports.assertTSInferType = assertTSInferType;
+exports.assertTSParenthesizedType = assertTSParenthesizedType;
+exports.assertTSTypeOperator = assertTSTypeOperator;
+exports.assertTSIndexedAccessType = assertTSIndexedAccessType;
+exports.assertTSMappedType = assertTSMappedType;
+exports.assertTSLiteralType = assertTSLiteralType;
+exports.assertTSExpressionWithTypeArguments = assertTSExpressionWithTypeArguments;
+exports.assertTSInterfaceDeclaration = assertTSInterfaceDeclaration;
+exports.assertTSInterfaceBody = assertTSInterfaceBody;
+exports.assertTSTypeAliasDeclaration = assertTSTypeAliasDeclaration;
+exports.assertTSAsExpression = assertTSAsExpression;
+exports.assertTSTypeAssertion = assertTSTypeAssertion;
+exports.assertTSEnumDeclaration = assertTSEnumDeclaration;
+exports.assertTSEnumMember = assertTSEnumMember;
+exports.assertTSModuleDeclaration = assertTSModuleDeclaration;
+exports.assertTSModuleBlock = assertTSModuleBlock;
+exports.assertTSImportEqualsDeclaration = assertTSImportEqualsDeclaration;
+exports.assertTSExternalModuleReference = assertTSExternalModuleReference;
+exports.assertTSNonNullExpression = assertTSNonNullExpression;
+exports.assertTSExportAssignment = assertTSExportAssignment;
+exports.assertTSNamespaceExportDeclaration = assertTSNamespaceExportDeclaration;
+exports.assertTSTypeAnnotation = assertTSTypeAnnotation;
+exports.assertTSTypeParameterInstantiation = assertTSTypeParameterInstantiation;
+exports.assertTSTypeParameterDeclaration = assertTSTypeParameterDeclaration;
+exports.assertTSTypeParameter = assertTSTypeParameter;
+exports.assertExpression = assertExpression;
+exports.assertBinary = assertBinary;
+exports.assertScopable = assertScopable;
+exports.assertBlockParent = assertBlockParent;
+exports.assertBlock = assertBlock;
+exports.assertStatement = assertStatement;
+exports.assertTerminatorless = assertTerminatorless;
+exports.assertCompletionStatement = assertCompletionStatement;
+exports.assertConditional = assertConditional;
+exports.assertLoop = assertLoop;
+exports.assertWhile = assertWhile;
+exports.assertExpressionWrapper = assertExpressionWrapper;
+exports.assertFor = assertFor;
+exports.assertForXStatement = assertForXStatement;
+exports.assertFunction = assertFunction;
+exports.assertFunctionParent = assertFunctionParent;
+exports.assertPureish = assertPureish;
+exports.assertDeclaration = assertDeclaration;
+exports.assertPatternLike = assertPatternLike;
+exports.assertLVal = assertLVal;
+exports.assertTSEntityName = assertTSEntityName;
+exports.assertLiteral = assertLiteral;
+exports.assertImmutable = assertImmutable;
+exports.assertUserWhitespacable = assertUserWhitespacable;
+exports.assertMethod = assertMethod;
+exports.assertObjectMember = assertObjectMember;
+exports.assertProperty = assertProperty;
+exports.assertUnaryLike = assertUnaryLike;
+exports.assertPattern = assertPattern;
+exports.assertClass = assertClass;
+exports.assertModuleDeclaration = assertModuleDeclaration;
+exports.assertExportDeclaration = assertExportDeclaration;
+exports.assertModuleSpecifier = assertModuleSpecifier;
+exports.assertFlow = assertFlow;
+exports.assertFlowType = assertFlowType;
+exports.assertFlowBaseAnnotation = assertFlowBaseAnnotation;
+exports.assertFlowDeclaration = assertFlowDeclaration;
+exports.assertFlowPredicate = assertFlowPredicate;
+exports.assertJSX = assertJSX;
+exports.assertPrivate = assertPrivate;
+exports.assertTSTypeElement = assertTSTypeElement;
+exports.assertTSType = assertTSType;
+exports.assertNumberLiteral = assertNumberLiteral;
+exports.assertRegexLiteral = assertRegexLiteral;
+exports.assertRestProperty = assertRestProperty;
+exports.assertSpreadProperty = assertSpreadProperty;
+
+var _is = _interopRequireDefault(require("../../validators/is"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function assert(type, node, opts) {
+  if (!(0, _is.default)(type, node, opts)) {
+    throw new Error(`Expected type "${type}" with option ${JSON.stringify(opts)}, but instead got "${node.type}".`);
+  }
+}
+
+function assertArrayExpression(node, opts = {}) {
+  assert("ArrayExpression", node, opts);
+}
+
+function assertAssignmentExpression(node, opts = {}) {
+  assert("AssignmentExpression", node, opts);
+}
+
+function assertBinaryExpression(node, opts = {}) {
+  assert("BinaryExpression", node, opts);
+}
+
+function assertDirective(node, opts = {}) {
+  assert("Directive", node, opts);
+}
+
+function assertDirectiveLiteral(node, opts = {}) {
+  assert("DirectiveLiteral", node, opts);
+}
+
+function assertBlockStatement(node, opts = {}) {
+  assert("BlockStatement", node, opts);
+}
+
+function assertBreakStatement(node, opts = {}) {
+  assert("BreakStatement", node, opts);
+}
+
+function assertCallExpression(node, opts = {}) {
+  assert("CallExpression", node, opts);
+}
+
+function assertCatchClause(node, opts = {}) {
+  assert("CatchClause", node, opts);
+}
+
+function assertConditionalExpression(node, opts = {}) {
+  assert("ConditionalExpression", node, opts);
+}
+
+function assertContinueStatement(node, opts = {}) {
+  assert("ContinueStatement", node, opts);
+}
+
+function assertDebuggerStatement(node, opts = {}) {
+  assert("DebuggerStatement", node, opts);
+}
+
+function assertDoWhileStatement(node, opts = {}) {
+  assert("DoWhileStatement", node, opts);
+}
+
+function assertEmptyStatement(node, opts = {}) {
+  assert("EmptyStatement", node, opts);
+}
+
+function assertExpressionStatement(node, opts = {}) {
+  assert("ExpressionStatement", node, opts);
+}
+
+function assertFile(node, opts = {}) {
+  assert("File", node, opts);
+}
+
+function assertForInStatement(node, opts = {}) {
+  assert("ForInStatement", node, opts);
+}
+
+function assertForStatement(node, opts = {}) {
+  assert("ForStatement", node, opts);
+}
+
+function assertFunctionDeclaration(node, opts = {}) {
+  assert("FunctionDeclaration", node, opts);
+}
+
+function assertFunctionExpression(node, opts = {}) {
+  assert("FunctionExpression", node, opts);
+}
+
+function assertIdentifier(node, opts = {}) {
+  assert("Identifier", node, opts);
+}
+
+function assertIfStatement(node, opts = {}) {
+  assert("IfStatement", node, opts);
+}
+
+function assertLabeledStatement(node, opts = {}) {
+  assert("LabeledStatement", node, opts);
+}
+
+function assertStringLiteral(node, opts = {}) {
+  assert("StringLiteral", node, opts);
+}
+
+function assertNumericLiteral(node, opts = {}) {
+  assert("NumericLiteral", node, opts);
+}
+
+function assertNullLiteral(node, opts = {}) {
+  assert("NullLiteral", node, opts);
+}
+
+function assertBooleanLiteral(node, opts = {}) {
+  assert("BooleanLiteral", node, opts);
+}
+
+function assertRegExpLiteral(node, opts = {}) {
+  assert("RegExpLiteral", node, opts);
+}
+
+function assertLogicalExpression(node, opts = {}) {
+  assert("LogicalExpression", node, opts);
+}
+
+function assertMemberExpression(node, opts = {}) {
+  assert("MemberExpression", node, opts);
+}
+
+function assertNewExpression(node, opts = {}) {
+  assert("NewExpression", node, opts);
+}
+
+function assertProgram(node, opts = {}) {
+  assert("Program", node, opts);
+}
+
+function assertObjectExpression(node, opts = {}) {
+  assert("ObjectExpression", node, opts);
+}
+
+function assertObjectMethod(node, opts = {}) {
+  assert("ObjectMethod", node, opts);
+}
+
+function assertObjectProperty(node, opts = {}) {
+  assert("ObjectProperty", node, opts);
+}
+
+function assertRestElement(node, opts = {}) {
+  assert("RestElement", node, opts);
+}
+
+function assertReturnStatement(node, opts = {}) {
+  assert("ReturnStatement", node, opts);
+}
+
+function assertSequenceExpression(node, opts = {}) {
+  assert("SequenceExpression", node, opts);
+}
+
+function assertSwitchCase(node, opts = {}) {
+  assert("SwitchCase", node, opts);
+}
+
+function assertSwitchStatement(node, opts = {}) {
+  assert("SwitchStatement", node, opts);
+}
+
+function assertThisExpression(node, opts = {}) {
+  assert("ThisExpression", node, opts);
+}
+
+function assertThrowStatement(node, opts = {}) {
+  assert("ThrowStatement", node, opts);
+}
+
+function assertTryStatement(node, opts = {}) {
+  assert("TryStatement", node, opts);
+}
+
+function assertUnaryExpression(node, opts = {}) {
+  assert("UnaryExpression", node, opts);
+}
+
+function assertUpdateExpression(node, opts = {}) {
+  assert("UpdateExpression", node, opts);
+}
+
+function assertVariableDeclaration(node, opts = {}) {
+  assert("VariableDeclaration", node, opts);
+}
+
+function assertVariableDeclarator(node, opts = {}) {
+  assert("VariableDeclarator", node, opts);
+}
+
+function assertWhileStatement(node, opts = {}) {
+  assert("WhileStatement", node, opts);
+}
+
+function assertWithStatement(node, opts = {}) {
+  assert("WithStatement", node, opts);
+}
+
+function assertAssignmentPattern(node, opts = {}) {
+  assert("AssignmentPattern", node, opts);
+}
+
+function assertArrayPattern(node, opts = {}) {
+  assert("ArrayPattern", node, opts);
+}
+
+function assertArrowFunctionExpression(node, opts = {}) {
+  assert("ArrowFunctionExpression", node, opts);
+}
+
+function assertClassBody(node, opts = {}) {
+  assert("ClassBody", node, opts);
+}
+
+function assertClassDeclaration(node, opts = {}) {
+  assert("ClassDeclaration", node, opts);
+}
+
+function assertClassExpression(node, opts = {}) {
+  assert("ClassExpression", node, opts);
+}
+
+function assertExportAllDeclaration(node, opts = {}) {
+  assert("ExportAllDeclaration", node, opts);
+}
+
+function assertExportDefaultDeclaration(node, opts = {}) {
+  assert("ExportDefaultDeclaration", node, opts);
+}
+
+function assertExportNamedDeclaration(node, opts = {}) {
+  assert("ExportNamedDeclaration", node, opts);
+}
+
+function assertExportSpecifier(node, opts = {}) {
+  assert("ExportSpecifier", node, opts);
+}
+
+function assertForOfStatement(node, opts = {}) {
+  assert("ForOfStatement", node, opts);
+}
+
+function assertImportDeclaration(node, opts = {}) {
+  assert("ImportDeclaration", node, opts);
+}
+
+function assertImportDefaultSpecifier(node, opts = {}) {
+  assert("ImportDefaultSpecifier", node, opts);
+}
+
+function assertImportNamespaceSpecifier(node, opts = {}) {
+  assert("ImportNamespaceSpecifier", node, opts);
+}
+
+function assertImportSpecifier(node, opts = {}) {
+  assert("ImportSpecifier", node, opts);
+}
+
+function assertMetaProperty(node, opts = {}) {
+  assert("MetaProperty", node, opts);
+}
+
+function assertClassMethod(node, opts = {}) {
+  assert("ClassMethod", node, opts);
+}
+
+function assertObjectPattern(node, opts = {}) {
+  assert("ObjectPattern", node, opts);
+}
+
+function assertSpreadElement(node, opts = {}) {
+  assert("SpreadElement", node, opts);
+}
+
+function assertSuper(node, opts = {}) {
+  assert("Super", node, opts);
+}
+
+function assertTaggedTemplateExpression(node, opts = {}) {
+  assert("TaggedTemplateExpression", node, opts);
+}
+
+function assertTemplateElement(node, opts = {}) {
+  assert("TemplateElement", node, opts);
+}
+
+function assertTemplateLiteral(node, opts = {}) {
+  assert("TemplateLiteral", node, opts);
+}
+
+function assertYieldExpression(node, opts = {}) {
+  assert("YieldExpression", node, opts);
+}
+
+function assertAnyTypeAnnotation(node, opts = {}) {
+  assert("AnyTypeAnnotation", node, opts);
+}
+
+function assertArrayTypeAnnotation(node, opts = {}) {
+  assert("ArrayTypeAnnotation", node, opts);
+}
+
+function assertBooleanTypeAnnotation(node, opts = {}) {
+  assert("BooleanTypeAnnotation", node, opts);
+}
+
+function assertBooleanLiteralTypeAnnotation(node, opts = {}) {
+  assert("BooleanLiteralTypeAnnotation", node, opts);
+}
+
+function assertNullLiteralTypeAnnotation(node, opts = {}) {
+  assert("NullLiteralTypeAnnotation", node, opts);
+}
+
+function assertClassImplements(node, opts = {}) {
+  assert("ClassImplements", node, opts);
+}
+
+function assertDeclareClass(node, opts = {}) {
+  assert("DeclareClass", node, opts);
+}
+
+function assertDeclareFunction(node, opts = {}) {
+  assert("DeclareFunction", node, opts);
+}
+
+function assertDeclareInterface(node, opts = {}) {
+  assert("DeclareInterface", node, opts);
+}
+
+function assertDeclareModule(node, opts = {}) {
+  assert("DeclareModule", node, opts);
+}
+
+function assertDeclareModuleExports(node, opts = {}) {
+  assert("DeclareModuleExports", node, opts);
+}
+
+function assertDeclareTypeAlias(node, opts = {}) {
+  assert("DeclareTypeAlias", node, opts);
+}
+
+function assertDeclareOpaqueType(node, opts = {}) {
+  assert("DeclareOpaqueType", node, opts);
+}
+
+function assertDeclareVariable(node, opts = {}) {
+  assert("DeclareVariable", node, opts);
+}
+
+function assertDeclareExportDeclaration(node, opts = {}) {
+  assert("DeclareExportDeclaration", node, opts);
+}
+
+function assertDeclareExportAllDeclaration(node, opts = {}) {
+  assert("DeclareExportAllDeclaration", node, opts);
+}
+
+function assertDeclaredPredicate(node, opts = {}) {
+  assert("DeclaredPredicate", node, opts);
+}
+
+function assertExistsTypeAnnotation(node, opts = {}) {
+  assert("ExistsTypeAnnotation", node, opts);
+}
+
+function assertFunctionTypeAnnotation(node, opts = {}) {
+  assert("FunctionTypeAnnotation", node, opts);
+}
+
+function assertFunctionTypeParam(node, opts = {}) {
+  assert("FunctionTypeParam", node, opts);
+}
+
+function assertGenericTypeAnnotation(node, opts = {}) {
+  assert("GenericTypeAnnotation", node, opts);
+}
+
+function assertInferredPredicate(node, opts = {}) {
+  assert("InferredPredicate", node, opts);
+}
+
+function assertInterfaceExtends(node, opts = {}) {
+  assert("InterfaceExtends", node, opts);
+}
+
+function assertInterfaceDeclaration(node, opts = {}) {
+  assert("InterfaceDeclaration", node, opts);
+}
+
+function assertIntersectionTypeAnnotation(node, opts = {}) {
+  assert("IntersectionTypeAnnotation", node, opts);
+}
+
+function assertMixedTypeAnnotation(node, opts = {}) {
+  assert("MixedTypeAnnotation", node, opts);
+}
+
+function assertEmptyTypeAnnotation(node, opts = {}) {
+  assert("EmptyTypeAnnotation", node, opts);
+}
+
+function assertNullableTypeAnnotation(node, opts = {}) {
+  assert("NullableTypeAnnotation", node, opts);
+}
+
+function assertNumberLiteralTypeAnnotation(node, opts = {}) {
+  assert("NumberLiteralTypeAnnotation", node, opts);
+}
+
+function assertNumberTypeAnnotation(node, opts = {}) {
+  assert("NumberTypeAnnotation", node, opts);
+}
+
+function assertObjectTypeAnnotation(node, opts = {}) {
+  assert("ObjectTypeAnnotation", node, opts);
+}
+
+function assertObjectTypeCallProperty(node, opts = {}) {
+  assert("ObjectTypeCallProperty", node, opts);
+}
+
+function assertObjectTypeIndexer(node, opts = {}) {
+  assert("ObjectTypeIndexer", node, opts);
+}
+
+function assertObjectTypeProperty(node, opts = {}) {
+  assert("ObjectTypeProperty", node, opts);
+}
+
+function assertObjectTypeSpreadProperty(node, opts = {}) {
+  assert("ObjectTypeSpreadProperty", node, opts);
+}
+
+function assertOpaqueType(node, opts = {}) {
+  assert("OpaqueType", node, opts);
+}
+
+function assertQualifiedTypeIdentifier(node, opts = {}) {
+  assert("QualifiedTypeIdentifier", node, opts);
+}
+
+function assertStringLiteralTypeAnnotation(node, opts = {}) {
+  assert("StringLiteralTypeAnnotation", node, opts);
+}
+
+function assertStringTypeAnnotation(node, opts = {}) {
+  assert("StringTypeAnnotation", node, opts);
+}
+
+function assertThisTypeAnnotation(node, opts = {}) {
+  assert("ThisTypeAnnotation", node, opts);
+}
+
+function assertTupleTypeAnnotation(node, opts = {}) {
+  assert("TupleTypeAnnotation", node, opts);
+}
+
+function assertTypeofTypeAnnotation(node, opts = {}) {
+  assert("TypeofTypeAnnotation", node, opts);
+}
+
+function assertTypeAlias(node, opts = {}) {
+  assert("TypeAlias", node, opts);
+}
+
+function assertTypeAnnotation(node, opts = {}) {
+  assert("TypeAnnotation", node, opts);
+}
+
+function assertTypeCastExpression(node, opts = {}) {
+  assert("TypeCastExpression", node, opts);
+}
+
+function assertTypeParameter(node, opts = {}) {
+  assert("TypeParameter", node, opts);
+}
+
+function assertTypeParameterDeclaration(node, opts = {}) {
+  assert("TypeParameterDeclaration", node, opts);
+}
+
+function assertTypeParameterInstantiation(node, opts = {}) {
+  assert("TypeParameterInstantiation", node, opts);
+}
+
+function assertUnionTypeAnnotation(node, opts = {}) {
+  assert("UnionTypeAnnotation", node, opts);
+}
+
+function assertVariance(node, opts = {}) {
+  assert("Variance", node, opts);
+}
+
+function assertVoidTypeAnnotation(node, opts = {}) {
+  assert("VoidTypeAnnotation", node, opts);
+}
+
+function assertJSXAttribute(node, opts = {}) {
+  assert("JSXAttribute", node, opts);
+}
+
+function assertJSXClosingElement(node, opts = {}) {
+  assert("JSXClosingElement", node, opts);
+}
+
+function assertJSXElement(node, opts = {}) {
+  assert("JSXElement", node, opts);
+}
+
+function assertJSXEmptyExpression(node, opts = {}) {
+  assert("JSXEmptyExpression", node, opts);
+}
+
+function assertJSXExpressionContainer(node, opts = {}) {
+  assert("JSXExpressionContainer", node, opts);
+}
+
+function assertJSXSpreadChild(node, opts = {}) {
+  assert("JSXSpreadChild", node, opts);
+}
+
+function assertJSXIdentifier(node, opts = {}) {
+  assert("JSXIdentifier", node, opts);
+}
+
+function assertJSXMemberExpression(node, opts = {}) {
+  assert("JSXMemberExpression", node, opts);
+}
+
+function assertJSXNamespacedName(node, opts = {}) {
+  assert("JSXNamespacedName", node, opts);
+}
+
+function assertJSXOpeningElement(node, opts = {}) {
+  assert("JSXOpeningElement", node, opts);
+}
+
+function assertJSXSpreadAttribute(node, opts = {}) {
+  assert("JSXSpreadAttribute", node, opts);
+}
+
+function assertJSXText(node, opts = {}) {
+  assert("JSXText", node, opts);
+}
+
+function assertJSXFragment(node, opts = {}) {
+  assert("JSXFragment", node, opts);
+}
+
+function assertJSXOpeningFragment(node, opts = {}) {
+  assert("JSXOpeningFragment", node, opts);
+}
+
+function assertJSXClosingFragment(node, opts = {}) {
+  assert("JSXClosingFragment", node, opts);
+}
+
+function assertNoop(node, opts = {}) {
+  assert("Noop", node, opts);
+}
+
+function assertParenthesizedExpression(node, opts = {}) {
+  assert("ParenthesizedExpression", node, opts);
+}
+
+function assertAwaitExpression(node, opts = {}) {
+  assert("AwaitExpression", node, opts);
+}
+
+function assertBindExpression(node, opts = {}) {
+  assert("BindExpression", node, opts);
+}
+
+function assertClassProperty(node, opts = {}) {
+  assert("ClassProperty", node, opts);
+}
+
+function assertOptionalMemberExpression(node, opts = {}) {
+  assert("OptionalMemberExpression", node, opts);
+}
+
+function assertOptionalCallExpression(node, opts = {}) {
+  assert("OptionalCallExpression", node, opts);
+}
+
+function assertClassPrivateProperty(node, opts = {}) {
+  assert("ClassPrivateProperty", node, opts);
+}
+
+function assertImport(node, opts = {}) {
+  assert("Import", node, opts);
+}
+
+function assertDecorator(node, opts = {}) {
+  assert("Decorator", node, opts);
+}
+
+function assertDoExpression(node, opts = {}) {
+  assert("DoExpression", node, opts);
+}
+
+function assertExportDefaultSpecifier(node, opts = {}) {
+  assert("ExportDefaultSpecifier", node, opts);
+}
+
+function assertExportNamespaceSpecifier(node, opts = {}) {
+  assert("ExportNamespaceSpecifier", node, opts);
+}
+
+function assertPrivateName(node, opts = {}) {
+  assert("PrivateName", node, opts);
+}
+
+function assertTSParameterProperty(node, opts = {}) {
+  assert("TSParameterProperty", node, opts);
+}
+
+function assertTSDeclareFunction(node, opts = {}) {
+  assert("TSDeclareFunction", node, opts);
+}
+
+function assertTSDeclareMethod(node, opts = {}) {
+  assert("TSDeclareMethod", node, opts);
+}
+
+function assertTSQualifiedName(node, opts = {}) {
+  assert("TSQualifiedName", node, opts);
+}
+
+function assertTSCallSignatureDeclaration(node, opts = {}) {
+  assert("TSCallSignatureDeclaration", node, opts);
+}
+
+function assertTSConstructSignatureDeclaration(node, opts = {}) {
+  assert("TSConstructSignatureDeclaration", node, opts);
+}
+
+function assertTSPropertySignature(node, opts = {}) {
+  assert("TSPropertySignature", node, opts);
+}
+
+function assertTSMethodSignature(node, opts = {}) {
+  assert("TSMethodSignature", node, opts);
+}
+
+function assertTSIndexSignature(node, opts = {}) {
+  assert("TSIndexSignature", node, opts);
+}
+
+function assertTSAnyKeyword(node, opts = {}) {
+  assert("TSAnyKeyword", node, opts);
+}
+
+function assertTSNumberKeyword(node, opts = {}) {
+  assert("TSNumberKeyword", node, opts);
+}
+
+function assertTSObjectKeyword(node, opts = {}) {
+  assert("TSObjectKeyword", node, opts);
+}
+
+function assertTSBooleanKeyword(node, opts = {}) {
+  assert("TSBooleanKeyword", node, opts);
+}
+
+function assertTSStringKeyword(node, opts = {}) {
+  assert("TSStringKeyword", node, opts);
+}
+
+function assertTSSymbolKeyword(node, opts = {}) {
+  assert("TSSymbolKeyword", node, opts);
+}
+
+function assertTSVoidKeyword(node, opts = {}) {
+  assert("TSVoidKeyword", node, opts);
+}
+
+function assertTSUndefinedKeyword(node, opts = {}) {
+  assert("TSUndefinedKeyword", node, opts);
+}
+
+function assertTSNullKeyword(node, opts = {}) {
+  assert("TSNullKeyword", node, opts);
+}
+
+function assertTSNeverKeyword(node, opts = {}) {
+  assert("TSNeverKeyword", node, opts);
+}
+
+function assertTSThisType(node, opts = {}) {
+  assert("TSThisType", node, opts);
+}
+
+function assertTSFunctionType(node, opts = {}) {
+  assert("TSFunctionType", node, opts);
+}
+
+function assertTSConstructorType(node, opts = {}) {
+  assert("TSConstructorType", node, opts);
+}
+
+function assertTSTypeReference(node, opts = {}) {
+  assert("TSTypeReference", node, opts);
+}
+
+function assertTSTypePredicate(node, opts = {}) {
+  assert("TSTypePredicate", node, opts);
+}
+
+function assertTSTypeQuery(node, opts = {}) {
+  assert("TSTypeQuery", node, opts);
+}
+
+function assertTSTypeLiteral(node, opts = {}) {
+  assert("TSTypeLiteral", node, opts);
+}
+
+function assertTSArrayType(node, opts = {}) {
+  assert("TSArrayType", node, opts);
+}
+
+function assertTSTupleType(node, opts = {}) {
+  assert("TSTupleType", node, opts);
+}
+
+function assertTSUnionType(node, opts = {}) {
+  assert("TSUnionType", node, opts);
+}
+
+function assertTSIntersectionType(node, opts = {}) {
+  assert("TSIntersectionType", node, opts);
+}
+
+function assertTSConditionalType(node, opts = {}) {
+  assert("TSConditionalType", node, opts);
+}
+
+function assertTSInferType(node, opts = {}) {
+  assert("TSInferType", node, opts);
+}
+
+function assertTSParenthesizedType(node, opts = {}) {
+  assert("TSParenthesizedType", node, opts);
+}
+
+function assertTSTypeOperator(node, opts = {}) {
+  assert("TSTypeOperator", node, opts);
+}
+
+function assertTSIndexedAccessType(node, opts = {}) {
+  assert("TSIndexedAccessType", node, opts);
+}
+
+function assertTSMappedType(node, opts = {}) {
+  assert("TSMappedType", node, opts);
+}
+
+function assertTSLiteralType(node, opts = {}) {
+  assert("TSLiteralType", node, opts);
+}
+
+function assertTSExpressionWithTypeArguments(node, opts = {}) {
+  assert("TSExpressionWithTypeArguments", node, opts);
+}
+
+function assertTSInterfaceDeclaration(node, opts = {}) {
+  assert("TSInterfaceDeclaration", node, opts);
+}
+
+function assertTSInterfaceBody(node, opts = {}) {
+  assert("TSInterfaceBody", node, opts);
+}
+
+function assertTSTypeAliasDeclaration(node, opts = {}) {
+  assert("TSTypeAliasDeclaration", node, opts);
+}
+
+function assertTSAsExpression(node, opts = {}) {
+  assert("TSAsExpression", node, opts);
+}
+
+function assertTSTypeAssertion(node, opts = {}) {
+  assert("TSTypeAssertion", node, opts);
+}
+
+function assertTSEnumDeclaration(node, opts = {}) {
+  assert("TSEnumDeclaration", node, opts);
+}
+
+function assertTSEnumMember(node, opts = {}) {
+  assert("TSEnumMember", node, opts);
+}
+
+function assertTSModuleDeclaration(node, opts = {}) {
+  assert("TSModuleDeclaration", node, opts);
+}
+
+function assertTSModuleBlock(node, opts = {}) {
+  assert("TSModuleBlock", node, opts);
+}
+
+function assertTSImportEqualsDeclaration(node, opts = {}) {
+  assert("TSImportEqualsDeclaration", node, opts);
+}
+
+function assertTSExternalModuleReference(node, opts = {}) {
+  assert("TSExternalModuleReference", node, opts);
+}
+
+function assertTSNonNullExpression(node, opts = {}) {
+  assert("TSNonNullExpression", node, opts);
+}
+
+function assertTSExportAssignment(node, opts = {}) {
+  assert("TSExportAssignment", node, opts);
+}
+
+function assertTSNamespaceExportDeclaration(node, opts = {}) {
+  assert("TSNamespaceExportDeclaration", node, opts);
+}
+
+function assertTSTypeAnnotation(node, opts = {}) {
+  assert("TSTypeAnnotation", node, opts);
+}
+
+function assertTSTypeParameterInstantiation(node, opts = {}) {
+  assert("TSTypeParameterInstantiation", node, opts);
+}
+
+function assertTSTypeParameterDeclaration(node, opts = {}) {
+  assert("TSTypeParameterDeclaration", node, opts);
+}
+
+function assertTSTypeParameter(node, opts = {}) {
+  assert("TSTypeParameter", node, opts);
+}
+
+function assertExpression(node, opts = {}) {
+  assert("Expression", node, opts);
+}
+
+function assertBinary(node, opts = {}) {
+  assert("Binary", node, opts);
+}
+
+function assertScopable(node, opts = {}) {
+  assert("Scopable", node, opts);
+}
+
+function assertBlockParent(node, opts = {}) {
+  assert("BlockParent", node, opts);
+}
+
+function assertBlock(node, opts = {}) {
+  assert("Block", node, opts);
+}
+
+function assertStatement(node, opts = {}) {
+  assert("Statement", node, opts);
+}
+
+function assertTerminatorless(node, opts = {}) {
+  assert("Terminatorless", node, opts);
+}
+
+function assertCompletionStatement(node, opts = {}) {
+  assert("CompletionStatement", node, opts);
+}
+
+function assertConditional(node, opts = {}) {
+  assert("Conditional", node, opts);
+}
+
+function assertLoop(node, opts = {}) {
+  assert("Loop", node, opts);
+}
+
+function assertWhile(node, opts = {}) {
+  assert("While", node, opts);
+}
+
+function assertExpressionWrapper(node, opts = {}) {
+  assert("ExpressionWrapper", node, opts);
+}
+
+function assertFor(node, opts = {}) {
+  assert("For", node, opts);
+}
+
+function assertForXStatement(node, opts = {}) {
+  assert("ForXStatement", node, opts);
+}
+
+function assertFunction(node, opts = {}) {
+  assert("Function", node, opts);
+}
+
+function assertFunctionParent(node, opts = {}) {
+  assert("FunctionParent", node, opts);
+}
+
+function assertPureish(node, opts = {}) {
+  assert("Pureish", node, opts);
+}
+
+function assertDeclaration(node, opts = {}) {
+  assert("Declaration", node, opts);
+}
+
+function assertPatternLike(node, opts = {}) {
+  assert("PatternLike", node, opts);
+}
+
+function assertLVal(node, opts = {}) {
+  assert("LVal", node, opts);
+}
+
+function assertTSEntityName(node, opts = {}) {
+  assert("TSEntityName", node, opts);
+}
+
+function assertLiteral(node, opts = {}) {
+  assert("Literal", node, opts);
+}
+
+function assertImmutable(node, opts = {}) {
+  assert("Immutable", node, opts);
+}
+
+function assertUserWhitespacable(node, opts = {}) {
+  assert("UserWhitespacable", node, opts);
+}
+
+function assertMethod(node, opts = {}) {
+  assert("Method", node, opts);
+}
+
+function assertObjectMember(node, opts = {}) {
+  assert("ObjectMember", node, opts);
+}
+
+function assertProperty(node, opts = {}) {
+  assert("Property", node, opts);
+}
+
+function assertUnaryLike(node, opts = {}) {
+  assert("UnaryLike", node, opts);
+}
+
+function assertPattern(node, opts = {}) {
+  assert("Pattern", node, opts);
+}
+
+function assertClass(node, opts = {}) {
+  assert("Class", node, opts);
+}
+
+function assertModuleDeclaration(node, opts = {}) {
+  assert("ModuleDeclaration", node, opts);
+}
+
+function assertExportDeclaration(node, opts = {}) {
+  assert("ExportDeclaration", node, opts);
+}
+
+function assertModuleSpecifier(node, opts = {}) {
+  assert("ModuleSpecifier", node, opts);
+}
+
+function assertFlow(node, opts = {}) {
+  assert("Flow", node, opts);
+}
+
+function assertFlowType(node, opts = {}) {
+  assert("FlowType", node, opts);
+}
+
+function assertFlowBaseAnnotation(node, opts = {}) {
+  assert("FlowBaseAnnotation", node, opts);
+}
+
+function assertFlowDeclaration(node, opts = {}) {
+  assert("FlowDeclaration", node, opts);
+}
+
+function assertFlowPredicate(node, opts = {}) {
+  assert("FlowPredicate", node, opts);
+}
+
+function assertJSX(node, opts = {}) {
+  assert("JSX", node, opts);
+}
+
+function assertPrivate(node, opts = {}) {
+  assert("Private", node, opts);
+}
+
+function assertTSTypeElement(node, opts = {}) {
+  assert("TSTypeElement", node, opts);
+}
+
+function assertTSType(node, opts = {}) {
+  assert("TSType", node, opts);
+}
+
+function assertNumberLiteral(node, opts) {
+  console.trace("The node type NumberLiteral has been renamed to NumericLiteral");
+  assert("NumberLiteral", node, opts);
+}
+
+function assertRegexLiteral(node, opts) {
+  console.trace("The node type RegexLiteral has been renamed to RegExpLiteral");
+  assert("RegexLiteral", node, opts);
+}
+
+function assertRestProperty(node, opts) {
+  console.trace("The node type RestProperty has been renamed to RestElement");
+  assert("RestProperty", node, opts);
+}
+
+function assertSpreadProperty(node, opts) {
+  console.trace("The node type SpreadProperty has been renamed to SpreadElement");
+  assert("SpreadProperty", node, opts);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/builders/builder.js b/node_modules/@babel/types/lib/builders/builder.js
new file mode 100644
index 00000000..b6dfc107
--- /dev/null
+++ b/node_modules/@babel/types/lib/builders/builder.js
@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = builder;
+
+function _clone() {
+  const data = _interopRequireDefault(require("lodash/clone"));
+
+  _clone = function _clone() {
+    return data;
+  };
+
+  return data;
+}
+
+var _definitions = require("../definitions");
+
+var _validate = _interopRequireDefault(require("../validators/validate"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function builder(type, ...args) {
+  const keys = _definitions.BUILDER_KEYS[type];
+  const countArgs = args.length;
+
+  if (countArgs > keys.length) {
+    throw new Error(`${type}: Too many arguments passed. Received ${countArgs} but can receive no more than ${keys.length}`);
+  }
+
+  const node = {
+    type
+  };
+  let i = 0;
+  keys.forEach(key => {
+    const field = _definitions.NODE_FIELDS[type][key];
+    let arg;
+    if (i < countArgs) arg = args[i];
+    if (arg === undefined) arg = (0, _clone().default)(field.default);
+    node[key] = arg;
+    i++;
+  });
+
+  for (const key in node) {
+    (0, _validate.default)(node, key, node[key]);
+  }
+
+  return node;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js b/node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js
new file mode 100644
index 00000000..4724335f
--- /dev/null
+++ b/node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js
@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createTypeAnnotationBasedOnTypeof;
+
+var _generated = require("../generated");
+
+function createTypeAnnotationBasedOnTypeof(type) {
+  if (type === "string") {
+    return (0, _generated.stringTypeAnnotation)();
+  } else if (type === "number") {
+    return (0, _generated.numberTypeAnnotation)();
+  } else if (type === "undefined") {
+    return (0, _generated.voidTypeAnnotation)();
+  } else if (type === "boolean") {
+    return (0, _generated.booleanTypeAnnotation)();
+  } else if (type === "function") {
+    return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Function"));
+  } else if (type === "object") {
+    return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Object"));
+  } else if (type === "symbol") {
+    return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Symbol"));
+  } else {
+    throw new Error("Invalid typeof value");
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/builders/flow/createUnionTypeAnnotation.js b/node_modules/@babel/types/lib/builders/flow/createUnionTypeAnnotation.js
new file mode 100644
index 00000000..df76b010
--- /dev/null
+++ b/node_modules/@babel/types/lib/builders/flow/createUnionTypeAnnotation.js
@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createUnionTypeAnnotation;
+
+var _generated = require("../generated");
+
+var _removeTypeDuplicates = _interopRequireDefault(require("../../modifications/flow/removeTypeDuplicates"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function createUnionTypeAnnotation(types) {
+  const flattened = (0, _removeTypeDuplicates.default)(types);
+
+  if (flattened.length === 1) {
+    return flattened[0];
+  } else {
+    return (0, _generated.unionTypeAnnotation)(flattened);
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/builders/generated/index.js b/node_modules/@babel/types/lib/builders/generated/index.js
new file mode 100644
index 00000000..debed7b4
--- /dev/null
+++ b/node_modules/@babel/types/lib/builders/generated/index.js
@@ -0,0 +1,1078 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.arrayExpression = exports.ArrayExpression = ArrayExpression;
+exports.assignmentExpression = exports.AssignmentExpression = AssignmentExpression;
+exports.binaryExpression = exports.BinaryExpression = BinaryExpression;
+exports.directive = exports.Directive = Directive;
+exports.directiveLiteral = exports.DirectiveLiteral = DirectiveLiteral;
+exports.blockStatement = exports.BlockStatement = BlockStatement;
+exports.breakStatement = exports.BreakStatement = BreakStatement;
+exports.callExpression = exports.CallExpression = CallExpression;
+exports.catchClause = exports.CatchClause = CatchClause;
+exports.conditionalExpression = exports.ConditionalExpression = ConditionalExpression;
+exports.continueStatement = exports.ContinueStatement = ContinueStatement;
+exports.debuggerStatement = exports.DebuggerStatement = DebuggerStatement;
+exports.doWhileStatement = exports.DoWhileStatement = DoWhileStatement;
+exports.emptyStatement = exports.EmptyStatement = EmptyStatement;
+exports.expressionStatement = exports.ExpressionStatement = ExpressionStatement;
+exports.file = exports.File = File;
+exports.forInStatement = exports.ForInStatement = ForInStatement;
+exports.forStatement = exports.ForStatement = ForStatement;
+exports.functionDeclaration = exports.FunctionDeclaration = FunctionDeclaration;
+exports.functionExpression = exports.FunctionExpression = FunctionExpression;
+exports.identifier = exports.Identifier = Identifier;
+exports.ifStatement = exports.IfStatement = IfStatement;
+exports.labeledStatement = exports.LabeledStatement = LabeledStatement;
+exports.stringLiteral = exports.StringLiteral = StringLiteral;
+exports.numericLiteral = exports.NumericLiteral = NumericLiteral;
+exports.nullLiteral = exports.NullLiteral = NullLiteral;
+exports.booleanLiteral = exports.BooleanLiteral = BooleanLiteral;
+exports.regExpLiteral = exports.RegExpLiteral = RegExpLiteral;
+exports.logicalExpression = exports.LogicalExpression = LogicalExpression;
+exports.memberExpression = exports.MemberExpression = MemberExpression;
+exports.newExpression = exports.NewExpression = NewExpression;
+exports.program = exports.Program = Program;
+exports.objectExpression = exports.ObjectExpression = ObjectExpression;
+exports.objectMethod = exports.ObjectMethod = ObjectMethod;
+exports.objectProperty = exports.ObjectProperty = ObjectProperty;
+exports.restElement = exports.RestElement = RestElement;
+exports.returnStatement = exports.ReturnStatement = ReturnStatement;
+exports.sequenceExpression = exports.SequenceExpression = SequenceExpression;
+exports.switchCase = exports.SwitchCase = SwitchCase;
+exports.switchStatement = exports.SwitchStatement = SwitchStatement;
+exports.thisExpression = exports.ThisExpression = ThisExpression;
+exports.throwStatement = exports.ThrowStatement = ThrowStatement;
+exports.tryStatement = exports.TryStatement = TryStatement;
+exports.unaryExpression = exports.UnaryExpression = UnaryExpression;
+exports.updateExpression = exports.UpdateExpression = UpdateExpression;
+exports.variableDeclaration = exports.VariableDeclaration = VariableDeclaration;
+exports.variableDeclarator = exports.VariableDeclarator = VariableDeclarator;
+exports.whileStatement = exports.WhileStatement = WhileStatement;
+exports.withStatement = exports.WithStatement = WithStatement;
+exports.assignmentPattern = exports.AssignmentPattern = AssignmentPattern;
+exports.arrayPattern = exports.ArrayPattern = ArrayPattern;
+exports.arrowFunctionExpression = exports.ArrowFunctionExpression = ArrowFunctionExpression;
+exports.classBody = exports.ClassBody = ClassBody;
+exports.classDeclaration = exports.ClassDeclaration = ClassDeclaration;
+exports.classExpression = exports.ClassExpression = ClassExpression;
+exports.exportAllDeclaration = exports.ExportAllDeclaration = ExportAllDeclaration;
+exports.exportDefaultDeclaration = exports.ExportDefaultDeclaration = ExportDefaultDeclaration;
+exports.exportNamedDeclaration = exports.ExportNamedDeclaration = ExportNamedDeclaration;
+exports.exportSpecifier = exports.ExportSpecifier = ExportSpecifier;
+exports.forOfStatement = exports.ForOfStatement = ForOfStatement;
+exports.importDeclaration = exports.ImportDeclaration = ImportDeclaration;
+exports.importDefaultSpecifier = exports.ImportDefaultSpecifier = ImportDefaultSpecifier;
+exports.importNamespaceSpecifier = exports.ImportNamespaceSpecifier = ImportNamespaceSpecifier;
+exports.importSpecifier = exports.ImportSpecifier = ImportSpecifier;
+exports.metaProperty = exports.MetaProperty = MetaProperty;
+exports.classMethod = exports.ClassMethod = ClassMethod;
+exports.objectPattern = exports.ObjectPattern = ObjectPattern;
+exports.spreadElement = exports.SpreadElement = SpreadElement;
+exports.super = exports.Super = Super;
+exports.taggedTemplateExpression = exports.TaggedTemplateExpression = TaggedTemplateExpression;
+exports.templateElement = exports.TemplateElement = TemplateElement;
+exports.templateLiteral = exports.TemplateLiteral = TemplateLiteral;
+exports.yieldExpression = exports.YieldExpression = YieldExpression;
+exports.anyTypeAnnotation = exports.AnyTypeAnnotation = AnyTypeAnnotation;
+exports.arrayTypeAnnotation = exports.ArrayTypeAnnotation = ArrayTypeAnnotation;
+exports.booleanTypeAnnotation = exports.BooleanTypeAnnotation = BooleanTypeAnnotation;
+exports.booleanLiteralTypeAnnotation = exports.BooleanLiteralTypeAnnotation = BooleanLiteralTypeAnnotation;
+exports.nullLiteralTypeAnnotation = exports.NullLiteralTypeAnnotation = NullLiteralTypeAnnotation;
+exports.classImplements = exports.ClassImplements = ClassImplements;
+exports.declareClass = exports.DeclareClass = DeclareClass;
+exports.declareFunction = exports.DeclareFunction = DeclareFunction;
+exports.declareInterface = exports.DeclareInterface = DeclareInterface;
+exports.declareModule = exports.DeclareModule = DeclareModule;
+exports.declareModuleExports = exports.DeclareModuleExports = DeclareModuleExports;
+exports.declareTypeAlias = exports.DeclareTypeAlias = DeclareTypeAlias;
+exports.declareOpaqueType = exports.DeclareOpaqueType = DeclareOpaqueType;
+exports.declareVariable = exports.DeclareVariable = DeclareVariable;
+exports.declareExportDeclaration = exports.DeclareExportDeclaration = DeclareExportDeclaration;
+exports.declareExportAllDeclaration = exports.DeclareExportAllDeclaration = DeclareExportAllDeclaration;
+exports.declaredPredicate = exports.DeclaredPredicate = DeclaredPredicate;
+exports.existsTypeAnnotation = exports.ExistsTypeAnnotation = ExistsTypeAnnotation;
+exports.functionTypeAnnotation = exports.FunctionTypeAnnotation = FunctionTypeAnnotation;
+exports.functionTypeParam = exports.FunctionTypeParam = FunctionTypeParam;
+exports.genericTypeAnnotation = exports.GenericTypeAnnotation = GenericTypeAnnotation;
+exports.inferredPredicate = exports.InferredPredicate = InferredPredicate;
+exports.interfaceExtends = exports.InterfaceExtends = InterfaceExtends;
+exports.interfaceDeclaration = exports.InterfaceDeclaration = InterfaceDeclaration;
+exports.intersectionTypeAnnotation = exports.IntersectionTypeAnnotation = IntersectionTypeAnnotation;
+exports.mixedTypeAnnotation = exports.MixedTypeAnnotation = MixedTypeAnnotation;
+exports.emptyTypeAnnotation = exports.EmptyTypeAnnotation = EmptyTypeAnnotation;
+exports.nullableTypeAnnotation = exports.NullableTypeAnnotation = NullableTypeAnnotation;
+exports.numberLiteralTypeAnnotation = exports.NumberLiteralTypeAnnotation = NumberLiteralTypeAnnotation;
+exports.numberTypeAnnotation = exports.NumberTypeAnnotation = NumberTypeAnnotation;
+exports.objectTypeAnnotation = exports.ObjectTypeAnnotation = ObjectTypeAnnotation;
+exports.objectTypeCallProperty = exports.ObjectTypeCallProperty = ObjectTypeCallProperty;
+exports.objectTypeIndexer = exports.ObjectTypeIndexer = ObjectTypeIndexer;
+exports.objectTypeProperty = exports.ObjectTypeProperty = ObjectTypeProperty;
+exports.objectTypeSpreadProperty = exports.ObjectTypeSpreadProperty = ObjectTypeSpreadProperty;
+exports.opaqueType = exports.OpaqueType = OpaqueType;
+exports.qualifiedTypeIdentifier = exports.QualifiedTypeIdentifier = QualifiedTypeIdentifier;
+exports.stringLiteralTypeAnnotation = exports.StringLiteralTypeAnnotation = StringLiteralTypeAnnotation;
+exports.stringTypeAnnotation = exports.StringTypeAnnotation = StringTypeAnnotation;
+exports.thisTypeAnnotation = exports.ThisTypeAnnotation = ThisTypeAnnotation;
+exports.tupleTypeAnnotation = exports.TupleTypeAnnotation = TupleTypeAnnotation;
+exports.typeofTypeAnnotation = exports.TypeofTypeAnnotation = TypeofTypeAnnotation;
+exports.typeAlias = exports.TypeAlias = TypeAlias;
+exports.typeAnnotation = exports.TypeAnnotation = TypeAnnotation;
+exports.typeCastExpression = exports.TypeCastExpression = TypeCastExpression;
+exports.typeParameter = exports.TypeParameter = TypeParameter;
+exports.typeParameterDeclaration = exports.TypeParameterDeclaration = TypeParameterDeclaration;
+exports.typeParameterInstantiation = exports.TypeParameterInstantiation = TypeParameterInstantiation;
+exports.unionTypeAnnotation = exports.UnionTypeAnnotation = UnionTypeAnnotation;
+exports.variance = exports.Variance = Variance;
+exports.voidTypeAnnotation = exports.VoidTypeAnnotation = VoidTypeAnnotation;
+exports.jSXAttribute = exports.jsxAttribute = exports.JSXAttribute = JSXAttribute;
+exports.jSXClosingElement = exports.jsxClosingElement = exports.JSXClosingElement = JSXClosingElement;
+exports.jSXElement = exports.jsxElement = exports.JSXElement = JSXElement;
+exports.jSXEmptyExpression = exports.jsxEmptyExpression = exports.JSXEmptyExpression = JSXEmptyExpression;
+exports.jSXExpressionContainer = exports.jsxExpressionContainer = exports.JSXExpressionContainer = JSXExpressionContainer;
+exports.jSXSpreadChild = exports.jsxSpreadChild = exports.JSXSpreadChild = JSXSpreadChild;
+exports.jSXIdentifier = exports.jsxIdentifier = exports.JSXIdentifier = JSXIdentifier;
+exports.jSXMemberExpression = exports.jsxMemberExpression = exports.JSXMemberExpression = JSXMemberExpression;
+exports.jSXNamespacedName = exports.jsxNamespacedName = exports.JSXNamespacedName = JSXNamespacedName;
+exports.jSXOpeningElement = exports.jsxOpeningElement = exports.JSXOpeningElement = JSXOpeningElement;
+exports.jSXSpreadAttribute = exports.jsxSpreadAttribute = exports.JSXSpreadAttribute = JSXSpreadAttribute;
+exports.jSXText = exports.jsxText = exports.JSXText = JSXText;
+exports.jSXFragment = exports.jsxFragment = exports.JSXFragment = JSXFragment;
+exports.jSXOpeningFragment = exports.jsxOpeningFragment = exports.JSXOpeningFragment = JSXOpeningFragment;
+exports.jSXClosingFragment = exports.jsxClosingFragment = exports.JSXClosingFragment = JSXClosingFragment;
+exports.noop = exports.Noop = Noop;
+exports.parenthesizedExpression = exports.ParenthesizedExpression = ParenthesizedExpression;
+exports.awaitExpression = exports.AwaitExpression = AwaitExpression;
+exports.bindExpression = exports.BindExpression = BindExpression;
+exports.classProperty = exports.ClassProperty = ClassProperty;
+exports.optionalMemberExpression = exports.OptionalMemberExpression = OptionalMemberExpression;
+exports.optionalCallExpression = exports.OptionalCallExpression = OptionalCallExpression;
+exports.classPrivateProperty = exports.ClassPrivateProperty = ClassPrivateProperty;
+exports.import = exports.Import = Import;
+exports.decorator = exports.Decorator = Decorator;
+exports.doExpression = exports.DoExpression = DoExpression;
+exports.exportDefaultSpecifier = exports.ExportDefaultSpecifier = ExportDefaultSpecifier;
+exports.exportNamespaceSpecifier = exports.ExportNamespaceSpecifier = ExportNamespaceSpecifier;
+exports.privateName = exports.PrivateName = PrivateName;
+exports.tSParameterProperty = exports.tsParameterProperty = exports.TSParameterProperty = TSParameterProperty;
+exports.tSDeclareFunction = exports.tsDeclareFunction = exports.TSDeclareFunction = TSDeclareFunction;
+exports.tSDeclareMethod = exports.tsDeclareMethod = exports.TSDeclareMethod = TSDeclareMethod;
+exports.tSQualifiedName = exports.tsQualifiedName = exports.TSQualifiedName = TSQualifiedName;
+exports.tSCallSignatureDeclaration = exports.tsCallSignatureDeclaration = exports.TSCallSignatureDeclaration = TSCallSignatureDeclaration;
+exports.tSConstructSignatureDeclaration = exports.tsConstructSignatureDeclaration = exports.TSConstructSignatureDeclaration = TSConstructSignatureDeclaration;
+exports.tSPropertySignature = exports.tsPropertySignature = exports.TSPropertySignature = TSPropertySignature;
+exports.tSMethodSignature = exports.tsMethodSignature = exports.TSMethodSignature = TSMethodSignature;
+exports.tSIndexSignature = exports.tsIndexSignature = exports.TSIndexSignature = TSIndexSignature;
+exports.tSAnyKeyword = exports.tsAnyKeyword = exports.TSAnyKeyword = TSAnyKeyword;
+exports.tSNumberKeyword = exports.tsNumberKeyword = exports.TSNumberKeyword = TSNumberKeyword;
+exports.tSObjectKeyword = exports.tsObjectKeyword = exports.TSObjectKeyword = TSObjectKeyword;
+exports.tSBooleanKeyword = exports.tsBooleanKeyword = exports.TSBooleanKeyword = TSBooleanKeyword;
+exports.tSStringKeyword = exports.tsStringKeyword = exports.TSStringKeyword = TSStringKeyword;
+exports.tSSymbolKeyword = exports.tsSymbolKeyword = exports.TSSymbolKeyword = TSSymbolKeyword;
+exports.tSVoidKeyword = exports.tsVoidKeyword = exports.TSVoidKeyword = TSVoidKeyword;
+exports.tSUndefinedKeyword = exports.tsUndefinedKeyword = exports.TSUndefinedKeyword = TSUndefinedKeyword;
+exports.tSNullKeyword = exports.tsNullKeyword = exports.TSNullKeyword = TSNullKeyword;
+exports.tSNeverKeyword = exports.tsNeverKeyword = exports.TSNeverKeyword = TSNeverKeyword;
+exports.tSThisType = exports.tsThisType = exports.TSThisType = TSThisType;
+exports.tSFunctionType = exports.tsFunctionType = exports.TSFunctionType = TSFunctionType;
+exports.tSConstructorType = exports.tsConstructorType = exports.TSConstructorType = TSConstructorType;
+exports.tSTypeReference = exports.tsTypeReference = exports.TSTypeReference = TSTypeReference;
+exports.tSTypePredicate = exports.tsTypePredicate = exports.TSTypePredicate = TSTypePredicate;
+exports.tSTypeQuery = exports.tsTypeQuery = exports.TSTypeQuery = TSTypeQuery;
+exports.tSTypeLiteral = exports.tsTypeLiteral = exports.TSTypeLiteral = TSTypeLiteral;
+exports.tSArrayType = exports.tsArrayType = exports.TSArrayType = TSArrayType;
+exports.tSTupleType = exports.tsTupleType = exports.TSTupleType = TSTupleType;
+exports.tSUnionType = exports.tsUnionType = exports.TSUnionType = TSUnionType;
+exports.tSIntersectionType = exports.tsIntersectionType = exports.TSIntersectionType = TSIntersectionType;
+exports.tSConditionalType = exports.tsConditionalType = exports.TSConditionalType = TSConditionalType;
+exports.tSInferType = exports.tsInferType = exports.TSInferType = TSInferType;
+exports.tSParenthesizedType = exports.tsParenthesizedType = exports.TSParenthesizedType = TSParenthesizedType;
+exports.tSTypeOperator = exports.tsTypeOperator = exports.TSTypeOperator = TSTypeOperator;
+exports.tSIndexedAccessType = exports.tsIndexedAccessType = exports.TSIndexedAccessType = TSIndexedAccessType;
+exports.tSMappedType = exports.tsMappedType = exports.TSMappedType = TSMappedType;
+exports.tSLiteralType = exports.tsLiteralType = exports.TSLiteralType = TSLiteralType;
+exports.tSExpressionWithTypeArguments = exports.tsExpressionWithTypeArguments = exports.TSExpressionWithTypeArguments = TSExpressionWithTypeArguments;
+exports.tSInterfaceDeclaration = exports.tsInterfaceDeclaration = exports.TSInterfaceDeclaration = TSInterfaceDeclaration;
+exports.tSInterfaceBody = exports.tsInterfaceBody = exports.TSInterfaceBody = TSInterfaceBody;
+exports.tSTypeAliasDeclaration = exports.tsTypeAliasDeclaration = exports.TSTypeAliasDeclaration = TSTypeAliasDeclaration;
+exports.tSAsExpression = exports.tsAsExpression = exports.TSAsExpression = TSAsExpression;
+exports.tSTypeAssertion = exports.tsTypeAssertion = exports.TSTypeAssertion = TSTypeAssertion;
+exports.tSEnumDeclaration = exports.tsEnumDeclaration = exports.TSEnumDeclaration = TSEnumDeclaration;
+exports.tSEnumMember = exports.tsEnumMember = exports.TSEnumMember = TSEnumMember;
+exports.tSModuleDeclaration = exports.tsModuleDeclaration = exports.TSModuleDeclaration = TSModuleDeclaration;
+exports.tSModuleBlock = exports.tsModuleBlock = exports.TSModuleBlock = TSModuleBlock;
+exports.tSImportEqualsDeclaration = exports.tsImportEqualsDeclaration = exports.TSImportEqualsDeclaration = TSImportEqualsDeclaration;
+exports.tSExternalModuleReference = exports.tsExternalModuleReference = exports.TSExternalModuleReference = TSExternalModuleReference;
+exports.tSNonNullExpression = exports.tsNonNullExpression = exports.TSNonNullExpression = TSNonNullExpression;
+exports.tSExportAssignment = exports.tsExportAssignment = exports.TSExportAssignment = TSExportAssignment;
+exports.tSNamespaceExportDeclaration = exports.tsNamespaceExportDeclaration = exports.TSNamespaceExportDeclaration = TSNamespaceExportDeclaration;
+exports.tSTypeAnnotation = exports.tsTypeAnnotation = exports.TSTypeAnnotation = TSTypeAnnotation;
+exports.tSTypeParameterInstantiation = exports.tsTypeParameterInstantiation = exports.TSTypeParameterInstantiation = TSTypeParameterInstantiation;
+exports.tSTypeParameterDeclaration = exports.tsTypeParameterDeclaration = exports.TSTypeParameterDeclaration = TSTypeParameterDeclaration;
+exports.tSTypeParameter = exports.tsTypeParameter = exports.TSTypeParameter = TSTypeParameter;
+exports.numberLiteral = exports.NumberLiteral = NumberLiteral;
+exports.regexLiteral = exports.RegexLiteral = RegexLiteral;
+exports.restProperty = exports.RestProperty = RestProperty;
+exports.spreadProperty = exports.SpreadProperty = SpreadProperty;
+
+var _builder = _interopRequireDefault(require("../builder"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ArrayExpression(...args) {
+  return (0, _builder.default)("ArrayExpression", ...args);
+}
+
+function AssignmentExpression(...args) {
+  return (0, _builder.default)("AssignmentExpression", ...args);
+}
+
+function BinaryExpression(...args) {
+  return (0, _builder.default)("BinaryExpression", ...args);
+}
+
+function Directive(...args) {
+  return (0, _builder.default)("Directive", ...args);
+}
+
+function DirectiveLiteral(...args) {
+  return (0, _builder.default)("DirectiveLiteral", ...args);
+}
+
+function BlockStatement(...args) {
+  return (0, _builder.default)("BlockStatement", ...args);
+}
+
+function BreakStatement(...args) {
+  return (0, _builder.default)("BreakStatement", ...args);
+}
+
+function CallExpression(...args) {
+  return (0, _builder.default)("CallExpression", ...args);
+}
+
+function CatchClause(...args) {
+  return (0, _builder.default)("CatchClause", ...args);
+}
+
+function ConditionalExpression(...args) {
+  return (0, _builder.default)("ConditionalExpression", ...args);
+}
+
+function ContinueStatement(...args) {
+  return (0, _builder.default)("ContinueStatement", ...args);
+}
+
+function DebuggerStatement(...args) {
+  return (0, _builder.default)("DebuggerStatement", ...args);
+}
+
+function DoWhileStatement(...args) {
+  return (0, _builder.default)("DoWhileStatement", ...args);
+}
+
+function EmptyStatement(...args) {
+  return (0, _builder.default)("EmptyStatement", ...args);
+}
+
+function ExpressionStatement(...args) {
+  return (0, _builder.default)("ExpressionStatement", ...args);
+}
+
+function File(...args) {
+  return (0, _builder.default)("File", ...args);
+}
+
+function ForInStatement(...args) {
+  return (0, _builder.default)("ForInStatement", ...args);
+}
+
+function ForStatement(...args) {
+  return (0, _builder.default)("ForStatement", ...args);
+}
+
+function FunctionDeclaration(...args) {
+  return (0, _builder.default)("FunctionDeclaration", ...args);
+}
+
+function FunctionExpression(...args) {
+  return (0, _builder.default)("FunctionExpression", ...args);
+}
+
+function Identifier(...args) {
+  return (0, _builder.default)("Identifier", ...args);
+}
+
+function IfStatement(...args) {
+  return (0, _builder.default)("IfStatement", ...args);
+}
+
+function LabeledStatement(...args) {
+  return (0, _builder.default)("LabeledStatement", ...args);
+}
+
+function StringLiteral(...args) {
+  return (0, _builder.default)("StringLiteral", ...args);
+}
+
+function NumericLiteral(...args) {
+  return (0, _builder.default)("NumericLiteral", ...args);
+}
+
+function NullLiteral(...args) {
+  return (0, _builder.default)("NullLiteral", ...args);
+}
+
+function BooleanLiteral(...args) {
+  return (0, _builder.default)("BooleanLiteral", ...args);
+}
+
+function RegExpLiteral(...args) {
+  return (0, _builder.default)("RegExpLiteral", ...args);
+}
+
+function LogicalExpression(...args) {
+  return (0, _builder.default)("LogicalExpression", ...args);
+}
+
+function MemberExpression(...args) {
+  return (0, _builder.default)("MemberExpression", ...args);
+}
+
+function NewExpression(...args) {
+  return (0, _builder.default)("NewExpression", ...args);
+}
+
+function Program(...args) {
+  return (0, _builder.default)("Program", ...args);
+}
+
+function ObjectExpression(...args) {
+  return (0, _builder.default)("ObjectExpression", ...args);
+}
+
+function ObjectMethod(...args) {
+  return (0, _builder.default)("ObjectMethod", ...args);
+}
+
+function ObjectProperty(...args) {
+  return (0, _builder.default)("ObjectProperty", ...args);
+}
+
+function RestElement(...args) {
+  return (0, _builder.default)("RestElement", ...args);
+}
+
+function ReturnStatement(...args) {
+  return (0, _builder.default)("ReturnStatement", ...args);
+}
+
+function SequenceExpression(...args) {
+  return (0, _builder.default)("SequenceExpression", ...args);
+}
+
+function SwitchCase(...args) {
+  return (0, _builder.default)("SwitchCase", ...args);
+}
+
+function SwitchStatement(...args) {
+  return (0, _builder.default)("SwitchStatement", ...args);
+}
+
+function ThisExpression(...args) {
+  return (0, _builder.default)("ThisExpression", ...args);
+}
+
+function ThrowStatement(...args) {
+  return (0, _builder.default)("ThrowStatement", ...args);
+}
+
+function TryStatement(...args) {
+  return (0, _builder.default)("TryStatement", ...args);
+}
+
+function UnaryExpression(...args) {
+  return (0, _builder.default)("UnaryExpression", ...args);
+}
+
+function UpdateExpression(...args) {
+  return (0, _builder.default)("UpdateExpression", ...args);
+}
+
+function VariableDeclaration(...args) {
+  return (0, _builder.default)("VariableDeclaration", ...args);
+}
+
+function VariableDeclarator(...args) {
+  return (0, _builder.default)("VariableDeclarator", ...args);
+}
+
+function WhileStatement(...args) {
+  return (0, _builder.default)("WhileStatement", ...args);
+}
+
+function WithStatement(...args) {
+  return (0, _builder.default)("WithStatement", ...args);
+}
+
+function AssignmentPattern(...args) {
+  return (0, _builder.default)("AssignmentPattern", ...args);
+}
+
+function ArrayPattern(...args) {
+  return (0, _builder.default)("ArrayPattern", ...args);
+}
+
+function ArrowFunctionExpression(...args) {
+  return (0, _builder.default)("ArrowFunctionExpression", ...args);
+}
+
+function ClassBody(...args) {
+  return (0, _builder.default)("ClassBody", ...args);
+}
+
+function ClassDeclaration(...args) {
+  return (0, _builder.default)("ClassDeclaration", ...args);
+}
+
+function ClassExpression(...args) {
+  return (0, _builder.default)("ClassExpression", ...args);
+}
+
+function ExportAllDeclaration(...args) {
+  return (0, _builder.default)("ExportAllDeclaration", ...args);
+}
+
+function ExportDefaultDeclaration(...args) {
+  return (0, _builder.default)("ExportDefaultDeclaration", ...args);
+}
+
+function ExportNamedDeclaration(...args) {
+  return (0, _builder.default)("ExportNamedDeclaration", ...args);
+}
+
+function ExportSpecifier(...args) {
+  return (0, _builder.default)("ExportSpecifier", ...args);
+}
+
+function ForOfStatement(...args) {
+  return (0, _builder.default)("ForOfStatement", ...args);
+}
+
+function ImportDeclaration(...args) {
+  return (0, _builder.default)("ImportDeclaration", ...args);
+}
+
+function ImportDefaultSpecifier(...args) {
+  return (0, _builder.default)("ImportDefaultSpecifier", ...args);
+}
+
+function ImportNamespaceSpecifier(...args) {
+  return (0, _builder.default)("ImportNamespaceSpecifier", ...args);
+}
+
+function ImportSpecifier(...args) {
+  return (0, _builder.default)("ImportSpecifier", ...args);
+}
+
+function MetaProperty(...args) {
+  return (0, _builder.default)("MetaProperty", ...args);
+}
+
+function ClassMethod(...args) {
+  return (0, _builder.default)("ClassMethod", ...args);
+}
+
+function ObjectPattern(...args) {
+  return (0, _builder.default)("ObjectPattern", ...args);
+}
+
+function SpreadElement(...args) {
+  return (0, _builder.default)("SpreadElement", ...args);
+}
+
+function Super(...args) {
+  return (0, _builder.default)("Super", ...args);
+}
+
+function TaggedTemplateExpression(...args) {
+  return (0, _builder.default)("TaggedTemplateExpression", ...args);
+}
+
+function TemplateElement(...args) {
+  return (0, _builder.default)("TemplateElement", ...args);
+}
+
+function TemplateLiteral(...args) {
+  return (0, _builder.default)("TemplateLiteral", ...args);
+}
+
+function YieldExpression(...args) {
+  return (0, _builder.default)("YieldExpression", ...args);
+}
+
+function AnyTypeAnnotation(...args) {
+  return (0, _builder.default)("AnyTypeAnnotation", ...args);
+}
+
+function ArrayTypeAnnotation(...args) {
+  return (0, _builder.default)("ArrayTypeAnnotation", ...args);
+}
+
+function BooleanTypeAnnotation(...args) {
+  return (0, _builder.default)("BooleanTypeAnnotation", ...args);
+}
+
+function BooleanLiteralTypeAnnotation(...args) {
+  return (0, _builder.default)("BooleanLiteralTypeAnnotation", ...args);
+}
+
+function NullLiteralTypeAnnotation(...args) {
+  return (0, _builder.default)("NullLiteralTypeAnnotation", ...args);
+}
+
+function ClassImplements(...args) {
+  return (0, _builder.default)("ClassImplements", ...args);
+}
+
+function DeclareClass(...args) {
+  return (0, _builder.default)("DeclareClass", ...args);
+}
+
+function DeclareFunction(...args) {
+  return (0, _builder.default)("DeclareFunction", ...args);
+}
+
+function DeclareInterface(...args) {
+  return (0, _builder.default)("DeclareInterface", ...args);
+}
+
+function DeclareModule(...args) {
+  return (0, _builder.default)("DeclareModule", ...args);
+}
+
+function DeclareModuleExports(...args) {
+  return (0, _builder.default)("DeclareModuleExports", ...args);
+}
+
+function DeclareTypeAlias(...args) {
+  return (0, _builder.default)("DeclareTypeAlias", ...args);
+}
+
+function DeclareOpaqueType(...args) {
+  return (0, _builder.default)("DeclareOpaqueType", ...args);
+}
+
+function DeclareVariable(...args) {
+  return (0, _builder.default)("DeclareVariable", ...args);
+}
+
+function DeclareExportDeclaration(...args) {
+  return (0, _builder.default)("DeclareExportDeclaration", ...args);
+}
+
+function DeclareExportAllDeclaration(...args) {
+  return (0, _builder.default)("DeclareExportAllDeclaration", ...args);
+}
+
+function DeclaredPredicate(...args) {
+  return (0, _builder.default)("DeclaredPredicate", ...args);
+}
+
+function ExistsTypeAnnotation(...args) {
+  return (0, _builder.default)("ExistsTypeAnnotation", ...args);
+}
+
+function FunctionTypeAnnotation(...args) {
+  return (0, _builder.default)("FunctionTypeAnnotation", ...args);
+}
+
+function FunctionTypeParam(...args) {
+  return (0, _builder.default)("FunctionTypeParam", ...args);
+}
+
+function GenericTypeAnnotation(...args) {
+  return (0, _builder.default)("GenericTypeAnnotation", ...args);
+}
+
+function InferredPredicate(...args) {
+  return (0, _builder.default)("InferredPredicate", ...args);
+}
+
+function InterfaceExtends(...args) {
+  return (0, _builder.default)("InterfaceExtends", ...args);
+}
+
+function InterfaceDeclaration(...args) {
+  return (0, _builder.default)("InterfaceDeclaration", ...args);
+}
+
+function IntersectionTypeAnnotation(...args) {
+  return (0, _builder.default)("IntersectionTypeAnnotation", ...args);
+}
+
+function MixedTypeAnnotation(...args) {
+  return (0, _builder.default)("MixedTypeAnnotation", ...args);
+}
+
+function EmptyTypeAnnotation(...args) {
+  return (0, _builder.default)("EmptyTypeAnnotation", ...args);
+}
+
+function NullableTypeAnnotation(...args) {
+  return (0, _builder.default)("NullableTypeAnnotation", ...args);
+}
+
+function NumberLiteralTypeAnnotation(...args) {
+  return (0, _builder.default)("NumberLiteralTypeAnnotation", ...args);
+}
+
+function NumberTypeAnnotation(...args) {
+  return (0, _builder.default)("NumberTypeAnnotation", ...args);
+}
+
+function ObjectTypeAnnotation(...args) {
+  return (0, _builder.default)("ObjectTypeAnnotation", ...args);
+}
+
+function ObjectTypeCallProperty(...args) {
+  return (0, _builder.default)("ObjectTypeCallProperty", ...args);
+}
+
+function ObjectTypeIndexer(...args) {
+  return (0, _builder.default)("ObjectTypeIndexer", ...args);
+}
+
+function ObjectTypeProperty(...args) {
+  return (0, _builder.default)("ObjectTypeProperty", ...args);
+}
+
+function ObjectTypeSpreadProperty(...args) {
+  return (0, _builder.default)("ObjectTypeSpreadProperty", ...args);
+}
+
+function OpaqueType(...args) {
+  return (0, _builder.default)("OpaqueType", ...args);
+}
+
+function QualifiedTypeIdentifier(...args) {
+  return (0, _builder.default)("QualifiedTypeIdentifier", ...args);
+}
+
+function StringLiteralTypeAnnotation(...args) {
+  return (0, _builder.default)("StringLiteralTypeAnnotation", ...args);
+}
+
+function StringTypeAnnotation(...args) {
+  return (0, _builder.default)("StringTypeAnnotation", ...args);
+}
+
+function ThisTypeAnnotation(...args) {
+  return (0, _builder.default)("ThisTypeAnnotation", ...args);
+}
+
+function TupleTypeAnnotation(...args) {
+  return (0, _builder.default)("TupleTypeAnnotation", ...args);
+}
+
+function TypeofTypeAnnotation(...args) {
+  return (0, _builder.default)("TypeofTypeAnnotation", ...args);
+}
+
+function TypeAlias(...args) {
+  return (0, _builder.default)("TypeAlias", ...args);
+}
+
+function TypeAnnotation(...args) {
+  return (0, _builder.default)("TypeAnnotation", ...args);
+}
+
+function TypeCastExpression(...args) {
+  return (0, _builder.default)("TypeCastExpression", ...args);
+}
+
+function TypeParameter(...args) {
+  return (0, _builder.default)("TypeParameter", ...args);
+}
+
+function TypeParameterDeclaration(...args) {
+  return (0, _builder.default)("TypeParameterDeclaration", ...args);
+}
+
+function TypeParameterInstantiation(...args) {
+  return (0, _builder.default)("TypeParameterInstantiation", ...args);
+}
+
+function UnionTypeAnnotation(...args) {
+  return (0, _builder.default)("UnionTypeAnnotation", ...args);
+}
+
+function Variance(...args) {
+  return (0, _builder.default)("Variance", ...args);
+}
+
+function VoidTypeAnnotation(...args) {
+  return (0, _builder.default)("VoidTypeAnnotation", ...args);
+}
+
+function JSXAttribute(...args) {
+  return (0, _builder.default)("JSXAttribute", ...args);
+}
+
+function JSXClosingElement(...args) {
+  return (0, _builder.default)("JSXClosingElement", ...args);
+}
+
+function JSXElement(...args) {
+  return (0, _builder.default)("JSXElement", ...args);
+}
+
+function JSXEmptyExpression(...args) {
+  return (0, _builder.default)("JSXEmptyExpression", ...args);
+}
+
+function JSXExpressionContainer(...args) {
+  return (0, _builder.default)("JSXExpressionContainer", ...args);
+}
+
+function JSXSpreadChild(...args) {
+  return (0, _builder.default)("JSXSpreadChild", ...args);
+}
+
+function JSXIdentifier(...args) {
+  return (0, _builder.default)("JSXIdentifier", ...args);
+}
+
+function JSXMemberExpression(...args) {
+  return (0, _builder.default)("JSXMemberExpression", ...args);
+}
+
+function JSXNamespacedName(...args) {
+  return (0, _builder.default)("JSXNamespacedName", ...args);
+}
+
+function JSXOpeningElement(...args) {
+  return (0, _builder.default)("JSXOpeningElement", ...args);
+}
+
+function JSXSpreadAttribute(...args) {
+  return (0, _builder.default)("JSXSpreadAttribute", ...args);
+}
+
+function JSXText(...args) {
+  return (0, _builder.default)("JSXText", ...args);
+}
+
+function JSXFragment(...args) {
+  return (0, _builder.default)("JSXFragment", ...args);
+}
+
+function JSXOpeningFragment(...args) {
+  return (0, _builder.default)("JSXOpeningFragment", ...args);
+}
+
+function JSXClosingFragment(...args) {
+  return (0, _builder.default)("JSXClosingFragment", ...args);
+}
+
+function Noop(...args) {
+  return (0, _builder.default)("Noop", ...args);
+}
+
+function ParenthesizedExpression(...args) {
+  return (0, _builder.default)("ParenthesizedExpression", ...args);
+}
+
+function AwaitExpression(...args) {
+  return (0, _builder.default)("AwaitExpression", ...args);
+}
+
+function BindExpression(...args) {
+  return (0, _builder.default)("BindExpression", ...args);
+}
+
+function ClassProperty(...args) {
+  return (0, _builder.default)("ClassProperty", ...args);
+}
+
+function OptionalMemberExpression(...args) {
+  return (0, _builder.default)("OptionalMemberExpression", ...args);
+}
+
+function OptionalCallExpression(...args) {
+  return (0, _builder.default)("OptionalCallExpression", ...args);
+}
+
+function ClassPrivateProperty(...args) {
+  return (0, _builder.default)("ClassPrivateProperty", ...args);
+}
+
+function Import(...args) {
+  return (0, _builder.default)("Import", ...args);
+}
+
+function Decorator(...args) {
+  return (0, _builder.default)("Decorator", ...args);
+}
+
+function DoExpression(...args) {
+  return (0, _builder.default)("DoExpression", ...args);
+}
+
+function ExportDefaultSpecifier(...args) {
+  return (0, _builder.default)("ExportDefaultSpecifier", ...args);
+}
+
+function ExportNamespaceSpecifier(...args) {
+  return (0, _builder.default)("ExportNamespaceSpecifier", ...args);
+}
+
+function PrivateName(...args) {
+  return (0, _builder.default)("PrivateName", ...args);
+}
+
+function TSParameterProperty(...args) {
+  return (0, _builder.default)("TSParameterProperty", ...args);
+}
+
+function TSDeclareFunction(...args) {
+  return (0, _builder.default)("TSDeclareFunction", ...args);
+}
+
+function TSDeclareMethod(...args) {
+  return (0, _builder.default)("TSDeclareMethod", ...args);
+}
+
+function TSQualifiedName(...args) {
+  return (0, _builder.default)("TSQualifiedName", ...args);
+}
+
+function TSCallSignatureDeclaration(...args) {
+  return (0, _builder.default)("TSCallSignatureDeclaration", ...args);
+}
+
+function TSConstructSignatureDeclaration(...args) {
+  return (0, _builder.default)("TSConstructSignatureDeclaration", ...args);
+}
+
+function TSPropertySignature(...args) {
+  return (0, _builder.default)("TSPropertySignature", ...args);
+}
+
+function TSMethodSignature(...args) {
+  return (0, _builder.default)("TSMethodSignature", ...args);
+}
+
+function TSIndexSignature(...args) {
+  return (0, _builder.default)("TSIndexSignature", ...args);
+}
+
+function TSAnyKeyword(...args) {
+  return (0, _builder.default)("TSAnyKeyword", ...args);
+}
+
+function TSNumberKeyword(...args) {
+  return (0, _builder.default)("TSNumberKeyword", ...args);
+}
+
+function TSObjectKeyword(...args) {
+  return (0, _builder.default)("TSObjectKeyword", ...args);
+}
+
+function TSBooleanKeyword(...args) {
+  return (0, _builder.default)("TSBooleanKeyword", ...args);
+}
+
+function TSStringKeyword(...args) {
+  return (0, _builder.default)("TSStringKeyword", ...args);
+}
+
+function TSSymbolKeyword(...args) {
+  return (0, _builder.default)("TSSymbolKeyword", ...args);
+}
+
+function TSVoidKeyword(...args) {
+  return (0, _builder.default)("TSVoidKeyword", ...args);
+}
+
+function TSUndefinedKeyword(...args) {
+  return (0, _builder.default)("TSUndefinedKeyword", ...args);
+}
+
+function TSNullKeyword(...args) {
+  return (0, _builder.default)("TSNullKeyword", ...args);
+}
+
+function TSNeverKeyword(...args) {
+  return (0, _builder.default)("TSNeverKeyword", ...args);
+}
+
+function TSThisType(...args) {
+  return (0, _builder.default)("TSThisType", ...args);
+}
+
+function TSFunctionType(...args) {
+  return (0, _builder.default)("TSFunctionType", ...args);
+}
+
+function TSConstructorType(...args) {
+  return (0, _builder.default)("TSConstructorType", ...args);
+}
+
+function TSTypeReference(...args) {
+  return (0, _builder.default)("TSTypeReference", ...args);
+}
+
+function TSTypePredicate(...args) {
+  return (0, _builder.default)("TSTypePredicate", ...args);
+}
+
+function TSTypeQuery(...args) {
+  return (0, _builder.default)("TSTypeQuery", ...args);
+}
+
+function TSTypeLiteral(...args) {
+  return (0, _builder.default)("TSTypeLiteral", ...args);
+}
+
+function TSArrayType(...args) {
+  return (0, _builder.default)("TSArrayType", ...args);
+}
+
+function TSTupleType(...args) {
+  return (0, _builder.default)("TSTupleType", ...args);
+}
+
+function TSUnionType(...args) {
+  return (0, _builder.default)("TSUnionType", ...args);
+}
+
+function TSIntersectionType(...args) {
+  return (0, _builder.default)("TSIntersectionType", ...args);
+}
+
+function TSConditionalType(...args) {
+  return (0, _builder.default)("TSConditionalType", ...args);
+}
+
+function TSInferType(...args) {
+  return (0, _builder.default)("TSInferType", ...args);
+}
+
+function TSParenthesizedType(...args) {
+  return (0, _builder.default)("TSParenthesizedType", ...args);
+}
+
+function TSTypeOperator(...args) {
+  return (0, _builder.default)("TSTypeOperator", ...args);
+}
+
+function TSIndexedAccessType(...args) {
+  return (0, _builder.default)("TSIndexedAccessType", ...args);
+}
+
+function TSMappedType(...args) {
+  return (0, _builder.default)("TSMappedType", ...args);
+}
+
+function TSLiteralType(...args) {
+  return (0, _builder.default)("TSLiteralType", ...args);
+}
+
+function TSExpressionWithTypeArguments(...args) {
+  return (0, _builder.default)("TSExpressionWithTypeArguments", ...args);
+}
+
+function TSInterfaceDeclaration(...args) {
+  return (0, _builder.default)("TSInterfaceDeclaration", ...args);
+}
+
+function TSInterfaceBody(...args) {
+  return (0, _builder.default)("TSInterfaceBody", ...args);
+}
+
+function TSTypeAliasDeclaration(...args) {
+  return (0, _builder.default)("TSTypeAliasDeclaration", ...args);
+}
+
+function TSAsExpression(...args) {
+  return (0, _builder.default)("TSAsExpression", ...args);
+}
+
+function TSTypeAssertion(...args) {
+  return (0, _builder.default)("TSTypeAssertion", ...args);
+}
+
+function TSEnumDeclaration(...args) {
+  return (0, _builder.default)("TSEnumDeclaration", ...args);
+}
+
+function TSEnumMember(...args) {
+  return (0, _builder.default)("TSEnumMember", ...args);
+}
+
+function TSModuleDeclaration(...args) {
+  return (0, _builder.default)("TSModuleDeclaration", ...args);
+}
+
+function TSModuleBlock(...args) {
+  return (0, _builder.default)("TSModuleBlock", ...args);
+}
+
+function TSImportEqualsDeclaration(...args) {
+  return (0, _builder.default)("TSImportEqualsDeclaration", ...args);
+}
+
+function TSExternalModuleReference(...args) {
+  return (0, _builder.default)("TSExternalModuleReference", ...args);
+}
+
+function TSNonNullExpression(...args) {
+  return (0, _builder.default)("TSNonNullExpression", ...args);
+}
+
+function TSExportAssignment(...args) {
+  return (0, _builder.default)("TSExportAssignment", ...args);
+}
+
+function TSNamespaceExportDeclaration(...args) {
+  return (0, _builder.default)("TSNamespaceExportDeclaration", ...args);
+}
+
+function TSTypeAnnotation(...args) {
+  return (0, _builder.default)("TSTypeAnnotation", ...args);
+}
+
+function TSTypeParameterInstantiation(...args) {
+  return (0, _builder.default)("TSTypeParameterInstantiation", ...args);
+}
+
+function TSTypeParameterDeclaration(...args) {
+  return (0, _builder.default)("TSTypeParameterDeclaration", ...args);
+}
+
+function TSTypeParameter(...args) {
+  return (0, _builder.default)("TSTypeParameter", ...args);
+}
+
+function NumberLiteral(...args) {
+  console.trace("The node type NumberLiteral has been renamed to NumericLiteral");
+  return NumberLiteral("NumberLiteral", ...args);
+}
+
+function RegexLiteral(...args) {
+  console.trace("The node type RegexLiteral has been renamed to RegExpLiteral");
+  return RegexLiteral("RegexLiteral", ...args);
+}
+
+function RestProperty(...args) {
+  console.trace("The node type RestProperty has been renamed to RestElement");
+  return RestProperty("RestProperty", ...args);
+}
+
+function SpreadProperty(...args) {
+  console.trace("The node type SpreadProperty has been renamed to SpreadElement");
+  return SpreadProperty("SpreadProperty", ...args);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/builders/react/buildChildren.js b/node_modules/@babel/types/lib/builders/react/buildChildren.js
new file mode 100644
index 00000000..91e7cbd9
--- /dev/null
+++ b/node_modules/@babel/types/lib/builders/react/buildChildren.js
@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = buildChildren;
+
+var _generated = require("../../validators/generated");
+
+var _cleanJSXElementLiteralChild = _interopRequireDefault(require("../../utils/react/cleanJSXElementLiteralChild"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function buildChildren(node) {
+  const elements = [];
+
+  for (let i = 0; i < node.children.length; i++) {
+    let child = node.children[i];
+
+    if ((0, _generated.isJSXText)(child)) {
+      (0, _cleanJSXElementLiteralChild.default)(child, elements);
+      continue;
+    }
+
+    if ((0, _generated.isJSXExpressionContainer)(child)) child = child.expression;
+    if ((0, _generated.isJSXEmptyExpression)(child)) continue;
+    elements.push(child);
+  }
+
+  return elements;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/clone/clone.js b/node_modules/@babel/types/lib/clone/clone.js
new file mode 100644
index 00000000..9595f6e2
--- /dev/null
+++ b/node_modules/@babel/types/lib/clone/clone.js
@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = clone;
+
+var _cloneNode = _interopRequireDefault(require("./cloneNode"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function clone(node) {
+  return (0, _cloneNode.default)(node, false);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/clone/cloneDeep.js b/node_modules/@babel/types/lib/clone/cloneDeep.js
new file mode 100644
index 00000000..eb29c536
--- /dev/null
+++ b/node_modules/@babel/types/lib/clone/cloneDeep.js
@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = cloneDeep;
+
+var _cloneNode = _interopRequireDefault(require("./cloneNode"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function cloneDeep(node) {
+  return (0, _cloneNode.default)(node);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/clone/cloneNode.js b/node_modules/@babel/types/lib/clone/cloneNode.js
new file mode 100644
index 00000000..cd1dc59e
--- /dev/null
+++ b/node_modules/@babel/types/lib/clone/cloneNode.js
@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = cloneNode;
+
+var _definitions = require("../definitions");
+
+const has = Function.call.bind(Object.prototype.hasOwnProperty);
+
+function cloneIfNode(obj, deep) {
+  if (obj && typeof obj.type === "string" && obj.type !== "CommentLine" && obj.type !== "CommentBlock") {
+    return cloneNode(obj, deep);
+  }
+
+  return obj;
+}
+
+function cloneIfNodeOrArray(obj, deep) {
+  if (Array.isArray(obj)) {
+    return obj.map(node => cloneIfNode(node, deep));
+  }
+
+  return cloneIfNode(obj, deep);
+}
+
+function cloneNode(node, deep = true) {
+  if (!node) return node;
+  const type = node.type;
+  const newNode = {
+    type
+  };
+
+  if (type === "Identifier") {
+    newNode.name = node.name;
+  } else if (!has(_definitions.NODE_FIELDS, type)) {
+    throw new Error(`Unknown node type: "${type}"`);
+  } else {
+    var _arr = Object.keys(_definitions.NODE_FIELDS[type]);
+
+    for (var _i = 0; _i < _arr.length; _i++) {
+      const field = _arr[_i];
+
+      if (has(node, field)) {
+        newNode[field] = deep ? cloneIfNodeOrArray(node[field], true) : node[field];
+      }
+    }
+  }
+
+  if (has(node, "loc")) {
+    newNode.loc = node.loc;
+  }
+
+  if (has(node, "leadingComments")) {
+    newNode.leadingComments = node.leadingComments;
+  }
+
+  if (has(node, "innerComments")) {
+    newNode.innerComments = node.innerCmments;
+  }
+
+  if (has(node, "trailingComments")) {
+    newNode.trailingComments = node.trailingComments;
+  }
+
+  if (has(node, "extra")) {
+    newNode.extra = Object.assign({}, node.extra);
+  }
+
+  return newNode;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/clone/cloneWithoutLoc.js b/node_modules/@babel/types/lib/clone/cloneWithoutLoc.js
new file mode 100644
index 00000000..5622af7b
--- /dev/null
+++ b/node_modules/@babel/types/lib/clone/cloneWithoutLoc.js
@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = cloneWithoutLoc;
+
+var _clone = _interopRequireDefault(require("./clone"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function cloneWithoutLoc(node) {
+  const newNode = (0, _clone.default)(node);
+  newNode.loc = null;
+  return newNode;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/comments/addComment.js b/node_modules/@babel/types/lib/comments/addComment.js
new file mode 100644
index 00000000..ff586514
--- /dev/null
+++ b/node_modules/@babel/types/lib/comments/addComment.js
@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = addComment;
+
+var _addComments = _interopRequireDefault(require("./addComments"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function addComment(node, type, content, line) {
+  return (0, _addComments.default)(node, type, [{
+    type: line ? "CommentLine" : "CommentBlock",
+    value: content
+  }]);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/comments/addComments.js b/node_modules/@babel/types/lib/comments/addComments.js
new file mode 100644
index 00000000..f3a61df7
--- /dev/null
+++ b/node_modules/@babel/types/lib/comments/addComments.js
@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = addComments;
+
+function addComments(node, type, comments) {
+  if (!comments || !node) return node;
+  const key = `${type}Comments`;
+
+  if (node[key]) {
+    if (type === "leading") {
+      node[key] = comments.concat(node[key]);
+    } else {
+      node[key] = node[key].concat(comments);
+    }
+  } else {
+    node[key] = comments;
+  }
+
+  return node;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/comments/inheritInnerComments.js b/node_modules/@babel/types/lib/comments/inheritInnerComments.js
new file mode 100644
index 00000000..fbe59dec
--- /dev/null
+++ b/node_modules/@babel/types/lib/comments/inheritInnerComments.js
@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = inheritInnerComments;
+
+var _inherit = _interopRequireDefault(require("../utils/inherit"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function inheritInnerComments(child, parent) {
+  (0, _inherit.default)("innerComments", child, parent);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/comments/inheritLeadingComments.js b/node_modules/@babel/types/lib/comments/inheritLeadingComments.js
new file mode 100644
index 00000000..ccb02ec5
--- /dev/null
+++ b/node_modules/@babel/types/lib/comments/inheritLeadingComments.js
@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = inheritLeadingComments;
+
+var _inherit = _interopRequireDefault(require("../utils/inherit"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function inheritLeadingComments(child, parent) {
+  (0, _inherit.default)("leadingComments", child, parent);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/comments/inheritTrailingComments.js b/node_modules/@babel/types/lib/comments/inheritTrailingComments.js
new file mode 100644
index 00000000..bce1e2d9
--- /dev/null
+++ b/node_modules/@babel/types/lib/comments/inheritTrailingComments.js
@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = inheritTrailingComments;
+
+var _inherit = _interopRequireDefault(require("../utils/inherit"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function inheritTrailingComments(child, parent) {
+  (0, _inherit.default)("trailingComments", child, parent);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/comments/inheritsComments.js b/node_modules/@babel/types/lib/comments/inheritsComments.js
new file mode 100644
index 00000000..fd942d86
--- /dev/null
+++ b/node_modules/@babel/types/lib/comments/inheritsComments.js
@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = inheritsComments;
+
+var _inheritTrailingComments = _interopRequireDefault(require("./inheritTrailingComments"));
+
+var _inheritLeadingComments = _interopRequireDefault(require("./inheritLeadingComments"));
+
+var _inheritInnerComments = _interopRequireDefault(require("./inheritInnerComments"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function inheritsComments(child, parent) {
+  (0, _inheritTrailingComments.default)(child, parent);
+  (0, _inheritLeadingComments.default)(child, parent);
+  (0, _inheritInnerComments.default)(child, parent);
+  return child;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/comments/removeComments.js b/node_modules/@babel/types/lib/comments/removeComments.js
new file mode 100644
index 00000000..fe34f1a8
--- /dev/null
+++ b/node_modules/@babel/types/lib/comments/removeComments.js
@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = removeComments;
+
+var _constants = require("../constants");
+
+function removeComments(node) {
+  _constants.COMMENT_KEYS.forEach(key => {
+    node[key] = null;
+  });
+
+  return node;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/constants/generated/index.js b/node_modules/@babel/types/lib/constants/generated/index.js
new file mode 100644
index 00000000..6072495e
--- /dev/null
+++ b/node_modules/@babel/types/lib/constants/generated/index.js
@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TSTYPE_TYPES = exports.TSTYPEELEMENT_TYPES = exports.PRIVATE_TYPES = exports.JSX_TYPES = exports.FLOWPREDICATE_TYPES = exports.FLOWDECLARATION_TYPES = exports.FLOWBASEANNOTATION_TYPES = exports.FLOWTYPE_TYPES = exports.FLOW_TYPES = exports.MODULESPECIFIER_TYPES = exports.EXPORTDECLARATION_TYPES = exports.MODULEDECLARATION_TYPES = exports.CLASS_TYPES = exports.PATTERN_TYPES = exports.UNARYLIKE_TYPES = exports.PROPERTY_TYPES = exports.OBJECTMEMBER_TYPES = exports.METHOD_TYPES = exports.USERWHITESPACABLE_TYPES = exports.IMMUTABLE_TYPES = exports.LITERAL_TYPES = exports.TSENTITYNAME_TYPES = exports.LVAL_TYPES = exports.PATTERNLIKE_TYPES = exports.DECLARATION_TYPES = exports.PUREISH_TYPES = exports.FUNCTIONPARENT_TYPES = exports.FUNCTION_TYPES = exports.FORXSTATEMENT_TYPES = exports.FOR_TYPES = exports.EXPRESSIONWRAPPER_TYPES = exports.WHILE_TYPES = exports.LOOP_TYPES = exports.CONDITIONAL_TYPES = exports.COMPLETIONSTATEMENT_TYPES = exports.TERMINATORLESS_TYPES = exports.STATEMENT_TYPES = exports.BLOCK_TYPES = exports.BLOCKPARENT_TYPES = exports.SCOPABLE_TYPES = exports.BINARY_TYPES = exports.EXPRESSION_TYPES = void 0;
+
+var _definitions = require("../../definitions");
+
+const EXPRESSION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Expression"];
+exports.EXPRESSION_TYPES = EXPRESSION_TYPES;
+const BINARY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Binary"];
+exports.BINARY_TYPES = BINARY_TYPES;
+const SCOPABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Scopable"];
+exports.SCOPABLE_TYPES = SCOPABLE_TYPES;
+const BLOCKPARENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["BlockParent"];
+exports.BLOCKPARENT_TYPES = BLOCKPARENT_TYPES;
+const BLOCK_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Block"];
+exports.BLOCK_TYPES = BLOCK_TYPES;
+const STATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Statement"];
+exports.STATEMENT_TYPES = STATEMENT_TYPES;
+const TERMINATORLESS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Terminatorless"];
+exports.TERMINATORLESS_TYPES = TERMINATORLESS_TYPES;
+const COMPLETIONSTATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["CompletionStatement"];
+exports.COMPLETIONSTATEMENT_TYPES = COMPLETIONSTATEMENT_TYPES;
+const CONDITIONAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Conditional"];
+exports.CONDITIONAL_TYPES = CONDITIONAL_TYPES;
+const LOOP_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Loop"];
+exports.LOOP_TYPES = LOOP_TYPES;
+const WHILE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["While"];
+exports.WHILE_TYPES = WHILE_TYPES;
+const EXPRESSIONWRAPPER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ExpressionWrapper"];
+exports.EXPRESSIONWRAPPER_TYPES = EXPRESSIONWRAPPER_TYPES;
+const FOR_TYPES = _definitions.FLIPPED_ALIAS_KEYS["For"];
+exports.FOR_TYPES = FOR_TYPES;
+const FORXSTATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ForXStatement"];
+exports.FORXSTATEMENT_TYPES = FORXSTATEMENT_TYPES;
+const FUNCTION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Function"];
+exports.FUNCTION_TYPES = FUNCTION_TYPES;
+const FUNCTIONPARENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FunctionParent"];
+exports.FUNCTIONPARENT_TYPES = FUNCTIONPARENT_TYPES;
+const PUREISH_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Pureish"];
+exports.PUREISH_TYPES = PUREISH_TYPES;
+const DECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Declaration"];
+exports.DECLARATION_TYPES = DECLARATION_TYPES;
+const PATTERNLIKE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["PatternLike"];
+exports.PATTERNLIKE_TYPES = PATTERNLIKE_TYPES;
+const LVAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["LVal"];
+exports.LVAL_TYPES = LVAL_TYPES;
+const TSENTITYNAME_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSEntityName"];
+exports.TSENTITYNAME_TYPES = TSENTITYNAME_TYPES;
+const LITERAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Literal"];
+exports.LITERAL_TYPES = LITERAL_TYPES;
+const IMMUTABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Immutable"];
+exports.IMMUTABLE_TYPES = IMMUTABLE_TYPES;
+const USERWHITESPACABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["UserWhitespacable"];
+exports.USERWHITESPACABLE_TYPES = USERWHITESPACABLE_TYPES;
+const METHOD_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Method"];
+exports.METHOD_TYPES = METHOD_TYPES;
+const OBJECTMEMBER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ObjectMember"];
+exports.OBJECTMEMBER_TYPES = OBJECTMEMBER_TYPES;
+const PROPERTY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Property"];
+exports.PROPERTY_TYPES = PROPERTY_TYPES;
+const UNARYLIKE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["UnaryLike"];
+exports.UNARYLIKE_TYPES = UNARYLIKE_TYPES;
+const PATTERN_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Pattern"];
+exports.PATTERN_TYPES = PATTERN_TYPES;
+const CLASS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Class"];
+exports.CLASS_TYPES = CLASS_TYPES;
+const MODULEDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ModuleDeclaration"];
+exports.MODULEDECLARATION_TYPES = MODULEDECLARATION_TYPES;
+const EXPORTDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ExportDeclaration"];
+exports.EXPORTDECLARATION_TYPES = EXPORTDECLARATION_TYPES;
+const MODULESPECIFIER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ModuleSpecifier"];
+exports.MODULESPECIFIER_TYPES = MODULESPECIFIER_TYPES;
+const FLOW_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Flow"];
+exports.FLOW_TYPES = FLOW_TYPES;
+const FLOWTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowType"];
+exports.FLOWTYPE_TYPES = FLOWTYPE_TYPES;
+const FLOWBASEANNOTATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowBaseAnnotation"];
+exports.FLOWBASEANNOTATION_TYPES = FLOWBASEANNOTATION_TYPES;
+const FLOWDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowDeclaration"];
+exports.FLOWDECLARATION_TYPES = FLOWDECLARATION_TYPES;
+const FLOWPREDICATE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowPredicate"];
+exports.FLOWPREDICATE_TYPES = FLOWPREDICATE_TYPES;
+const JSX_TYPES = _definitions.FLIPPED_ALIAS_KEYS["JSX"];
+exports.JSX_TYPES = JSX_TYPES;
+const PRIVATE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Private"];
+exports.PRIVATE_TYPES = PRIVATE_TYPES;
+const TSTYPEELEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSTypeElement"];
+exports.TSTYPEELEMENT_TYPES = TSTYPEELEMENT_TYPES;
+const TSTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSType"];
+exports.TSTYPE_TYPES = TSTYPE_TYPES;
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/constants/index.js b/node_modules/@babel/types/lib/constants/index.js
new file mode 100644
index 00000000..a60b106f
--- /dev/null
+++ b/node_modules/@babel/types/lib/constants/index.js
@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NOT_LOCAL_BINDING = exports.BLOCK_SCOPED_SYMBOL = exports.INHERIT_KEYS = exports.UNARY_OPERATORS = exports.STRING_UNARY_OPERATORS = exports.NUMBER_UNARY_OPERATORS = exports.BOOLEAN_UNARY_OPERATORS = exports.BINARY_OPERATORS = exports.NUMBER_BINARY_OPERATORS = exports.BOOLEAN_BINARY_OPERATORS = exports.COMPARISON_BINARY_OPERATORS = exports.EQUALITY_BINARY_OPERATORS = exports.BOOLEAN_NUMBER_BINARY_OPERATORS = exports.UPDATE_OPERATORS = exports.LOGICAL_OPERATORS = exports.COMMENT_KEYS = exports.FOR_INIT_KEYS = exports.FLATTENABLE_KEYS = exports.STATEMENT_OR_BLOCK_KEYS = void 0;
+const STATEMENT_OR_BLOCK_KEYS = ["consequent", "body", "alternate"];
+exports.STATEMENT_OR_BLOCK_KEYS = STATEMENT_OR_BLOCK_KEYS;
+const FLATTENABLE_KEYS = ["body", "expressions"];
+exports.FLATTENABLE_KEYS = FLATTENABLE_KEYS;
+const FOR_INIT_KEYS = ["left", "init"];
+exports.FOR_INIT_KEYS = FOR_INIT_KEYS;
+const COMMENT_KEYS = ["leadingComments", "trailingComments", "innerComments"];
+exports.COMMENT_KEYS = COMMENT_KEYS;
+const LOGICAL_OPERATORS = ["||", "&&", "??"];
+exports.LOGICAL_OPERATORS = LOGICAL_OPERATORS;
+const UPDATE_OPERATORS = ["++", "--"];
+exports.UPDATE_OPERATORS = UPDATE_OPERATORS;
+const BOOLEAN_NUMBER_BINARY_OPERATORS = [">", "<", ">=", "<="];
+exports.BOOLEAN_NUMBER_BINARY_OPERATORS = BOOLEAN_NUMBER_BINARY_OPERATORS;
+const EQUALITY_BINARY_OPERATORS = ["==", "===", "!=", "!=="];
+exports.EQUALITY_BINARY_OPERATORS = EQUALITY_BINARY_OPERATORS;
+const COMPARISON_BINARY_OPERATORS = [...EQUALITY_BINARY_OPERATORS, "in", "instanceof"];
+exports.COMPARISON_BINARY_OPERATORS = COMPARISON_BINARY_OPERATORS;
+const BOOLEAN_BINARY_OPERATORS = [...COMPARISON_BINARY_OPERATORS, ...BOOLEAN_NUMBER_BINARY_OPERATORS];
+exports.BOOLEAN_BINARY_OPERATORS = BOOLEAN_BINARY_OPERATORS;
+const NUMBER_BINARY_OPERATORS = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"];
+exports.NUMBER_BINARY_OPERATORS = NUMBER_BINARY_OPERATORS;
+const BINARY_OPERATORS = ["+", ...NUMBER_BINARY_OPERATORS, ...BOOLEAN_BINARY_OPERATORS];
+exports.BINARY_OPERATORS = BINARY_OPERATORS;
+const BOOLEAN_UNARY_OPERATORS = ["delete", "!"];
+exports.BOOLEAN_UNARY_OPERATORS = BOOLEAN_UNARY_OPERATORS;
+const NUMBER_UNARY_OPERATORS = ["+", "-", "~"];
+exports.NUMBER_UNARY_OPERATORS = NUMBER_UNARY_OPERATORS;
+const STRING_UNARY_OPERATORS = ["typeof"];
+exports.STRING_UNARY_OPERATORS = STRING_UNARY_OPERATORS;
+const UNARY_OPERATORS = ["void", "throw", ...BOOLEAN_UNARY_OPERATORS, ...NUMBER_UNARY_OPERATORS, ...STRING_UNARY_OPERATORS];
+exports.UNARY_OPERATORS = UNARY_OPERATORS;
+const INHERIT_KEYS = {
+  optional: ["typeAnnotation", "typeParameters", "returnType"],
+  force: ["start", "loc", "end"]
+};
+exports.INHERIT_KEYS = INHERIT_KEYS;
+const BLOCK_SCOPED_SYMBOL = Symbol.for("var used to be block scoped");
+exports.BLOCK_SCOPED_SYMBOL = BLOCK_SCOPED_SYMBOL;
+const NOT_LOCAL_BINDING = Symbol.for("should not be considered a local binding");
+exports.NOT_LOCAL_BINDING = NOT_LOCAL_BINDING;
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/converters/ensureBlock.js b/node_modules/@babel/types/lib/converters/ensureBlock.js
new file mode 100644
index 00000000..2836b365
--- /dev/null
+++ b/node_modules/@babel/types/lib/converters/ensureBlock.js
@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = ensureBlock;
+
+var _toBlock = _interopRequireDefault(require("./toBlock"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ensureBlock(node, key = "body") {
+  return node[key] = (0, _toBlock.default)(node[key], node);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/converters/gatherSequenceExpressions.js b/node_modules/@babel/types/lib/converters/gatherSequenceExpressions.js
new file mode 100644
index 00000000..1cffa1e4
--- /dev/null
+++ b/node_modules/@babel/types/lib/converters/gatherSequenceExpressions.js
@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = gatherSequenceExpressions;
+
+var _getBindingIdentifiers = _interopRequireDefault(require("../retrievers/getBindingIdentifiers"));
+
+var _generated = require("../validators/generated");
+
+var _generated2 = require("../builders/generated");
+
+var _cloneNode = _interopRequireDefault(require("../clone/cloneNode"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function gatherSequenceExpressions(nodes, scope, declars) {
+  const exprs = [];
+  let ensureLastUndefined = true;
+
+  for (var _iterator = nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref;
+
+    if (_isArray) {
+      if (_i >= _iterator.length) break;
+      _ref = _iterator[_i++];
+    } else {
+      _i = _iterator.next();
+      if (_i.done) break;
+      _ref = _i.value;
+    }
+
+    const node = _ref;
+    ensureLastUndefined = false;
+
+    if ((0, _generated.isExpression)(node)) {
+      exprs.push(node);
+    } else if ((0, _generated.isExpressionStatement)(node)) {
+      exprs.push(node.expression);
+    } else if ((0, _generated.isVariableDeclaration)(node)) {
+      if (node.kind !== "var") return;
+      var _arr = node.declarations;
+
+      for (var _i2 = 0; _i2 < _arr.length; _i2++) {
+        const declar = _arr[_i2];
+        const bindings = (0, _getBindingIdentifiers.default)(declar);
+
+        for (const key in bindings) {
+          declars.push({
+            kind: node.kind,
+            id: (0, _cloneNode.default)(bindings[key])
+          });
+        }
+
+        if (declar.init) {
+          exprs.push((0, _generated2.assignmentExpression)("=", declar.id, declar.init));
+        }
+      }
+
+      ensureLastUndefined = true;
+    } else if ((0, _generated.isIfStatement)(node)) {
+      const consequent = node.consequent ? gatherSequenceExpressions([node.consequent], scope, declars) : scope.buildUndefinedNode();
+      const alternate = node.alternate ? gatherSequenceExpressions([node.alternate], scope, declars) : scope.buildUndefinedNode();
+      if (!consequent || !alternate) return;
+      exprs.push((0, _generated2.conditionalExpression)(node.test, consequent, alternate));
+    } else if ((0, _generated.isBlockStatement)(node)) {
+      const body = gatherSequenceExpressions(node.body, scope, declars);
+      if (!body) return;
+      exprs.push(body);
+    } else if ((0, _generated.isEmptyStatement)(node)) {
+      ensureLastUndefined = true;
+    } else {
+      return;
+    }
+  }
+
+  if (ensureLastUndefined) {
+    exprs.push(scope.buildUndefinedNode());
+  }
+
+  if (exprs.length === 1) {
+    return exprs[0];
+  } else {
+    return (0, _generated2.sequenceExpression)(exprs);
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/converters/toBindingIdentifierName.js b/node_modules/@babel/types/lib/converters/toBindingIdentifierName.js
new file mode 100644
index 00000000..b9d165b6
--- /dev/null
+++ b/node_modules/@babel/types/lib/converters/toBindingIdentifierName.js
@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = toBindingIdentifierName;
+
+var _toIdentifier = _interopRequireDefault(require("./toIdentifier"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function toBindingIdentifierName(name) {
+  name = (0, _toIdentifier.default)(name);
+  if (name === "eval" || name === "arguments") name = "_" + name;
+  return name;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/converters/toBlock.js b/node_modules/@babel/types/lib/converters/toBlock.js
new file mode 100644
index 00000000..19886833
--- /dev/null
+++ b/node_modules/@babel/types/lib/converters/toBlock.js
@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = toBlock;
+
+var _generated = require("../validators/generated");
+
+var _generated2 = require("../builders/generated");
+
+function toBlock(node, parent) {
+  if ((0, _generated.isBlockStatement)(node)) {
+    return node;
+  }
+
+  let blockNodes = [];
+
+  if ((0, _generated.isEmptyStatement)(node)) {
+    blockNodes = [];
+  } else {
+    if (!(0, _generated.isStatement)(node)) {
+      if ((0, _generated.isFunction)(parent)) {
+        node = (0, _generated2.returnStatement)(node);
+      } else {
+        node = (0, _generated2.expressionStatement)(node);
+      }
+    }
+
+    blockNodes = [node];
+  }
+
+  return (0, _generated2.blockStatement)(blockNodes);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/converters/toComputedKey.js b/node_modules/@babel/types/lib/converters/toComputedKey.js
new file mode 100644
index 00000000..31e6770f
--- /dev/null
+++ b/node_modules/@babel/types/lib/converters/toComputedKey.js
@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = toComputedKey;
+
+var _generated = require("../validators/generated");
+
+var _generated2 = require("../builders/generated");
+
+function toComputedKey(node, key = node.key || node.property) {
+  if (!node.computed && (0, _generated.isIdentifier)(key)) key = (0, _generated2.stringLiteral)(key.name);
+  return key;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/converters/toExpression.js b/node_modules/@babel/types/lib/converters/toExpression.js
new file mode 100644
index 00000000..6e58b0de
--- /dev/null
+++ b/node_modules/@babel/types/lib/converters/toExpression.js
@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = toExpression;
+
+var _generated = require("../validators/generated");
+
+function toExpression(node) {
+  if ((0, _generated.isExpressionStatement)(node)) {
+    node = node.expression;
+  }
+
+  if ((0, _generated.isExpression)(node)) {
+    return node;
+  }
+
+  if ((0, _generated.isClass)(node)) {
+    node.type = "ClassExpression";
+  } else if ((0, _generated.isFunction)(node)) {
+    node.type = "FunctionExpression";
+  }
+
+  if (!(0, _generated.isExpression)(node)) {
+    throw new Error(`cannot turn ${node.type} to an expression`);
+  }
+
+  return node;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/converters/toIdentifier.js b/node_modules/@babel/types/lib/converters/toIdentifier.js
new file mode 100644
index 00000000..e55db41f
--- /dev/null
+++ b/node_modules/@babel/types/lib/converters/toIdentifier.js
@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = toIdentifier;
+
+var _isValidIdentifier = _interopRequireDefault(require("../validators/isValidIdentifier"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function toIdentifier(name) {
+  name = name + "";
+  name = name.replace(/[^a-zA-Z0-9$_]/g, "-");
+  name = name.replace(/^[-0-9]+/, "");
+  name = name.replace(/[-\s]+(.)?/g, function (match, c) {
+    return c ? c.toUpperCase() : "";
+  });
+
+  if (!(0, _isValidIdentifier.default)(name)) {
+    name = `_${name}`;
+  }
+
+  return name || "_";
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/converters/toKeyAlias.js b/node_modules/@babel/types/lib/converters/toKeyAlias.js
new file mode 100644
index 00000000..c48fd0e7
--- /dev/null
+++ b/node_modules/@babel/types/lib/converters/toKeyAlias.js
@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = toKeyAlias;
+
+var _generated = require("../validators/generated");
+
+var _cloneNode = _interopRequireDefault(require("../clone/cloneNode"));
+
+var _removePropertiesDeep = _interopRequireDefault(require("../modifications/removePropertiesDeep"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function toKeyAlias(node, key = node.key) {
+  let alias;
+
+  if (node.kind === "method") {
+    return toKeyAlias.increment() + "";
+  } else if ((0, _generated.isIdentifier)(key)) {
+    alias = key.name;
+  } else if ((0, _generated.isStringLiteral)(key)) {
+    alias = JSON.stringify(key.value);
+  } else {
+    alias = JSON.stringify((0, _removePropertiesDeep.default)((0, _cloneNode.default)(key)));
+  }
+
+  if (node.computed) {
+    alias = `[${alias}]`;
+  }
+
+  if (node.static) {
+    alias = `static:${alias}`;
+  }
+
+  return alias;
+}
+
+toKeyAlias.uid = 0;
+
+toKeyAlias.increment = function () {
+  if (toKeyAlias.uid >= Number.MAX_SAFE_INTEGER) {
+    return toKeyAlias.uid = 0;
+  } else {
+    return toKeyAlias.uid++;
+  }
+};
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/converters/toSequenceExpression.js b/node_modules/@babel/types/lib/converters/toSequenceExpression.js
new file mode 100644
index 00000000..8ddea8c0
--- /dev/null
+++ b/node_modules/@babel/types/lib/converters/toSequenceExpression.js
@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = toSequenceExpression;
+
+var _gatherSequenceExpressions = _interopRequireDefault(require("./gatherSequenceExpressions"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function toSequenceExpression(nodes, scope) {
+  if (!nodes || !nodes.length) return;
+  const declars = [];
+  const result = (0, _gatherSequenceExpressions.default)(nodes, scope, declars);
+  if (!result) return;
+
+  for (var _i = 0; _i < declars.length; _i++) {
+    const declar = declars[_i];
+    scope.push(declar);
+  }
+
+  return result;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/converters/toStatement.js b/node_modules/@babel/types/lib/converters/toStatement.js
new file mode 100644
index 00000000..69b22ae0
--- /dev/null
+++ b/node_modules/@babel/types/lib/converters/toStatement.js
@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = toStatement;
+
+var _generated = require("../validators/generated");
+
+var _generated2 = require("../builders/generated");
+
+function toStatement(node, ignore) {
+  if ((0, _generated.isStatement)(node)) {
+    return node;
+  }
+
+  let mustHaveId = false;
+  let newType;
+
+  if ((0, _generated.isClass)(node)) {
+    mustHaveId = true;
+    newType = "ClassDeclaration";
+  } else if ((0, _generated.isFunction)(node)) {
+    mustHaveId = true;
+    newType = "FunctionDeclaration";
+  } else if ((0, _generated.isAssignmentExpression)(node)) {
+    return (0, _generated2.expressionStatement)(node);
+  }
+
+  if (mustHaveId && !node.id) {
+    newType = false;
+  }
+
+  if (!newType) {
+    if (ignore) {
+      return false;
+    } else {
+      throw new Error(`cannot turn ${node.type} to a statement`);
+    }
+  }
+
+  node.type = newType;
+  return node;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/converters/valueToNode.js b/node_modules/@babel/types/lib/converters/valueToNode.js
new file mode 100644
index 00000000..ac510233
--- /dev/null
+++ b/node_modules/@babel/types/lib/converters/valueToNode.js
@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = valueToNode;
+
+function _isPlainObject() {
+  const data = _interopRequireDefault(require("lodash/isPlainObject"));
+
+  _isPlainObject = function _isPlainObject() {
+    return data;
+  };
+
+  return data;
+}
+
+function _isRegExp() {
+  const data = _interopRequireDefault(require("lodash/isRegExp"));
+
+  _isRegExp = function _isRegExp() {
+    return data;
+  };
+
+  return data;
+}
+
+var _isValidIdentifier = _interopRequireDefault(require("../validators/isValidIdentifier"));
+
+var _generated = require("../builders/generated");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function valueToNode(value) {
+  if (value === undefined) {
+    return (0, _generated.identifier)("undefined");
+  }
+
+  if (value === true || value === false) {
+    return (0, _generated.booleanLiteral)(value);
+  }
+
+  if (value === null) {
+    return (0, _generated.nullLiteral)();
+  }
+
+  if (typeof value === "string") {
+    return (0, _generated.stringLiteral)(value);
+  }
+
+  if (typeof value === "number") {
+    return (0, _generated.numericLiteral)(value);
+  }
+
+  if ((0, _isRegExp().default)(value)) {
+    const pattern = value.source;
+    const flags = value.toString().match(/\/([a-z]+|)$/)[1];
+    return (0, _generated.regExpLiteral)(pattern, flags);
+  }
+
+  if (Array.isArray(value)) {
+    return (0, _generated.arrayExpression)(value.map(valueToNode));
+  }
+
+  if ((0, _isPlainObject().default)(value)) {
+    const props = [];
+
+    for (const key in value) {
+      let nodeKey;
+
+      if ((0, _isValidIdentifier.default)(key)) {
+        nodeKey = (0, _generated.identifier)(key);
+      } else {
+        nodeKey = (0, _generated.stringLiteral)(key);
+      }
+
+      props.push((0, _generated.objectProperty)(nodeKey, valueToNode(value[key])));
+    }
+
+    return (0, _generated.objectExpression)(props);
+  }
+
+  throw new Error("don't know how to turn this value into a node");
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/definitions/core.js b/node_modules/@babel/types/lib/definitions/core.js
new file mode 100644
index 00000000..871c81ce
--- /dev/null
+++ b/node_modules/@babel/types/lib/definitions/core.js
@@ -0,0 +1,699 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.patternLikeCommon = exports.functionDeclarationCommon = exports.functionTypeAnnotationCommon = exports.functionCommon = void 0;
+
+var _isValidIdentifier = _interopRequireDefault(require("../validators/isValidIdentifier"));
+
+var _constants = require("../constants");
+
+var _utils = _interopRequireWildcard(require("./utils"));
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+(0, _utils.default)("ArrayExpression", {
+  fields: {
+    elements: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "Expression", "SpreadElement"))),
+      default: []
+    }
+  },
+  visitor: ["elements"],
+  aliases: ["Expression"]
+});
+(0, _utils.default)("AssignmentExpression", {
+  fields: {
+    operator: {
+      validate: (0, _utils.assertValueType)("string")
+    },
+    left: {
+      validate: (0, _utils.assertNodeType)("LVal")
+    },
+    right: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    }
+  },
+  builder: ["operator", "left", "right"],
+  visitor: ["left", "right"],
+  aliases: ["Expression"]
+});
+(0, _utils.default)("BinaryExpression", {
+  builder: ["operator", "left", "right"],
+  fields: {
+    operator: {
+      validate: (0, _utils.assertOneOf)(..._constants.BINARY_OPERATORS)
+    },
+    left: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    },
+    right: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    }
+  },
+  visitor: ["left", "right"],
+  aliases: ["Binary", "Expression"]
+});
+(0, _utils.default)("Directive", {
+  visitor: ["value"],
+  fields: {
+    value: {
+      validate: (0, _utils.assertNodeType)("DirectiveLiteral")
+    }
+  }
+});
+(0, _utils.default)("DirectiveLiteral", {
+  builder: ["value"],
+  fields: {
+    value: {
+      validate: (0, _utils.assertValueType)("string")
+    }
+  }
+});
+(0, _utils.default)("BlockStatement", {
+  builder: ["body", "directives"],
+  visitor: ["directives", "body"],
+  fields: {
+    directives: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))),
+      default: []
+    },
+    body: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
+    }
+  },
+  aliases: ["Scopable", "BlockParent", "Block", "Statement"]
+});
+(0, _utils.default)("BreakStatement", {
+  visitor: ["label"],
+  fields: {
+    label: {
+      validate: (0, _utils.assertNodeType)("Identifier"),
+      optional: true
+    }
+  },
+  aliases: ["Statement", "Terminatorless", "CompletionStatement"]
+});
+(0, _utils.default)("CallExpression", {
+  visitor: ["callee", "arguments", "typeParameters"],
+  builder: ["callee", "arguments"],
+  aliases: ["Expression"],
+  fields: {
+    callee: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    },
+    arguments: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName")))
+    },
+    optional: {
+      validate: (0, _utils.assertOneOf)(true, false),
+      optional: true
+    },
+    typeParameters: {
+      validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
+      optional: true
+    }
+  }
+});
+(0, _utils.default)("CatchClause", {
+  visitor: ["param", "body"],
+  fields: {
+    param: {
+      validate: (0, _utils.assertNodeType)("Identifier"),
+      optional: true
+    },
+    body: {
+      validate: (0, _utils.assertNodeType)("BlockStatement")
+    }
+  },
+  aliases: ["Scopable", "BlockParent"]
+});
+(0, _utils.default)("ConditionalExpression", {
+  visitor: ["test", "consequent", "alternate"],
+  fields: {
+    test: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    },
+    consequent: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    },
+    alternate: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    }
+  },
+  aliases: ["Expression", "Conditional"]
+});
+(0, _utils.default)("ContinueStatement", {
+  visitor: ["label"],
+  fields: {
+    label: {
+      validate: (0, _utils.assertNodeType)("Identifier"),
+      optional: true
+    }
+  },
+  aliases: ["Statement", "Terminatorless", "CompletionStatement"]
+});
+(0, _utils.default)("DebuggerStatement", {
+  aliases: ["Statement"]
+});
+(0, _utils.default)("DoWhileStatement", {
+  visitor: ["test", "body"],
+  fields: {
+    test: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    },
+    body: {
+      validate: (0, _utils.assertNodeType)("Statement")
+    }
+  },
+  aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"]
+});
+(0, _utils.default)("EmptyStatement", {
+  aliases: ["Statement"]
+});
+(0, _utils.default)("ExpressionStatement", {
+  visitor: ["expression"],
+  fields: {
+    expression: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    }
+  },
+  aliases: ["Statement", "ExpressionWrapper"]
+});
+(0, _utils.default)("File", {
+  builder: ["program", "comments", "tokens"],
+  visitor: ["program"],
+  fields: {
+    program: {
+      validate: (0, _utils.assertNodeType)("Program")
+    }
+  }
+});
+(0, _utils.default)("ForInStatement", {
+  visitor: ["left", "right", "body"],
+  aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"],
+  fields: {
+    left: {
+      validate: (0, _utils.assertNodeType)("VariableDeclaration", "LVal")
+    },
+    right: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    },
+    body: {
+      validate: (0, _utils.assertNodeType)("Statement")
+    }
+  }
+});
+(0, _utils.default)("ForStatement", {
+  visitor: ["init", "test", "update", "body"],
+  aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop"],
+  fields: {
+    init: {
+      validate: (0, _utils.assertNodeType)("VariableDeclaration", "Expression"),
+      optional: true
+    },
+    test: {
+      validate: (0, _utils.assertNodeType)("Expression"),
+      optional: true
+    },
+    update: {
+      validate: (0, _utils.assertNodeType)("Expression"),
+      optional: true
+    },
+    body: {
+      validate: (0, _utils.assertNodeType)("Statement")
+    }
+  }
+});
+const functionCommon = {
+  params: {
+    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("LVal")))
+  },
+  generator: {
+    default: false,
+    validate: (0, _utils.assertValueType)("boolean")
+  },
+  async: {
+    validate: (0, _utils.assertValueType)("boolean"),
+    default: false
+  }
+};
+exports.functionCommon = functionCommon;
+const functionTypeAnnotationCommon = {
+  returnType: {
+    validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
+    optional: true
+  },
+  typeParameters: {
+    validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
+    optional: true
+  }
+};
+exports.functionTypeAnnotationCommon = functionTypeAnnotationCommon;
+const functionDeclarationCommon = Object.assign({}, functionCommon, {
+  declare: {
+    validate: (0, _utils.assertValueType)("boolean"),
+    optional: true
+  },
+  id: {
+    validate: (0, _utils.assertNodeType)("Identifier"),
+    optional: true
+  }
+});
+exports.functionDeclarationCommon = functionDeclarationCommon;
+(0, _utils.default)("FunctionDeclaration", {
+  builder: ["id", "params", "body", "generator", "async"],
+  visitor: ["id", "params", "body", "returnType", "typeParameters"],
+  fields: Object.assign({}, functionDeclarationCommon, functionTypeAnnotationCommon, {
+    body: {
+      validate: (0, _utils.assertNodeType)("BlockStatement")
+    }
+  }),
+  aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Statement", "Pureish", "Declaration"]
+});
+(0, _utils.default)("FunctionExpression", {
+  inherits: "FunctionDeclaration",
+  aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
+  fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, {
+    id: {
+      validate: (0, _utils.assertNodeType)("Identifier"),
+      optional: true
+    },
+    body: {
+      validate: (0, _utils.assertNodeType)("BlockStatement")
+    }
+  })
+});
+const patternLikeCommon = {
+  typeAnnotation: {
+    validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
+    optional: true
+  },
+  decorators: {
+    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator")))
+  }
+};
+exports.patternLikeCommon = patternLikeCommon;
+(0, _utils.default)("Identifier", {
+  builder: ["name"],
+  visitor: ["typeAnnotation"],
+  aliases: ["Expression", "PatternLike", "LVal", "TSEntityName"],
+  fields: Object.assign({}, patternLikeCommon, {
+    name: {
+      validate: (0, _utils.chain)(function (node, key, val) {
+        if (!(0, _isValidIdentifier.default)(val)) {}
+      }, (0, _utils.assertValueType)("string"))
+    },
+    optional: {
+      validate: (0, _utils.assertValueType)("boolean"),
+      optional: true
+    }
+  })
+});
+(0, _utils.default)("IfStatement", {
+  visitor: ["test", "consequent", "alternate"],
+  aliases: ["Statement", "Conditional"],
+  fields: {
+    test: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    },
+    consequent: {
+      validate: (0, _utils.assertNodeType)("Statement")
+    },
+    alternate: {
+      optional: true,
+      validate: (0, _utils.assertNodeType)("Statement")
+    }
+  }
+});
+(0, _utils.default)("LabeledStatement", {
+  visitor: ["label", "body"],
+  aliases: ["Statement"],
+  fields: {
+    label: {
+      validate: (0, _utils.assertNodeType)("Identifier")
+    },
+    body: {
+      validate: (0, _utils.assertNodeType)("Statement")
+    }
+  }
+});
+(0, _utils.default)("StringLiteral", {
+  builder: ["value"],
+  fields: {
+    value: {
+      validate: (0, _utils.assertValueType)("string")
+    }
+  },
+  aliases: ["Expression", "Pureish", "Literal", "Immutable"]
+});
+(0, _utils.default)("NumericLiteral", {
+  builder: ["value"],
+  deprecatedAlias: "NumberLiteral",
+  fields: {
+    value: {
+      validate: (0, _utils.assertValueType)("number")
+    }
+  },
+  aliases: ["Expression", "Pureish", "Literal", "Immutable"]
+});
+(0, _utils.default)("NullLiteral", {
+  aliases: ["Expression", "Pureish", "Literal", "Immutable"]
+});
+(0, _utils.default)("BooleanLiteral", {
+  builder: ["value"],
+  fields: {
+    value: {
+      validate: (0, _utils.assertValueType)("boolean")
+    }
+  },
+  aliases: ["Expression", "Pureish", "Literal", "Immutable"]
+});
+(0, _utils.default)("RegExpLiteral", {
+  builder: ["pattern", "flags"],
+  deprecatedAlias: "RegexLiteral",
+  aliases: ["Expression", "Literal"],
+  fields: {
+    pattern: {
+      validate: (0, _utils.assertValueType)("string")
+    },
+    flags: {
+      validate: (0, _utils.assertValueType)("string"),
+      default: ""
+    }
+  }
+});
+(0, _utils.default)("LogicalExpression", {
+  builder: ["operator", "left", "right"],
+  visitor: ["left", "right"],
+  aliases: ["Binary", "Expression"],
+  fields: {
+    operator: {
+      validate: (0, _utils.assertOneOf)(..._constants.LOGICAL_OPERATORS)
+    },
+    left: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    },
+    right: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    }
+  }
+});
+(0, _utils.default)("MemberExpression", {
+  builder: ["object", "property", "computed", "optional"],
+  visitor: ["object", "property"],
+  aliases: ["Expression", "LVal"],
+  fields: {
+    object: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    },
+    property: {
+      validate: function () {
+        const normal = (0, _utils.assertNodeType)("Identifier", "PrivateName");
+        const computed = (0, _utils.assertNodeType)("Expression");
+        return function (node, key, val) {
+          const validator = node.computed ? computed : normal;
+          validator(node, key, val);
+        };
+      }()
+    },
+    computed: {
+      default: false
+    },
+    optional: {
+      validate: (0, _utils.assertOneOf)(true, false),
+      optional: true
+    }
+  }
+});
+(0, _utils.default)("NewExpression", {
+  inherits: "CallExpression"
+});
+(0, _utils.default)("Program", {
+  visitor: ["directives", "body"],
+  builder: ["body", "directives", "sourceType"],
+  fields: {
+    sourceFile: {
+      validate: (0, _utils.assertValueType)("string")
+    },
+    sourceType: {
+      validate: (0, _utils.assertOneOf)("script", "module"),
+      default: "script"
+    },
+    directives: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))),
+      default: []
+    },
+    body: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
+    }
+  },
+  aliases: ["Scopable", "BlockParent", "Block"]
+});
+(0, _utils.default)("ObjectExpression", {
+  visitor: ["properties"],
+  aliases: ["Expression"],
+  fields: {
+    properties: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ObjectMethod", "ObjectProperty", "SpreadElement")))
+    }
+  }
+});
+(0, _utils.default)("ObjectMethod", {
+  builder: ["kind", "key", "params", "body", "computed"],
+  fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, {
+    kind: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("method", "get", "set")),
+      default: "method"
+    },
+    computed: {
+      validate: (0, _utils.assertValueType)("boolean"),
+      default: false
+    },
+    key: {
+      validate: function () {
+        const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
+        const computed = (0, _utils.assertNodeType)("Expression");
+        return function (node, key, val) {
+          const validator = node.computed ? computed : normal;
+          validator(node, key, val);
+        };
+      }()
+    },
+    decorators: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator")))
+    },
+    body: {
+      validate: (0, _utils.assertNodeType)("BlockStatement")
+    }
+  }),
+  visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
+  aliases: ["UserWhitespacable", "Function", "Scopable", "BlockParent", "FunctionParent", "Method", "ObjectMember"]
+});
+(0, _utils.default)("ObjectProperty", {
+  builder: ["key", "value", "computed", "shorthand", "decorators"],
+  fields: {
+    computed: {
+      validate: (0, _utils.assertValueType)("boolean"),
+      default: false
+    },
+    key: {
+      validate: function () {
+        const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
+        const computed = (0, _utils.assertNodeType)("Expression");
+        return function (node, key, val) {
+          const validator = node.computed ? computed : normal;
+          validator(node, key, val);
+        };
+      }()
+    },
+    value: {
+      validate: (0, _utils.assertNodeType)("Expression", "PatternLike")
+    },
+    shorthand: {
+      validate: (0, _utils.assertValueType)("boolean"),
+      default: false
+    },
+    decorators: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
+      optional: true
+    }
+  },
+  visitor: ["key", "value", "decorators"],
+  aliases: ["UserWhitespacable", "Property", "ObjectMember"]
+});
+(0, _utils.default)("RestElement", {
+  visitor: ["argument", "typeAnnotation"],
+  builder: ["argument"],
+  aliases: ["LVal", "PatternLike"],
+  deprecatedAlias: "RestProperty",
+  fields: Object.assign({}, patternLikeCommon, {
+    argument: {
+      validate: (0, _utils.assertNodeType)("LVal")
+    }
+  })
+});
+(0, _utils.default)("ReturnStatement", {
+  visitor: ["argument"],
+  aliases: ["Statement", "Terminatorless", "CompletionStatement"],
+  fields: {
+    argument: {
+      validate: (0, _utils.assertNodeType)("Expression"),
+      optional: true
+    }
+  }
+});
+(0, _utils.default)("SequenceExpression", {
+  visitor: ["expressions"],
+  fields: {
+    expressions: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression")))
+    }
+  },
+  aliases: ["Expression"]
+});
+(0, _utils.default)("SwitchCase", {
+  visitor: ["test", "consequent"],
+  fields: {
+    test: {
+      validate: (0, _utils.assertNodeType)("Expression"),
+      optional: true
+    },
+    consequent: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
+    }
+  }
+});
+(0, _utils.default)("SwitchStatement", {
+  visitor: ["discriminant", "cases"],
+  aliases: ["Statement", "BlockParent", "Scopable"],
+  fields: {
+    discriminant: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    },
+    cases: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("SwitchCase")))
+    }
+  }
+});
+(0, _utils.default)("ThisExpression", {
+  aliases: ["Expression"]
+});
+(0, _utils.default)("ThrowStatement", {
+  visitor: ["argument"],
+  aliases: ["Statement", "Terminatorless", "CompletionStatement"],
+  fields: {
+    argument: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    }
+  }
+});
+(0, _utils.default)("TryStatement", {
+  visitor: ["block", "handler", "finalizer"],
+  aliases: ["Statement"],
+  fields: {
+    block: {
+      validate: (0, _utils.assertNodeType)("BlockStatement")
+    },
+    handler: {
+      optional: true,
+      validate: (0, _utils.assertNodeType)("CatchClause")
+    },
+    finalizer: {
+      optional: true,
+      validate: (0, _utils.assertNodeType)("BlockStatement")
+    }
+  }
+});
+(0, _utils.default)("UnaryExpression", {
+  builder: ["operator", "argument", "prefix"],
+  fields: {
+    prefix: {
+      default: true
+    },
+    argument: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    },
+    operator: {
+      validate: (0, _utils.assertOneOf)(..._constants.UNARY_OPERATORS)
+    }
+  },
+  visitor: ["argument"],
+  aliases: ["UnaryLike", "Expression"]
+});
+(0, _utils.default)("UpdateExpression", {
+  builder: ["operator", "argument", "prefix"],
+  fields: {
+    prefix: {
+      default: false
+    },
+    argument: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    },
+    operator: {
+      validate: (0, _utils.assertOneOf)(..._constants.UPDATE_OPERATORS)
+    }
+  },
+  visitor: ["argument"],
+  aliases: ["Expression"]
+});
+(0, _utils.default)("VariableDeclaration", {
+  builder: ["kind", "declarations"],
+  visitor: ["declarations"],
+  aliases: ["Statement", "Declaration"],
+  fields: {
+    declare: {
+      validate: (0, _utils.assertValueType)("boolean"),
+      optional: true
+    },
+    kind: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("var", "let", "const"))
+    },
+    declarations: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("VariableDeclarator")))
+    }
+  }
+});
+(0, _utils.default)("VariableDeclarator", {
+  visitor: ["id", "init"],
+  fields: {
+    id: {
+      validate: (0, _utils.assertNodeType)("LVal")
+    },
+    definite: {
+      optional: true,
+      validate: (0, _utils.assertValueType)("boolean")
+    },
+    init: {
+      optional: true,
+      validate: (0, _utils.assertNodeType)("Expression")
+    }
+  }
+});
+(0, _utils.default)("WhileStatement", {
+  visitor: ["test", "body"],
+  aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"],
+  fields: {
+    test: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    },
+    body: {
+      validate: (0, _utils.assertNodeType)("BlockStatement", "Statement")
+    }
+  }
+});
+(0, _utils.default)("WithStatement", {
+  visitor: ["object", "body"],
+  aliases: ["Statement"],
+  fields: {
+    object: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    },
+    body: {
+      validate: (0, _utils.assertNodeType)("BlockStatement", "Statement")
+    }
+  }
+});
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/definitions/es2015.js b/node_modules/@babel/types/lib/definitions/es2015.js
new file mode 100644
index 00000000..1ef16a1c
--- /dev/null
+++ b/node_modules/@babel/types/lib/definitions/es2015.js
@@ -0,0 +1,381 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.classMethodOrDeclareMethodCommon = exports.classMethodOrPropertyCommon = void 0;
+
+var _utils = _interopRequireWildcard(require("./utils"));
+
+var _core = require("./core");
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+(0, _utils.default)("AssignmentPattern", {
+  visitor: ["left", "right"],
+  builder: ["left", "right"],
+  aliases: ["Pattern", "PatternLike", "LVal"],
+  fields: Object.assign({}, _core.patternLikeCommon, {
+    left: {
+      validate: (0, _utils.assertNodeType)("Identifier", "ObjectPattern", "ArrayPattern")
+    },
+    right: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    },
+    decorators: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator")))
+    }
+  })
+});
+(0, _utils.default)("ArrayPattern", {
+  visitor: ["elements", "typeAnnotation"],
+  builder: ["elements"],
+  aliases: ["Pattern", "PatternLike", "LVal"],
+  fields: Object.assign({}, _core.patternLikeCommon, {
+    elements: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("PatternLike")))
+    },
+    decorators: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator")))
+    }
+  })
+});
+(0, _utils.default)("ArrowFunctionExpression", {
+  builder: ["params", "body", "async"],
+  visitor: ["params", "body", "returnType", "typeParameters"],
+  aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
+  fields: Object.assign({}, _core.functionCommon, _core.functionTypeAnnotationCommon, {
+    expression: {
+      validate: (0, _utils.assertValueType)("boolean")
+    },
+    body: {
+      validate: (0, _utils.assertNodeType)("BlockStatement", "Expression")
+    }
+  })
+});
+(0, _utils.default)("ClassBody", {
+  visitor: ["body"],
+  fields: {
+    body: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ClassMethod", "ClassProperty", "ClassPrivateProperty", "TSDeclareMethod", "TSIndexSignature")))
+    }
+  }
+});
+const classCommon = {
+  typeParameters: {
+    validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
+    optional: true
+  },
+  body: {
+    validate: (0, _utils.assertNodeType)("ClassBody")
+  },
+  superClass: {
+    optional: true,
+    validate: (0, _utils.assertNodeType)("Expression")
+  },
+  superTypeParameters: {
+    validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
+    optional: true
+  },
+  implements: {
+    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))),
+    optional: true
+  }
+};
+(0, _utils.default)("ClassDeclaration", {
+  builder: ["id", "superClass", "body", "decorators"],
+  visitor: ["id", "body", "superClass", "mixins", "typeParameters", "superTypeParameters", "implements", "decorators"],
+  aliases: ["Scopable", "Class", "Statement", "Declaration", "Pureish"],
+  fields: Object.assign({}, classCommon, {
+    declare: {
+      validate: (0, _utils.assertValueType)("boolean"),
+      optional: true
+    },
+    abstract: {
+      validate: (0, _utils.assertValueType)("boolean"),
+      optional: true
+    },
+    id: {
+      validate: (0, _utils.assertNodeType)("Identifier"),
+      optional: true
+    },
+    decorators: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
+      optional: true
+    }
+  })
+});
+(0, _utils.default)("ClassExpression", {
+  inherits: "ClassDeclaration",
+  aliases: ["Scopable", "Class", "Expression", "Pureish"],
+  fields: Object.assign({}, classCommon, {
+    id: {
+      optional: true,
+      validate: (0, _utils.assertNodeType)("Identifier")
+    },
+    body: {
+      validate: (0, _utils.assertNodeType)("ClassBody")
+    },
+    superClass: {
+      optional: true,
+      validate: (0, _utils.assertNodeType)("Expression")
+    },
+    decorators: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
+      optional: true
+    }
+  })
+});
+(0, _utils.default)("ExportAllDeclaration", {
+  visitor: ["source"],
+  aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"],
+  fields: {
+    source: {
+      validate: (0, _utils.assertNodeType)("StringLiteral")
+    }
+  }
+});
+(0, _utils.default)("ExportDefaultDeclaration", {
+  visitor: ["declaration"],
+  aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"],
+  fields: {
+    declaration: {
+      validate: (0, _utils.assertNodeType)("FunctionDeclaration", "TSDeclareFunction", "ClassDeclaration", "Expression")
+    }
+  }
+});
+(0, _utils.default)("ExportNamedDeclaration", {
+  visitor: ["declaration", "specifiers", "source"],
+  aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"],
+  fields: {
+    declaration: {
+      validate: (0, _utils.assertNodeType)("Declaration"),
+      optional: true
+    },
+    specifiers: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ExportSpecifier", "ExportDefaultSpecifier", "ExportNamespaceSpecifier")))
+    },
+    source: {
+      validate: (0, _utils.assertNodeType)("StringLiteral"),
+      optional: true
+    }
+  }
+});
+(0, _utils.default)("ExportSpecifier", {
+  visitor: ["local", "exported"],
+  aliases: ["ModuleSpecifier"],
+  fields: {
+    local: {
+      validate: (0, _utils.assertNodeType)("Identifier")
+    },
+    exported: {
+      validate: (0, _utils.assertNodeType)("Identifier")
+    }
+  }
+});
+(0, _utils.default)("ForOfStatement", {
+  visitor: ["left", "right", "body"],
+  aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"],
+  fields: {
+    left: {
+      validate: (0, _utils.assertNodeType)("VariableDeclaration", "LVal")
+    },
+    right: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    },
+    body: {
+      validate: (0, _utils.assertNodeType)("Statement")
+    },
+    await: {
+      default: false,
+      validate: (0, _utils.assertValueType)("boolean")
+    }
+  }
+});
+(0, _utils.default)("ImportDeclaration", {
+  visitor: ["specifiers", "source"],
+  aliases: ["Statement", "Declaration", "ModuleDeclaration"],
+  fields: {
+    specifiers: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportSpecifier", "ImportDefaultSpecifier", "ImportNamespaceSpecifier")))
+    },
+    source: {
+      validate: (0, _utils.assertNodeType)("StringLiteral")
+    }
+  }
+});
+(0, _utils.default)("ImportDefaultSpecifier", {
+  visitor: ["local"],
+  aliases: ["ModuleSpecifier"],
+  fields: {
+    local: {
+      validate: (0, _utils.assertNodeType)("Identifier")
+    }
+  }
+});
+(0, _utils.default)("ImportNamespaceSpecifier", {
+  visitor: ["local"],
+  aliases: ["ModuleSpecifier"],
+  fields: {
+    local: {
+      validate: (0, _utils.assertNodeType)("Identifier")
+    }
+  }
+});
+(0, _utils.default)("ImportSpecifier", {
+  visitor: ["local", "imported"],
+  aliases: ["ModuleSpecifier"],
+  fields: {
+    local: {
+      validate: (0, _utils.assertNodeType)("Identifier")
+    },
+    imported: {
+      validate: (0, _utils.assertNodeType)("Identifier")
+    },
+    importKind: {
+      validate: (0, _utils.assertOneOf)(null, "type", "typeof")
+    }
+  }
+});
+(0, _utils.default)("MetaProperty", {
+  visitor: ["meta", "property"],
+  aliases: ["Expression"],
+  fields: {
+    meta: {
+      validate: (0, _utils.assertNodeType)("Identifier")
+    },
+    property: {
+      validate: (0, _utils.assertNodeType)("Identifier")
+    }
+  }
+});
+const classMethodOrPropertyCommon = {
+  abstract: {
+    validate: (0, _utils.assertValueType)("boolean"),
+    optional: true
+  },
+  accessibility: {
+    validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("public", "private", "protected")),
+    optional: true
+  },
+  static: {
+    validate: (0, _utils.assertValueType)("boolean"),
+    optional: true
+  },
+  computed: {
+    default: false,
+    validate: (0, _utils.assertValueType)("boolean")
+  },
+  optional: {
+    validate: (0, _utils.assertValueType)("boolean"),
+    optional: true
+  },
+  key: {
+    validate: (0, _utils.chain)(function () {
+      const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
+      const computed = (0, _utils.assertNodeType)("Expression");
+      return function (node, key, val) {
+        const validator = node.computed ? computed : normal;
+        validator(node, key, val);
+      };
+    }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "Expression"))
+  }
+};
+exports.classMethodOrPropertyCommon = classMethodOrPropertyCommon;
+const classMethodOrDeclareMethodCommon = Object.assign({}, _core.functionCommon, classMethodOrPropertyCommon, {
+  kind: {
+    validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("get", "set", "method", "constructor")),
+    default: "method"
+  },
+  access: {
+    validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("public", "private", "protected")),
+    optional: true
+  },
+  decorators: {
+    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
+    optional: true
+  }
+});
+exports.classMethodOrDeclareMethodCommon = classMethodOrDeclareMethodCommon;
+(0, _utils.default)("ClassMethod", {
+  aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method"],
+  builder: ["kind", "key", "params", "body", "computed", "static"],
+  visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
+  fields: Object.assign({}, classMethodOrDeclareMethodCommon, _core.functionTypeAnnotationCommon, {
+    body: {
+      validate: (0, _utils.assertNodeType)("BlockStatement")
+    }
+  })
+});
+(0, _utils.default)("ObjectPattern", {
+  visitor: ["properties", "typeAnnotation"],
+  builder: ["properties"],
+  aliases: ["Pattern", "PatternLike", "LVal"],
+  fields: Object.assign({}, _core.patternLikeCommon, {
+    properties: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("RestElement", "ObjectProperty")))
+    }
+  })
+});
+(0, _utils.default)("SpreadElement", {
+  visitor: ["argument"],
+  aliases: ["UnaryLike"],
+  deprecatedAlias: "SpreadProperty",
+  fields: {
+    argument: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    }
+  }
+});
+(0, _utils.default)("Super", {
+  aliases: ["Expression"]
+});
+(0, _utils.default)("TaggedTemplateExpression", {
+  visitor: ["tag", "quasi"],
+  aliases: ["Expression"],
+  fields: {
+    tag: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    },
+    quasi: {
+      validate: (0, _utils.assertNodeType)("TemplateLiteral")
+    }
+  }
+});
+(0, _utils.default)("TemplateElement", {
+  builder: ["value", "tail"],
+  fields: {
+    value: {},
+    tail: {
+      validate: (0, _utils.assertValueType)("boolean"),
+      default: false
+    }
+  }
+});
+(0, _utils.default)("TemplateLiteral", {
+  visitor: ["quasis", "expressions"],
+  aliases: ["Expression", "Literal"],
+  fields: {
+    quasis: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TemplateElement")))
+    },
+    expressions: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression")))
+    }
+  }
+});
+(0, _utils.default)("YieldExpression", {
+  builder: ["argument", "delegate"],
+  visitor: ["argument"],
+  aliases: ["Expression", "Terminatorless"],
+  fields: {
+    delegate: {
+      validate: (0, _utils.assertValueType)("boolean"),
+      default: false
+    },
+    argument: {
+      optional: true,
+      validate: (0, _utils.assertNodeType)("Expression")
+    }
+  }
+});
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/definitions/experimental.js b/node_modules/@babel/types/lib/definitions/experimental.js
new file mode 100644
index 00000000..510ca241
--- /dev/null
+++ b/node_modules/@babel/types/lib/definitions/experimental.js
@@ -0,0 +1,161 @@
+"use strict";
+
+var _utils = _interopRequireWildcard(require("./utils"));
+
+var _es = require("./es2015");
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+(0, _utils.default)("AwaitExpression", {
+  builder: ["argument"],
+  visitor: ["argument"],
+  aliases: ["Expression", "Terminatorless"],
+  fields: {
+    argument: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    }
+  }
+});
+(0, _utils.default)("BindExpression", {
+  visitor: ["object", "callee"],
+  aliases: ["Expression"],
+  fields: {}
+});
+(0, _utils.default)("ClassProperty", {
+  visitor: ["key", "value", "typeAnnotation", "decorators"],
+  builder: ["key", "value", "typeAnnotation", "decorators", "computed"],
+  aliases: ["Property"],
+  fields: Object.assign({}, _es.classMethodOrPropertyCommon, {
+    value: {
+      validate: (0, _utils.assertNodeType)("Expression"),
+      optional: true
+    },
+    definite: {
+      validate: (0, _utils.assertValueType)("boolean"),
+      optional: true
+    },
+    typeAnnotation: {
+      validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
+      optional: true
+    },
+    decorators: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
+      optional: true
+    },
+    readonly: {
+      validate: (0, _utils.assertValueType)("boolean"),
+      optional: true
+    }
+  })
+});
+(0, _utils.default)("OptionalMemberExpression", {
+  builder: ["object", "property", "computed", "optional"],
+  visitor: ["object", "property"],
+  aliases: ["Expression"],
+  fields: {
+    object: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    },
+    property: {
+      validate: function () {
+        const normal = (0, _utils.assertNodeType)("Identifier");
+        const computed = (0, _utils.assertNodeType)("Expression");
+        return function (node, key, val) {
+          const validator = node.computed ? computed : normal;
+          validator(node, key, val);
+        };
+      }()
+    },
+    computed: {
+      default: false
+    },
+    optional: {
+      validate: (0, _utils.assertValueType)("boolean")
+    }
+  }
+});
+(0, _utils.default)("OptionalCallExpression", {
+  visitor: ["callee", "arguments", "typeParameters"],
+  builder: ["callee", "arguments", "optional"],
+  aliases: ["Expression"],
+  fields: {
+    callee: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    },
+    arguments: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName")))
+    },
+    optional: {
+      validate: (0, _utils.assertValueType)("boolean")
+    },
+    typeParameters: {
+      validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
+      optional: true
+    }
+  }
+});
+(0, _utils.default)("ClassPrivateProperty", {
+  visitor: ["key", "value"],
+  builder: ["key", "value"],
+  aliases: ["Property", "Private"],
+  fields: {
+    key: {
+      validate: (0, _utils.assertNodeType)("PrivateName")
+    },
+    value: {
+      validate: (0, _utils.assertNodeType)("Expression"),
+      optional: true
+    }
+  }
+});
+(0, _utils.default)("Import", {
+  aliases: ["Expression"]
+});
+(0, _utils.default)("Decorator", {
+  visitor: ["callee", "arguments"],
+  fields: {
+    callee: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    },
+    arguments: {
+      optional: true,
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement")))
+    }
+  }
+});
+(0, _utils.default)("DoExpression", {
+  visitor: ["body"],
+  aliases: ["Expression"],
+  fields: {
+    body: {
+      validate: (0, _utils.assertNodeType)("BlockStatement")
+    }
+  }
+});
+(0, _utils.default)("ExportDefaultSpecifier", {
+  visitor: ["exported"],
+  aliases: ["ModuleSpecifier"],
+  fields: {
+    exported: {
+      validate: (0, _utils.assertNodeType)("Identifier")
+    }
+  }
+});
+(0, _utils.default)("ExportNamespaceSpecifier", {
+  visitor: ["exported"],
+  aliases: ["ModuleSpecifier"],
+  fields: {
+    exported: {
+      validate: (0, _utils.assertNodeType)("Identifier")
+    }
+  }
+});
+(0, _utils.default)("PrivateName", {
+  visitor: ["id"],
+  aliases: ["Private"],
+  fields: {
+    id: {
+      validate: (0, _utils.assertNodeType)("Identifier")
+    }
+  }
+});
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/definitions/flow.js b/node_modules/@babel/types/lib/definitions/flow.js
new file mode 100644
index 00000000..25bd1704
--- /dev/null
+++ b/node_modules/@babel/types/lib/definitions/flow.js
@@ -0,0 +1,364 @@
+"use strict";
+
+var _utils = _interopRequireWildcard(require("./utils"));
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+const defineInterfaceishType = (name, typeParameterType = "TypeParameterDeclaration") => {
+  (0, _utils.default)(name, {
+    builder: ["id", "typeParameters", "extends", "body"],
+    visitor: ["id", "typeParameters", "extends", "mixins", "implements", "body"],
+    aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
+    fields: {
+      id: (0, _utils.validateType)("Identifier"),
+      typeParameters: (0, _utils.validateOptionalType)(typeParameterType),
+      extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
+      mixins: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
+      implements: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ClassImplements")),
+      body: (0, _utils.validateType)("ObjectTypeAnnotation")
+    }
+  });
+};
+
+(0, _utils.default)("AnyTypeAnnotation", {
+  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
+});
+(0, _utils.default)("ArrayTypeAnnotation", {
+  visitor: ["elementType"],
+  aliases: ["Flow", "FlowType"],
+  fields: {
+    elementType: (0, _utils.validateType)("FlowType")
+  }
+});
+(0, _utils.default)("BooleanTypeAnnotation", {
+  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
+});
+(0, _utils.default)("BooleanLiteralTypeAnnotation", {
+  builder: ["value"],
+  aliases: ["Flow", "FlowType"],
+  fields: {
+    value: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+  }
+});
+(0, _utils.default)("NullLiteralTypeAnnotation", {
+  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
+});
+(0, _utils.default)("ClassImplements", {
+  visitor: ["id", "typeParameters"],
+  aliases: ["Flow"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
+  }
+});
+defineInterfaceishType("DeclareClass", "TypeParameterInstantiation");
+(0, _utils.default)("DeclareFunction", {
+  visitor: ["id"],
+  aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    predicate: (0, _utils.validateOptionalType)("DeclaredPredicate")
+  }
+});
+defineInterfaceishType("DeclareInterface");
+(0, _utils.default)("DeclareModule", {
+  builder: ["id", "body", "kind"],
+  visitor: ["id", "body"],
+  aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
+  fields: {
+    id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
+    body: (0, _utils.validateType)("BlockStatement"),
+    kind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("CommonJS", "ES"))
+  }
+});
+(0, _utils.default)("DeclareModuleExports", {
+  visitor: ["typeAnnotation"],
+  aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
+  fields: {
+    typeAnnotation: (0, _utils.validateType)("TypeAnnotation")
+  }
+});
+(0, _utils.default)("DeclareTypeAlias", {
+  visitor: ["id", "typeParameters", "right"],
+  aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    right: (0, _utils.validateType)("FlowType")
+  }
+});
+(0, _utils.default)("DeclareOpaqueType", {
+  visitor: ["id", "typeParameters", "supertype"],
+  aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    supertype: (0, _utils.validateOptionalType)("FlowType")
+  }
+});
+(0, _utils.default)("DeclareVariable", {
+  visitor: ["id"],
+  aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier")
+  }
+});
+(0, _utils.default)("DeclareExportDeclaration", {
+  visitor: ["declaration", "specifiers", "source"],
+  aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
+  fields: {
+    declaration: (0, _utils.validateOptionalType)("Flow"),
+    specifiers: (0, _utils.validateOptional)((0, _utils.arrayOfType)(["ExportSpecifier", "ExportNamespaceSpecifier"])),
+    source: (0, _utils.validateOptionalType)("StringLiteral"),
+    default: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
+  }
+});
+(0, _utils.default)("DeclareExportAllDeclaration", {
+  visitor: ["source"],
+  aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
+  fields: {
+    source: (0, _utils.validateType)("StringLiteral"),
+    exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)(["type", "value"]))
+  }
+});
+(0, _utils.default)("DeclaredPredicate", {
+  visitor: ["value"],
+  aliases: ["Flow", "FlowPredicate"],
+  fields: {
+    value: (0, _utils.validateType)("Flow")
+  }
+});
+(0, _utils.default)("ExistsTypeAnnotation", {
+  aliases: ["Flow", "FlowType"]
+});
+(0, _utils.default)("FunctionTypeAnnotation", {
+  visitor: ["typeParameters", "params", "rest", "returnType"],
+  aliases: ["Flow", "FlowType"],
+  fields: {
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    params: (0, _utils.validate)((0, _utils.arrayOfType)("FunctionTypeParam")),
+    rest: (0, _utils.validateOptionalType)("FunctionTypeParam"),
+    returnType: (0, _utils.validateType)("FlowType")
+  }
+});
+(0, _utils.default)("FunctionTypeParam", {
+  visitor: ["name", "typeAnnotation"],
+  aliases: ["Flow"],
+  fields: {
+    name: (0, _utils.validateOptionalType)("Identifier"),
+    typeAnnotation: (0, _utils.validateType)("FlowType"),
+    optional: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
+  }
+});
+(0, _utils.default)("GenericTypeAnnotation", {
+  visitor: ["id", "typeParameters"],
+  aliases: ["Flow", "FlowType"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
+  }
+});
+(0, _utils.default)("InferredPredicate", {
+  aliases: ["Flow", "FlowPredicate"]
+});
+(0, _utils.default)("InterfaceExtends", {
+  visitor: ["id", "typeParameters"],
+  aliases: ["Flow"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
+  }
+});
+defineInterfaceishType("InterfaceDeclaration");
+(0, _utils.default)("IntersectionTypeAnnotation", {
+  visitor: ["types"],
+  aliases: ["Flow", "FlowType"],
+  fields: {
+    types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
+  }
+});
+(0, _utils.default)("MixedTypeAnnotation", {
+  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
+});
+(0, _utils.default)("EmptyTypeAnnotation", {
+  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
+});
+(0, _utils.default)("NullableTypeAnnotation", {
+  visitor: ["typeAnnotation"],
+  aliases: ["Flow", "FlowType"],
+  fields: {
+    typeAnnotation: (0, _utils.validateType)("FlowType")
+  }
+});
+(0, _utils.default)("NumberLiteralTypeAnnotation", {
+  builder: ["value"],
+  aliases: ["Flow", "FlowType"],
+  fields: {
+    value: (0, _utils.validate)((0, _utils.assertValueType)("number"))
+  }
+});
+(0, _utils.default)("NumberTypeAnnotation", {
+  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
+});
+(0, _utils.default)("ObjectTypeAnnotation", {
+  visitor: ["properties", "indexers", "callProperties"],
+  aliases: ["Flow", "FlowType"],
+  builder: ["properties", "indexers", "callProperties", "exact"],
+  fields: {
+    properties: (0, _utils.validate)((0, _utils.arrayOfType)(["ObjectTypeProperty", "ObjectTypeSpreadProperty"])),
+    indexers: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ObjectTypeIndexer")),
+    callProperties: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ObjectTypeCallProperty")),
+    exact: {
+      validate: (0, _utils.assertValueType)("boolean"),
+      default: false
+    }
+  }
+});
+(0, _utils.default)("ObjectTypeCallProperty", {
+  visitor: ["value"],
+  aliases: ["Flow", "UserWhitespacable"],
+  fields: {
+    value: (0, _utils.validateType)("FlowType"),
+    static: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+  }
+});
+(0, _utils.default)("ObjectTypeIndexer", {
+  visitor: ["id", "key", "value", "variance"],
+  aliases: ["Flow", "UserWhitespacable"],
+  fields: {
+    id: (0, _utils.validateOptionalType)("Identifier"),
+    key: (0, _utils.validateType)("FlowType"),
+    value: (0, _utils.validateType)("FlowType"),
+    static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    variance: (0, _utils.validateOptionalType)("Variance")
+  }
+});
+(0, _utils.default)("ObjectTypeProperty", {
+  visitor: ["key", "value", "variance"],
+  aliases: ["Flow", "UserWhitespacable"],
+  fields: {
+    key: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
+    value: (0, _utils.validateType)("FlowType"),
+    kind: (0, _utils.validate)((0, _utils.assertOneOf)("init", "get", "set")),
+    static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    variance: (0, _utils.validateOptionalType)("Variance")
+  }
+});
+(0, _utils.default)("ObjectTypeSpreadProperty", {
+  visitor: ["argument"],
+  aliases: ["Flow", "UserWhitespacable"],
+  fields: {
+    argument: (0, _utils.validateType)("FlowType")
+  }
+});
+(0, _utils.default)("OpaqueType", {
+  visitor: ["id", "typeParameters", "supertype", "impltype"],
+  aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    supertype: (0, _utils.validateOptionalType)("FlowType"),
+    impltype: (0, _utils.validateType)("FlowType")
+  }
+});
+(0, _utils.default)("QualifiedTypeIdentifier", {
+  visitor: ["id", "qualification"],
+  aliases: ["Flow"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    qualification: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"])
+  }
+});
+(0, _utils.default)("StringLiteralTypeAnnotation", {
+  builder: ["value"],
+  aliases: ["Flow", "FlowType"],
+  fields: {
+    value: (0, _utils.validate)((0, _utils.assertValueType)("string"))
+  }
+});
+(0, _utils.default)("StringTypeAnnotation", {
+  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
+});
+(0, _utils.default)("ThisTypeAnnotation", {
+  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
+});
+(0, _utils.default)("TupleTypeAnnotation", {
+  visitor: ["types"],
+  aliases: ["Flow", "FlowType"],
+  fields: {
+    types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
+  }
+});
+(0, _utils.default)("TypeofTypeAnnotation", {
+  visitor: ["argument"],
+  aliases: ["Flow", "FlowType"],
+  fields: {
+    argument: (0, _utils.validateType)("FlowType")
+  }
+});
+(0, _utils.default)("TypeAlias", {
+  visitor: ["id", "typeParameters", "right"],
+  aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    right: (0, _utils.validateType)("FlowType")
+  }
+});
+(0, _utils.default)("TypeAnnotation", {
+  aliases: ["Flow"],
+  visitor: ["typeAnnotation"],
+  fields: {
+    typeAnnotation: (0, _utils.validateType)("FlowType")
+  }
+});
+(0, _utils.default)("TypeCastExpression", {
+  visitor: ["expression", "typeAnnotation"],
+  aliases: ["Flow", "ExpressionWrapper", "Expression"],
+  fields: {
+    expression: (0, _utils.validateType)("Expression"),
+    typeAnnotation: (0, _utils.validateType)("TypeAnnotation")
+  }
+});
+(0, _utils.default)("TypeParameter", {
+  aliases: ["Flow"],
+  visitor: ["bound", "default", "variance"],
+  fields: {
+    name: (0, _utils.validate)((0, _utils.assertValueType)("string")),
+    bound: (0, _utils.validateOptionalType)("TypeAnnotation"),
+    default: (0, _utils.validateOptionalType)("FlowType"),
+    variance: (0, _utils.validateOptionalType)("Variance")
+  }
+});
+(0, _utils.default)("TypeParameterDeclaration", {
+  aliases: ["Flow"],
+  visitor: ["params"],
+  fields: {
+    params: (0, _utils.validate)((0, _utils.arrayOfType)("TypeParameter"))
+  }
+});
+(0, _utils.default)("TypeParameterInstantiation", {
+  aliases: ["Flow"],
+  visitor: ["params"],
+  fields: {
+    params: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
+  }
+});
+(0, _utils.default)("UnionTypeAnnotation", {
+  visitor: ["types"],
+  aliases: ["Flow", "FlowType"],
+  fields: {
+    types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
+  }
+});
+(0, _utils.default)("Variance", {
+  aliases: ["Flow"],
+  builder: ["kind"],
+  fields: {
+    kind: (0, _utils.validate)((0, _utils.assertOneOf)("minus", "plus"))
+  }
+});
+(0, _utils.default)("VoidTypeAnnotation", {
+  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
+});
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/definitions/index.js b/node_modules/@babel/types/lib/definitions/index.js
new file mode 100644
index 00000000..ea17d560
--- /dev/null
+++ b/node_modules/@babel/types/lib/definitions/index.js
@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "VISITOR_KEYS", {
+  enumerable: true,
+  get: function get() {
+    return _utils.VISITOR_KEYS;
+  }
+});
+Object.defineProperty(exports, "ALIAS_KEYS", {
+  enumerable: true,
+  get: function get() {
+    return _utils.ALIAS_KEYS;
+  }
+});
+Object.defineProperty(exports, "FLIPPED_ALIAS_KEYS", {
+  enumerable: true,
+  get: function get() {
+    return _utils.FLIPPED_ALIAS_KEYS;
+  }
+});
+Object.defineProperty(exports, "NODE_FIELDS", {
+  enumerable: true,
+  get: function get() {
+    return _utils.NODE_FIELDS;
+  }
+});
+Object.defineProperty(exports, "BUILDER_KEYS", {
+  enumerable: true,
+  get: function get() {
+    return _utils.BUILDER_KEYS;
+  }
+});
+Object.defineProperty(exports, "DEPRECATED_KEYS", {
+  enumerable: true,
+  get: function get() {
+    return _utils.DEPRECATED_KEYS;
+  }
+});
+exports.TYPES = void 0;
+
+function _toFastProperties() {
+  const data = _interopRequireDefault(require("to-fast-properties"));
+
+  _toFastProperties = function _toFastProperties() {
+    return data;
+  };
+
+  return data;
+}
+
+require("./core");
+
+require("./es2015");
+
+require("./flow");
+
+require("./jsx");
+
+require("./misc");
+
+require("./experimental");
+
+require("./typescript");
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+(0, _toFastProperties().default)(_utils.VISITOR_KEYS);
+(0, _toFastProperties().default)(_utils.ALIAS_KEYS);
+(0, _toFastProperties().default)(_utils.FLIPPED_ALIAS_KEYS);
+(0, _toFastProperties().default)(_utils.NODE_FIELDS);
+(0, _toFastProperties().default)(_utils.BUILDER_KEYS);
+(0, _toFastProperties().default)(_utils.DEPRECATED_KEYS);
+const TYPES = Object.keys(_utils.VISITOR_KEYS).concat(Object.keys(_utils.FLIPPED_ALIAS_KEYS)).concat(Object.keys(_utils.DEPRECATED_KEYS));
+exports.TYPES = TYPES;
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/definitions/jsx.js b/node_modules/@babel/types/lib/definitions/jsx.js
new file mode 100644
index 00000000..0ed8978b
--- /dev/null
+++ b/node_modules/@babel/types/lib/definitions/jsx.js
@@ -0,0 +1,156 @@
+"use strict";
+
+var _utils = _interopRequireWildcard(require("./utils"));
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+(0, _utils.default)("JSXAttribute", {
+  visitor: ["name", "value"],
+  aliases: ["JSX", "Immutable"],
+  fields: {
+    name: {
+      validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXNamespacedName")
+    },
+    value: {
+      optional: true,
+      validate: (0, _utils.assertNodeType)("JSXElement", "JSXFragment", "StringLiteral", "JSXExpressionContainer")
+    }
+  }
+});
+(0, _utils.default)("JSXClosingElement", {
+  visitor: ["name"],
+  aliases: ["JSX", "Immutable"],
+  fields: {
+    name: {
+      validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression")
+    }
+  }
+});
+(0, _utils.default)("JSXElement", {
+  builder: ["openingElement", "closingElement", "children", "selfClosing"],
+  visitor: ["openingElement", "children", "closingElement"],
+  aliases: ["JSX", "Immutable", "Expression"],
+  fields: {
+    openingElement: {
+      validate: (0, _utils.assertNodeType)("JSXOpeningElement")
+    },
+    closingElement: {
+      optional: true,
+      validate: (0, _utils.assertNodeType)("JSXClosingElement")
+    },
+    children: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment")))
+    }
+  }
+});
+(0, _utils.default)("JSXEmptyExpression", {
+  aliases: ["JSX"]
+});
+(0, _utils.default)("JSXExpressionContainer", {
+  visitor: ["expression"],
+  aliases: ["JSX", "Immutable"],
+  fields: {
+    expression: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    }
+  }
+});
+(0, _utils.default)("JSXSpreadChild", {
+  visitor: ["expression"],
+  aliases: ["JSX", "Immutable"],
+  fields: {
+    expression: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    }
+  }
+});
+(0, _utils.default)("JSXIdentifier", {
+  builder: ["name"],
+  aliases: ["JSX"],
+  fields: {
+    name: {
+      validate: (0, _utils.assertValueType)("string")
+    }
+  }
+});
+(0, _utils.default)("JSXMemberExpression", {
+  visitor: ["object", "property"],
+  aliases: ["JSX"],
+  fields: {
+    object: {
+      validate: (0, _utils.assertNodeType)("JSXMemberExpression", "JSXIdentifier")
+    },
+    property: {
+      validate: (0, _utils.assertNodeType)("JSXIdentifier")
+    }
+  }
+});
+(0, _utils.default)("JSXNamespacedName", {
+  visitor: ["namespace", "name"],
+  aliases: ["JSX"],
+  fields: {
+    namespace: {
+      validate: (0, _utils.assertNodeType)("JSXIdentifier")
+    },
+    name: {
+      validate: (0, _utils.assertNodeType)("JSXIdentifier")
+    }
+  }
+});
+(0, _utils.default)("JSXOpeningElement", {
+  builder: ["name", "attributes", "selfClosing"],
+  visitor: ["name", "attributes"],
+  aliases: ["JSX", "Immutable"],
+  fields: {
+    name: {
+      validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression")
+    },
+    selfClosing: {
+      default: false,
+      validate: (0, _utils.assertValueType)("boolean")
+    },
+    attributes: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXAttribute", "JSXSpreadAttribute")))
+    }
+  }
+});
+(0, _utils.default)("JSXSpreadAttribute", {
+  visitor: ["argument"],
+  aliases: ["JSX"],
+  fields: {
+    argument: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    }
+  }
+});
+(0, _utils.default)("JSXText", {
+  aliases: ["JSX", "Immutable"],
+  builder: ["value"],
+  fields: {
+    value: {
+      validate: (0, _utils.assertValueType)("string")
+    }
+  }
+});
+(0, _utils.default)("JSXFragment", {
+  builder: ["openingFragment", "closingFragment", "children"],
+  visitor: ["openingFragment", "children", "closingFragment"],
+  aliases: ["JSX", "Immutable", "Expression"],
+  fields: {
+    openingFragment: {
+      validate: (0, _utils.assertNodeType)("JSXOpeningFragment")
+    },
+    closingFragment: {
+      validate: (0, _utils.assertNodeType)("JSXClosingFragment")
+    },
+    children: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment")))
+    }
+  }
+});
+(0, _utils.default)("JSXOpeningFragment", {
+  aliases: ["JSX", "Immutable"]
+});
+(0, _utils.default)("JSXClosingFragment", {
+  aliases: ["JSX", "Immutable"]
+});
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/definitions/misc.js b/node_modules/@babel/types/lib/definitions/misc.js
new file mode 100644
index 00000000..714f2979
--- /dev/null
+++ b/node_modules/@babel/types/lib/definitions/misc.js
@@ -0,0 +1,18 @@
+"use strict";
+
+var _utils = _interopRequireWildcard(require("./utils"));
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+(0, _utils.default)("Noop", {
+  visitor: []
+});
+(0, _utils.default)("ParenthesizedExpression", {
+  visitor: ["expression"],
+  aliases: ["Expression", "ExpressionWrapper"],
+  fields: {
+    expression: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    }
+  }
+});
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/definitions/typescript.js b/node_modules/@babel/types/lib/definitions/typescript.js
new file mode 100644
index 00000000..9910fb62
--- /dev/null
+++ b/node_modules/@babel/types/lib/definitions/typescript.js
@@ -0,0 +1,389 @@
+"use strict";
+
+var _utils = _interopRequireWildcard(require("./utils"));
+
+var _core = require("./core");
+
+var _es = require("./es2015");
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+const bool = (0, _utils.assertValueType)("boolean");
+const tSFunctionTypeAnnotationCommon = {
+  returnType: {
+    validate: (0, _utils.assertNodeType)("TSTypeAnnotation", "Noop"),
+    optional: true
+  },
+  typeParameters: {
+    validate: (0, _utils.assertNodeType)("TSTypeParameterDeclaration", "Noop"),
+    optional: true
+  }
+};
+(0, _utils.default)("TSParameterProperty", {
+  aliases: ["LVal"],
+  visitor: ["parameter"],
+  fields: {
+    accessibility: {
+      validate: (0, _utils.assertOneOf)("public", "private", "protected"),
+      optional: true
+    },
+    readonly: {
+      validate: (0, _utils.assertValueType)("boolean"),
+      optional: true
+    },
+    parameter: {
+      validate: (0, _utils.assertNodeType)("Identifier", "AssignmentPattern")
+    }
+  }
+});
+(0, _utils.default)("TSDeclareFunction", {
+  aliases: ["Statement", "Declaration"],
+  visitor: ["id", "typeParameters", "params", "returnType"],
+  fields: Object.assign({}, _core.functionDeclarationCommon, tSFunctionTypeAnnotationCommon)
+});
+(0, _utils.default)("TSDeclareMethod", {
+  visitor: ["decorators", "key", "typeParameters", "params", "returnType"],
+  fields: Object.assign({}, _es.classMethodOrDeclareMethodCommon, tSFunctionTypeAnnotationCommon)
+});
+(0, _utils.default)("TSQualifiedName", {
+  aliases: ["TSEntityName"],
+  visitor: ["left", "right"],
+  fields: {
+    left: (0, _utils.validateType)("TSEntityName"),
+    right: (0, _utils.validateType)("Identifier")
+  }
+});
+const signatureDeclarationCommon = {
+  typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
+  parameters: (0, _utils.validateArrayOfType)(["Identifier", "RestElement"]),
+  typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation")
+};
+const callConstructSignatureDeclaration = {
+  aliases: ["TSTypeElement"],
+  visitor: ["typeParameters", "parameters", "typeAnnotation"],
+  fields: signatureDeclarationCommon
+};
+(0, _utils.default)("TSCallSignatureDeclaration", callConstructSignatureDeclaration);
+(0, _utils.default)("TSConstructSignatureDeclaration", callConstructSignatureDeclaration);
+const namedTypeElementCommon = {
+  key: (0, _utils.validateType)("Expression"),
+  computed: (0, _utils.validate)(bool),
+  optional: (0, _utils.validateOptional)(bool)
+};
+(0, _utils.default)("TSPropertySignature", {
+  aliases: ["TSTypeElement"],
+  visitor: ["key", "typeAnnotation", "initializer"],
+  fields: Object.assign({}, namedTypeElementCommon, {
+    readonly: (0, _utils.validateOptional)(bool),
+    typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"),
+    initializer: (0, _utils.validateOptionalType)("Expression")
+  })
+});
+(0, _utils.default)("TSMethodSignature", {
+  aliases: ["TSTypeElement"],
+  visitor: ["key", "typeParameters", "parameters", "typeAnnotation"],
+  fields: Object.assign({}, signatureDeclarationCommon, namedTypeElementCommon)
+});
+(0, _utils.default)("TSIndexSignature", {
+  aliases: ["TSTypeElement"],
+  visitor: ["parameters", "typeAnnotation"],
+  fields: {
+    readonly: (0, _utils.validateOptional)(bool),
+    parameters: (0, _utils.validateArrayOfType)("Identifier"),
+    typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation")
+  }
+});
+const tsKeywordTypes = ["TSAnyKeyword", "TSNumberKeyword", "TSObjectKeyword", "TSBooleanKeyword", "TSStringKeyword", "TSSymbolKeyword", "TSVoidKeyword", "TSUndefinedKeyword", "TSNullKeyword", "TSNeverKeyword"];
+
+for (var _i = 0; _i < tsKeywordTypes.length; _i++) {
+  const type = tsKeywordTypes[_i];
+  (0, _utils.default)(type, {
+    aliases: ["TSType"],
+    visitor: [],
+    fields: {}
+  });
+}
+
+(0, _utils.default)("TSThisType", {
+  aliases: ["TSType"],
+  visitor: [],
+  fields: {}
+});
+const fnOrCtr = {
+  aliases: ["TSType"],
+  visitor: ["typeParameters", "typeAnnotation"],
+  fields: signatureDeclarationCommon
+};
+(0, _utils.default)("TSFunctionType", fnOrCtr);
+(0, _utils.default)("TSConstructorType", fnOrCtr);
+(0, _utils.default)("TSTypeReference", {
+  aliases: ["TSType"],
+  visitor: ["typeName", "typeParameters"],
+  fields: {
+    typeName: (0, _utils.validateType)("TSEntityName"),
+    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
+  }
+});
+(0, _utils.default)("TSTypePredicate", {
+  aliases: ["TSType"],
+  visitor: ["parameterName", "typeAnnotation"],
+  fields: {
+    parameterName: (0, _utils.validateType)(["Identifier", "TSThisType"]),
+    typeAnnotation: (0, _utils.validateType)("TSTypeAnnotation")
+  }
+});
+(0, _utils.default)("TSTypeQuery", {
+  aliases: ["TSType"],
+  visitor: ["exprName"],
+  fields: {
+    exprName: (0, _utils.validateType)("TSEntityName")
+  }
+});
+(0, _utils.default)("TSTypeLiteral", {
+  aliases: ["TSType"],
+  visitor: ["members"],
+  fields: {
+    members: (0, _utils.validateArrayOfType)("TSTypeElement")
+  }
+});
+(0, _utils.default)("TSArrayType", {
+  aliases: ["TSType"],
+  visitor: ["elementType"],
+  fields: {
+    elementType: (0, _utils.validateType)("TSType")
+  }
+});
+(0, _utils.default)("TSTupleType", {
+  aliases: ["TSType"],
+  visitor: ["elementTypes"],
+  fields: {
+    elementTypes: (0, _utils.validateArrayOfType)("TSType")
+  }
+});
+const unionOrIntersection = {
+  aliases: ["TSType"],
+  visitor: ["types"],
+  fields: {
+    types: (0, _utils.validateArrayOfType)("TSType")
+  }
+};
+(0, _utils.default)("TSUnionType", unionOrIntersection);
+(0, _utils.default)("TSIntersectionType", unionOrIntersection);
+(0, _utils.default)("TSConditionalType", {
+  aliases: ["TSType"],
+  visitor: ["checkType", "extendsType", "trueType", "falseType"],
+  fields: {
+    checkType: (0, _utils.validateType)("TSType"),
+    extendsType: (0, _utils.validateType)("TSType"),
+    trueType: (0, _utils.validateType)("TSType"),
+    falseType: (0, _utils.validateType)("TSType")
+  }
+});
+(0, _utils.default)("TSInferType", {
+  aliases: ["TSType"],
+  visitor: ["typeParameter"],
+  fields: {
+    typeParameter: (0, _utils.validateType)("TSType")
+  }
+});
+(0, _utils.default)("TSParenthesizedType", {
+  aliases: ["TSType"],
+  visitor: ["typeAnnotation"],
+  fields: {
+    typeAnnotation: (0, _utils.validateType)("TSType")
+  }
+});
+(0, _utils.default)("TSTypeOperator", {
+  aliases: ["TSType"],
+  visitor: ["typeAnnotation"],
+  fields: {
+    operator: (0, _utils.validate)((0, _utils.assertValueType)("string")),
+    typeAnnotation: (0, _utils.validateType)("TSType")
+  }
+});
+(0, _utils.default)("TSIndexedAccessType", {
+  aliases: ["TSType"],
+  visitor: ["objectType", "indexType"],
+  fields: {
+    objectType: (0, _utils.validateType)("TSType"),
+    indexType: (0, _utils.validateType)("TSType")
+  }
+});
+(0, _utils.default)("TSMappedType", {
+  aliases: ["TSType"],
+  visitor: ["typeParameter", "typeAnnotation"],
+  fields: {
+    readonly: (0, _utils.validateOptional)(bool),
+    typeParameter: (0, _utils.validateType)("TSTypeParameter"),
+    optional: (0, _utils.validateOptional)(bool),
+    typeAnnotation: (0, _utils.validateOptionalType)("TSType")
+  }
+});
+(0, _utils.default)("TSLiteralType", {
+  aliases: ["TSType"],
+  visitor: ["literal"],
+  fields: {
+    literal: (0, _utils.validateType)(["NumericLiteral", "StringLiteral", "BooleanLiteral"])
+  }
+});
+(0, _utils.default)("TSExpressionWithTypeArguments", {
+  aliases: ["TSType"],
+  visitor: ["expression", "typeParameters"],
+  fields: {
+    expression: (0, _utils.validateType)("TSEntityName"),
+    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
+  }
+});
+(0, _utils.default)("TSInterfaceDeclaration", {
+  aliases: ["Statement", "Declaration"],
+  visitor: ["id", "typeParameters", "extends", "body"],
+  fields: {
+    declare: (0, _utils.validateOptional)(bool),
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
+    extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("TSExpressionWithTypeArguments")),
+    body: (0, _utils.validateType)("TSInterfaceBody")
+  }
+});
+(0, _utils.default)("TSInterfaceBody", {
+  visitor: ["body"],
+  fields: {
+    body: (0, _utils.validateArrayOfType)("TSTypeElement")
+  }
+});
+(0, _utils.default)("TSTypeAliasDeclaration", {
+  aliases: ["Statement", "Declaration"],
+  visitor: ["id", "typeParameters", "typeAnnotation"],
+  fields: {
+    declare: (0, _utils.validateOptional)(bool),
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
+    typeAnnotation: (0, _utils.validateType)("TSType")
+  }
+});
+(0, _utils.default)("TSAsExpression", {
+  aliases: ["Expression"],
+  visitor: ["expression", "typeAnnotation"],
+  fields: {
+    expression: (0, _utils.validateType)("Expression"),
+    typeAnnotation: (0, _utils.validateType)("TSType")
+  }
+});
+(0, _utils.default)("TSTypeAssertion", {
+  aliases: ["Expression"],
+  visitor: ["typeAnnotation", "expression"],
+  fields: {
+    typeAnnotation: (0, _utils.validateType)("TSType"),
+    expression: (0, _utils.validateType)("Expression")
+  }
+});
+(0, _utils.default)("TSEnumDeclaration", {
+  aliases: ["Statement", "Declaration"],
+  visitor: ["id", "members"],
+  fields: {
+    declare: (0, _utils.validateOptional)(bool),
+    const: (0, _utils.validateOptional)(bool),
+    id: (0, _utils.validateType)("Identifier"),
+    members: (0, _utils.validateArrayOfType)("TSEnumMember"),
+    initializer: (0, _utils.validateOptionalType)("Expression")
+  }
+});
+(0, _utils.default)("TSEnumMember", {
+  visitor: ["id", "initializer"],
+  fields: {
+    id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
+    initializer: (0, _utils.validateOptionalType)("Expression")
+  }
+});
+(0, _utils.default)("TSModuleDeclaration", {
+  aliases: ["Statement", "Declaration"],
+  visitor: ["id", "body"],
+  fields: {
+    declare: (0, _utils.validateOptional)(bool),
+    global: (0, _utils.validateOptional)(bool),
+    id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
+    body: (0, _utils.validateType)(["TSModuleBlock", "TSModuleDeclaration"])
+  }
+});
+(0, _utils.default)("TSModuleBlock", {
+  visitor: ["body"],
+  fields: {
+    body: (0, _utils.validateArrayOfType)("Statement")
+  }
+});
+(0, _utils.default)("TSImportEqualsDeclaration", {
+  aliases: ["Statement"],
+  visitor: ["id", "moduleReference"],
+  fields: {
+    isExport: (0, _utils.validate)(bool),
+    id: (0, _utils.validateType)("Identifier"),
+    moduleReference: (0, _utils.validateType)(["TSEntityName", "TSExternalModuleReference"])
+  }
+});
+(0, _utils.default)("TSExternalModuleReference", {
+  visitor: ["expression"],
+  fields: {
+    expression: (0, _utils.validateType)("StringLiteral")
+  }
+});
+(0, _utils.default)("TSNonNullExpression", {
+  aliases: ["Expression"],
+  visitor: ["expression"],
+  fields: {
+    expression: (0, _utils.validateType)("Expression")
+  }
+});
+(0, _utils.default)("TSExportAssignment", {
+  aliases: ["Statement"],
+  visitor: ["expression"],
+  fields: {
+    expression: (0, _utils.validateType)("Expression")
+  }
+});
+(0, _utils.default)("TSNamespaceExportDeclaration", {
+  aliases: ["Statement"],
+  visitor: ["id"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier")
+  }
+});
+(0, _utils.default)("TSTypeAnnotation", {
+  visitor: ["typeAnnotation"],
+  fields: {
+    typeAnnotation: {
+      validate: (0, _utils.assertNodeType)("TSType")
+    }
+  }
+});
+(0, _utils.default)("TSTypeParameterInstantiation", {
+  visitor: ["params"],
+  fields: {
+    params: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSType")))
+    }
+  }
+});
+(0, _utils.default)("TSTypeParameterDeclaration", {
+  visitor: ["params"],
+  fields: {
+    params: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSTypeParameter")))
+    }
+  }
+});
+(0, _utils.default)("TSTypeParameter", {
+  visitor: ["constraint", "default"],
+  fields: {
+    name: {
+      validate: (0, _utils.assertValueType)("string")
+    },
+    constraint: {
+      validate: (0, _utils.assertNodeType)("TSType"),
+      optional: true
+    },
+    default: {
+      validate: (0, _utils.assertNodeType)("TSType"),
+      optional: true
+    }
+  }
+});
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/definitions/utils.js b/node_modules/@babel/types/lib/definitions/utils.js
new file mode 100644
index 00000000..2cd5faec
--- /dev/null
+++ b/node_modules/@babel/types/lib/definitions/utils.js
@@ -0,0 +1,228 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validate = validate;
+exports.typeIs = typeIs;
+exports.validateType = validateType;
+exports.validateOptional = validateOptional;
+exports.validateOptionalType = validateOptionalType;
+exports.arrayOf = arrayOf;
+exports.arrayOfType = arrayOfType;
+exports.validateArrayOfType = validateArrayOfType;
+exports.assertEach = assertEach;
+exports.assertOneOf = assertOneOf;
+exports.assertNodeType = assertNodeType;
+exports.assertNodeOrValueType = assertNodeOrValueType;
+exports.assertValueType = assertValueType;
+exports.chain = chain;
+exports.default = defineType;
+exports.DEPRECATED_KEYS = exports.BUILDER_KEYS = exports.NODE_FIELDS = exports.FLIPPED_ALIAS_KEYS = exports.ALIAS_KEYS = exports.VISITOR_KEYS = void 0;
+
+var _is = _interopRequireDefault(require("../validators/is"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const VISITOR_KEYS = {};
+exports.VISITOR_KEYS = VISITOR_KEYS;
+const ALIAS_KEYS = {};
+exports.ALIAS_KEYS = ALIAS_KEYS;
+const FLIPPED_ALIAS_KEYS = {};
+exports.FLIPPED_ALIAS_KEYS = FLIPPED_ALIAS_KEYS;
+const NODE_FIELDS = {};
+exports.NODE_FIELDS = NODE_FIELDS;
+const BUILDER_KEYS = {};
+exports.BUILDER_KEYS = BUILDER_KEYS;
+const DEPRECATED_KEYS = {};
+exports.DEPRECATED_KEYS = DEPRECATED_KEYS;
+
+function getType(val) {
+  if (Array.isArray(val)) {
+    return "array";
+  } else if (val === null) {
+    return "null";
+  } else if (val === undefined) {
+    return "undefined";
+  } else {
+    return typeof val;
+  }
+}
+
+function validate(validate) {
+  return {
+    validate
+  };
+}
+
+function typeIs(typeName) {
+  return typeof typeName === "string" ? assertNodeType(typeName) : assertNodeType(...typeName);
+}
+
+function validateType(typeName) {
+  return validate(typeIs(typeName));
+}
+
+function validateOptional(validate) {
+  return {
+    validate,
+    optional: true
+  };
+}
+
+function validateOptionalType(typeName) {
+  return {
+    validate: typeIs(typeName),
+    optional: true
+  };
+}
+
+function arrayOf(elementType) {
+  return chain(assertValueType("array"), assertEach(elementType));
+}
+
+function arrayOfType(typeName) {
+  return arrayOf(typeIs(typeName));
+}
+
+function validateArrayOfType(typeName) {
+  return validate(arrayOfType(typeName));
+}
+
+function assertEach(callback) {
+  function validator(node, key, val) {
+    if (!Array.isArray(val)) return;
+
+    for (let i = 0; i < val.length; i++) {
+      callback(node, `${key}[${i}]`, val[i]);
+    }
+  }
+
+  validator.each = callback;
+  return validator;
+}
+
+function assertOneOf(...values) {
+  function validate(node, key, val) {
+    if (values.indexOf(val) < 0) {
+      throw new TypeError(`Property ${key} expected value to be one of ${JSON.stringify(values)} but got ${JSON.stringify(val)}`);
+    }
+  }
+
+  validate.oneOf = values;
+  return validate;
+}
+
+function assertNodeType(...types) {
+  function validate(node, key, val) {
+    let valid = false;
+
+    for (var _i = 0; _i < types.length; _i++) {
+      const type = types[_i];
+
+      if ((0, _is.default)(type, val)) {
+        valid = true;
+        break;
+      }
+    }
+
+    if (!valid) {
+      throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} ` + `but instead got ${JSON.stringify(val && val.type)}`);
+    }
+  }
+
+  validate.oneOfNodeTypes = types;
+  return validate;
+}
+
+function assertNodeOrValueType(...types) {
+  function validate(node, key, val) {
+    let valid = false;
+
+    for (var _i2 = 0; _i2 < types.length; _i2++) {
+      const type = types[_i2];
+
+      if (getType(val) === type || (0, _is.default)(type, val)) {
+        valid = true;
+        break;
+      }
+    }
+
+    if (!valid) {
+      throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} ` + `but instead got ${JSON.stringify(val && val.type)}`);
+    }
+  }
+
+  validate.oneOfNodeOrValueTypes = types;
+  return validate;
+}
+
+function assertValueType(type) {
+  function validate(node, key, val) {
+    const valid = getType(val) === type;
+
+    if (!valid) {
+      throw new TypeError(`Property ${key} expected type of ${type} but got ${getType(val)}`);
+    }
+  }
+
+  validate.type = type;
+  return validate;
+}
+
+function chain(...fns) {
+  function validate(...args) {
+    for (var _i3 = 0; _i3 < fns.length; _i3++) {
+      const fn = fns[_i3];
+      fn(...args);
+    }
+  }
+
+  validate.chainOf = fns;
+  return validate;
+}
+
+function defineType(type, opts = {}) {
+  const inherits = opts.inherits && store[opts.inherits] || {};
+  const fields = opts.fields || inherits.fields || {};
+  const visitor = opts.visitor || inherits.visitor || [];
+  const aliases = opts.aliases || inherits.aliases || [];
+  const builder = opts.builder || inherits.builder || opts.visitor || [];
+
+  if (opts.deprecatedAlias) {
+    DEPRECATED_KEYS[opts.deprecatedAlias] = type;
+  }
+
+  var _arr = visitor.concat(builder);
+
+  for (var _i4 = 0; _i4 < _arr.length; _i4++) {
+    const key = _arr[_i4];
+    fields[key] = fields[key] || {};
+  }
+
+  for (const key in fields) {
+    const field = fields[key];
+
+    if (builder.indexOf(key) === -1) {
+      field.optional = true;
+    }
+
+    if (field.default === undefined) {
+      field.default = null;
+    } else if (!field.validate) {
+      field.validate = assertValueType(getType(field.default));
+    }
+  }
+
+  VISITOR_KEYS[type] = opts.visitor = visitor;
+  BUILDER_KEYS[type] = opts.builder = builder;
+  NODE_FIELDS[type] = opts.fields = fields;
+  ALIAS_KEYS[type] = opts.aliases = aliases;
+  aliases.forEach(alias => {
+    FLIPPED_ALIAS_KEYS[alias] = FLIPPED_ALIAS_KEYS[alias] || [];
+    FLIPPED_ALIAS_KEYS[alias].push(type);
+  });
+  store[type] = opts;
+}
+
+const store = {};
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/index.d.ts b/node_modules/@babel/types/lib/index.d.ts
new file mode 100644
index 00000000..957d62e8
--- /dev/null
+++ b/node_modules/@babel/types/lib/index.d.ts
@@ -0,0 +1,1880 @@
+// NOTE: This file is autogenerated. Do not modify.
+// See scripts/generators/typescript.js for script used.
+
+interface BaseComment {
+  value: string;
+  start: number;
+  end: number;
+  loc: SourceLocation;
+  type: "BlockComment" | "LineComment";
+}
+
+export interface BlockComment extends BaseComment {
+  type: "BlockComment";
+}
+
+export interface LineComment extends BaseComment {
+  type: "LineComment";
+}
+
+export type Comment = BlockComment | LineComment;
+
+export interface SourceLocation {
+  start: {
+    line: number;
+    column: number;
+  };
+
+  end: {
+    line: number;
+    column: number;
+  };
+}
+
+interface BaseNode {
+  leadingComments: ReadonlyArray<Comment> | null;
+  innerComments: ReadonlyArray<Comment> | null;
+  trailingComments: ReadonlyArray<Comment> | null;
+  start: number | null;
+  end: number | null;
+  loc: SourceLocation | null;
+  type: Node["type"];
+}
+
+export type Node = AnyTypeAnnotation | ArrayExpression | ArrayPattern | ArrayTypeAnnotation | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | Binary | BinaryExpression | BindExpression | Block | BlockParent | BlockStatement | BooleanLiteral | BooleanLiteralTypeAnnotation | BooleanTypeAnnotation | BreakStatement | CallExpression | CatchClause | Class | ClassBody | ClassDeclaration | ClassExpression | ClassImplements | ClassMethod | ClassPrivateProperty | ClassProperty | CompletionStatement | Conditional | ConditionalExpression | ContinueStatement | DebuggerStatement | Declaration | DeclareClass | DeclareExportAllDeclaration | DeclareExportDeclaration | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareOpaqueType | DeclareTypeAlias | DeclareVariable | DeclaredPredicate | Decorator | Directive | DirectiveLiteral | DoExpression | DoWhileStatement | EmptyStatement | EmptyTypeAnnotation | ExistsTypeAnnotation | ExportAllDeclaration | ExportDeclaration | ExportDefaultDeclaration | ExportDefaultSpecifier | ExportNamedDeclaration | ExportNamespaceSpecifier | ExportSpecifier | Expression | ExpressionStatement | ExpressionWrapper | File | Flow | FlowBaseAnnotation | FlowDeclaration | FlowPredicate | FlowType | For | ForInStatement | ForOfStatement | ForStatement | ForXStatement | Function | FunctionDeclaration | FunctionExpression | FunctionParent | FunctionTypeAnnotation | FunctionTypeParam | GenericTypeAnnotation | Identifier | IfStatement | Immutable | Import | ImportDeclaration | ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportSpecifier | InferredPredicate | InterfaceDeclaration | InterfaceExtends | IntersectionTypeAnnotation | JSX | JSXAttribute | JSXClosingElement | JSXClosingFragment | JSXElement | JSXEmptyExpression | JSXExpressionContainer | JSXFragment | JSXIdentifier | JSXMemberExpression | JSXNamespacedName | JSXOpeningElement | JSXOpeningFragment | JSXSpreadAttribute | JSXSpreadChild | JSXText | LVal | LabeledStatement | Literal | LogicalExpression | Loop | MemberExpression | MetaProperty | Method | MixedTypeAnnotation | ModuleDeclaration | ModuleSpecifier | NewExpression | Noop | NullLiteral | NullLiteralTypeAnnotation | NullableTypeAnnotation | NumberLiteral | NumberLiteralTypeAnnotation | NumberTypeAnnotation | NumericLiteral | ObjectExpression | ObjectMember | ObjectMethod | ObjectPattern | ObjectProperty | ObjectTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalCallExpression | OptionalMemberExpression | ParenthesizedExpression | Pattern | PatternLike | Private | PrivateName | Program | Property | Pureish | QualifiedTypeIdentifier | RegExpLiteral | RegexLiteral | RestElement | RestProperty | ReturnStatement | Scopable | SequenceExpression | SpreadElement | SpreadProperty | Statement | StringLiteral | StringLiteralTypeAnnotation | StringTypeAnnotation | Super | SwitchCase | SwitchStatement | TSAnyKeyword | TSArrayType | TSAsExpression | TSBooleanKeyword | TSCallSignatureDeclaration | TSConditionalType | TSConstructSignatureDeclaration | TSConstructorType | TSDeclareFunction | TSDeclareMethod | TSEntityName | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSExpressionWithTypeArguments | TSExternalModuleReference | TSFunctionType | TSImportEqualsDeclaration | TSIndexSignature | TSIndexedAccessType | TSInferType | TSInterfaceBody | TSInterfaceDeclaration | TSIntersectionType | TSLiteralType | TSMappedType | TSMethodSignature | TSModuleBlock | TSModuleDeclaration | TSNamespaceExportDeclaration | TSNeverKeyword | TSNonNullExpression | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSParameterProperty | TSParenthesizedType | TSPropertySignature | TSQualifiedName | TSStringKeyword | TSSymbolKeyword | TSThisType | TSTupleType | TSType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeElement | TSTypeLiteral | TSTypeOperator | TSTypeParameter | TSTypeParameterDeclaration | TSTypeParameterInstantiation | TSTypePredicate | TSTypeQuery | TSTypeReference | TSUndefinedKeyword | TSUnionType | TSVoidKeyword | TaggedTemplateExpression | TemplateElement | TemplateLiteral | Terminatorless | ThisExpression | ThisTypeAnnotation | ThrowStatement | TryStatement | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeCastExpression | TypeParameter | TypeParameterDeclaration | TypeParameterInstantiation | TypeofTypeAnnotation | UnaryExpression | UnaryLike | UnionTypeAnnotation | UpdateExpression | UserWhitespacable | VariableDeclaration | VariableDeclarator | Variance | VoidTypeAnnotation | While | WhileStatement | WithStatement | YieldExpression;
+
+export interface ArrayExpression extends BaseNode {
+  type: "ArrayExpression";
+  elements: Array<null | Expression | SpreadElement>;
+}
+
+export interface AssignmentExpression extends BaseNode {
+  type: "AssignmentExpression";
+  operator: string;
+  left: LVal;
+  right: Expression;
+}
+
+export interface BinaryExpression extends BaseNode {
+  type: "BinaryExpression";
+  operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=";
+  left: Expression;
+  right: Expression;
+}
+
+export interface Directive extends BaseNode {
+  type: "Directive";
+  value: DirectiveLiteral;
+}
+
+export interface DirectiveLiteral extends BaseNode {
+  type: "DirectiveLiteral";
+  value: string;
+}
+
+export interface BlockStatement extends BaseNode {
+  type: "BlockStatement";
+  body: Array<Statement>;
+  directives: Array<Directive>;
+}
+
+export interface BreakStatement extends BaseNode {
+  type: "BreakStatement";
+  label: Identifier | null;
+}
+
+export interface CallExpression extends BaseNode {
+  type: "CallExpression";
+  callee: Expression;
+  arguments: Array<Expression | SpreadElement | JSXNamespacedName>;
+  optional: true | false | null;
+  typeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
+}
+
+export interface CatchClause extends BaseNode {
+  type: "CatchClause";
+  param: Identifier | null;
+  body: BlockStatement;
+}
+
+export interface ConditionalExpression extends BaseNode {
+  type: "ConditionalExpression";
+  test: Expression;
+  consequent: Expression;
+  alternate: Expression;
+}
+
+export interface ContinueStatement extends BaseNode {
+  type: "ContinueStatement";
+  label: Identifier | null;
+}
+
+export interface DebuggerStatement extends BaseNode {
+  type: "DebuggerStatement";
+}
+
+export interface DoWhileStatement extends BaseNode {
+  type: "DoWhileStatement";
+  test: Expression;
+  body: Statement;
+}
+
+export interface EmptyStatement extends BaseNode {
+  type: "EmptyStatement";
+}
+
+export interface ExpressionStatement extends BaseNode {
+  type: "ExpressionStatement";
+  expression: Expression;
+}
+
+export interface File extends BaseNode {
+  type: "File";
+  program: Program;
+  comments: any;
+  tokens: any;
+}
+
+export interface ForInStatement extends BaseNode {
+  type: "ForInStatement";
+  left: VariableDeclaration | LVal;
+  right: Expression;
+  body: Statement;
+}
+
+export interface ForStatement extends BaseNode {
+  type: "ForStatement";
+  init: VariableDeclaration | Expression | null;
+  test: Expression | null;
+  update: Expression | null;
+  body: Statement;
+}
+
+export interface FunctionDeclaration extends BaseNode {
+  type: "FunctionDeclaration";
+  id: Identifier | null;
+  params: Array<LVal>;
+  body: BlockStatement;
+  generator: boolean;
+  async: boolean;
+  declare: boolean | null;
+  returnType: TypeAnnotation | TSTypeAnnotation | Noop | null;
+  typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
+}
+
+export interface FunctionExpression extends BaseNode {
+  type: "FunctionExpression";
+  id: Identifier | null;
+  params: Array<LVal>;
+  body: BlockStatement;
+  generator: boolean;
+  async: boolean;
+  returnType: TypeAnnotation | TSTypeAnnotation | Noop | null;
+  typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
+}
+
+export interface Identifier extends BaseNode {
+  type: "Identifier";
+  name: string;
+  decorators: Array<Decorator> | null;
+  optional: boolean | null;
+  typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
+}
+
+export interface IfStatement extends BaseNode {
+  type: "IfStatement";
+  test: Expression;
+  consequent: Statement;
+  alternate: Statement | null;
+}
+
+export interface LabeledStatement extends BaseNode {
+  type: "LabeledStatement";
+  label: Identifier;
+  body: Statement;
+}
+
+export interface StringLiteral extends BaseNode {
+  type: "StringLiteral";
+  value: string;
+}
+
+export interface NumericLiteral extends BaseNode {
+  type: "NumericLiteral";
+  value: number;
+}
+
+export interface NullLiteral extends BaseNode {
+  type: "NullLiteral";
+}
+
+export interface BooleanLiteral extends BaseNode {
+  type: "BooleanLiteral";
+  value: boolean;
+}
+
+export interface RegExpLiteral extends BaseNode {
+  type: "RegExpLiteral";
+  pattern: string;
+  flags: string;
+}
+
+export interface LogicalExpression extends BaseNode {
+  type: "LogicalExpression";
+  operator: "||" | "&&" | "??";
+  left: Expression;
+  right: Expression;
+}
+
+export interface MemberExpression extends BaseNode {
+  type: "MemberExpression";
+  object: Expression;
+  property: any;
+  computed: boolean;
+  optional: true | false | null;
+}
+
+export interface NewExpression extends BaseNode {
+  type: "NewExpression";
+  callee: Expression;
+  arguments: Array<Expression | SpreadElement | JSXNamespacedName>;
+  optional: true | false | null;
+  typeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
+}
+
+export interface Program extends BaseNode {
+  type: "Program";
+  body: Array<Statement>;
+  directives: Array<Directive>;
+  sourceType: "script" | "module";
+  sourceFile: string | null;
+}
+
+export interface ObjectExpression extends BaseNode {
+  type: "ObjectExpression";
+  properties: Array<ObjectMethod | ObjectProperty | SpreadElement>;
+}
+
+export interface ObjectMethod extends BaseNode {
+  type: "ObjectMethod";
+  kind: "method" | "get" | "set";
+  key: any;
+  params: Array<LVal>;
+  body: BlockStatement;
+  computed: boolean;
+  async: boolean;
+  decorators: Array<Decorator> | null;
+  generator: boolean;
+  returnType: TypeAnnotation | TSTypeAnnotation | Noop | null;
+  typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
+}
+
+export interface ObjectProperty extends BaseNode {
+  type: "ObjectProperty";
+  key: any;
+  value: Expression | PatternLike;
+  computed: boolean;
+  shorthand: boolean;
+  decorators: Array<Decorator> | null;
+}
+
+export interface RestElement extends BaseNode {
+  type: "RestElement";
+  argument: LVal;
+  decorators: Array<Decorator> | null;
+  typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
+}
+
+export interface ReturnStatement extends BaseNode {
+  type: "ReturnStatement";
+  argument: Expression | null;
+}
+
+export interface SequenceExpression extends BaseNode {
+  type: "SequenceExpression";
+  expressions: Array<Expression>;
+}
+
+export interface SwitchCase extends BaseNode {
+  type: "SwitchCase";
+  test: Expression | null;
+  consequent: Array<Statement>;
+}
+
+export interface SwitchStatement extends BaseNode {
+  type: "SwitchStatement";
+  discriminant: Expression;
+  cases: Array<SwitchCase>;
+}
+
+export interface ThisExpression extends BaseNode {
+  type: "ThisExpression";
+}
+
+export interface ThrowStatement extends BaseNode {
+  type: "ThrowStatement";
+  argument: Expression;
+}
+
+export interface TryStatement extends BaseNode {
+  type: "TryStatement";
+  block: BlockStatement;
+  handler: CatchClause | null;
+  finalizer: BlockStatement | null;
+}
+
+export interface UnaryExpression extends BaseNode {
+  type: "UnaryExpression";
+  operator: "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof";
+  argument: Expression;
+  prefix: boolean;
+}
+
+export interface UpdateExpression extends BaseNode {
+  type: "UpdateExpression";
+  operator: "++" | "--";
+  argument: Expression;
+  prefix: boolean;
+}
+
+export interface VariableDeclaration extends BaseNode {
+  type: "VariableDeclaration";
+  kind: "var" | "let" | "const";
+  declarations: Array<VariableDeclarator>;
+  declare: boolean | null;
+}
+
+export interface VariableDeclarator extends BaseNode {
+  type: "VariableDeclarator";
+  id: LVal;
+  init: Expression | null;
+  definite: boolean | null;
+}
+
+export interface WhileStatement extends BaseNode {
+  type: "WhileStatement";
+  test: Expression;
+  body: BlockStatement | Statement;
+}
+
+export interface WithStatement extends BaseNode {
+  type: "WithStatement";
+  object: Expression;
+  body: BlockStatement | Statement;
+}
+
+export interface AssignmentPattern extends BaseNode {
+  type: "AssignmentPattern";
+  left: Identifier | ObjectPattern | ArrayPattern;
+  right: Expression;
+  decorators: Array<Decorator> | null;
+  typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
+}
+
+export interface ArrayPattern extends BaseNode {
+  type: "ArrayPattern";
+  elements: Array<PatternLike>;
+  decorators: Array<Decorator> | null;
+  typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
+}
+
+export interface ArrowFunctionExpression extends BaseNode {
+  type: "ArrowFunctionExpression";
+  params: Array<LVal>;
+  body: BlockStatement | Expression;
+  async: boolean;
+  expression: boolean | null;
+  generator: boolean;
+  returnType: TypeAnnotation | TSTypeAnnotation | Noop | null;
+  typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
+}
+
+export interface ClassBody extends BaseNode {
+  type: "ClassBody";
+  body: Array<ClassMethod | ClassProperty | ClassPrivateProperty | TSDeclareMethod | TSIndexSignature>;
+}
+
+export interface ClassDeclaration extends BaseNode {
+  type: "ClassDeclaration";
+  id: Identifier | null;
+  superClass: Expression | null;
+  body: ClassBody;
+  decorators: Array<Decorator> | null;
+  abstract: boolean | null;
+  declare: boolean | null;
+  mixins: any | null;
+  superTypeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
+  typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
+}
+
+export interface ClassExpression extends BaseNode {
+  type: "ClassExpression";
+  id: Identifier | null;
+  superClass: Expression | null;
+  body: ClassBody;
+  decorators: Array<Decorator> | null;
+  mixins: any | null;
+  superTypeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
+  typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
+}
+
+export interface ExportAllDeclaration extends BaseNode {
+  type: "ExportAllDeclaration";
+  source: StringLiteral;
+}
+
+export interface ExportDefaultDeclaration extends BaseNode {
+  type: "ExportDefaultDeclaration";
+  declaration: FunctionDeclaration | TSDeclareFunction | ClassDeclaration | Expression;
+}
+
+export interface ExportNamedDeclaration extends BaseNode {
+  type: "ExportNamedDeclaration";
+  declaration: Declaration | null;
+  specifiers: Array<ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier>;
+  source: StringLiteral | null;
+}
+
+export interface ExportSpecifier extends BaseNode {
+  type: "ExportSpecifier";
+  local: Identifier;
+  exported: Identifier;
+}
+
+export interface ForOfStatement extends BaseNode {
+  type: "ForOfStatement";
+  left: VariableDeclaration | LVal;
+  right: Expression;
+  body: Statement;
+}
+
+export interface ImportDeclaration extends BaseNode {
+  type: "ImportDeclaration";
+  specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
+  source: StringLiteral;
+}
+
+export interface ImportDefaultSpecifier extends BaseNode {
+  type: "ImportDefaultSpecifier";
+  local: Identifier;
+}
+
+export interface ImportNamespaceSpecifier extends BaseNode {
+  type: "ImportNamespaceSpecifier";
+  local: Identifier;
+}
+
+export interface ImportSpecifier extends BaseNode {
+  type: "ImportSpecifier";
+  local: Identifier;
+  imported: Identifier;
+  importKind: null | "type" | "typeof" | null;
+}
+
+export interface MetaProperty extends BaseNode {
+  type: "MetaProperty";
+  meta: Identifier;
+  property: Identifier;
+}
+
+export interface ClassMethod extends BaseNode {
+  type: "ClassMethod";
+  kind: "get" | "set" | "method" | "constructor";
+  key: Identifier | StringLiteral | NumericLiteral | Expression;
+  params: Array<LVal>;
+  body: BlockStatement;
+  computed: boolean;
+  abstract: boolean | null;
+  access: "public" | "private" | "protected" | null;
+  accessibility: "public" | "private" | "protected" | null;
+  async: boolean;
+  decorators: Array<Decorator> | null;
+  generator: boolean;
+  optional: boolean | null;
+  returnType: TypeAnnotation | TSTypeAnnotation | Noop | null;
+  typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
+}
+
+export interface ObjectPattern extends BaseNode {
+  type: "ObjectPattern";
+  properties: Array<RestElement | ObjectProperty>;
+  decorators: Array<Decorator> | null;
+  typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
+}
+
+export interface SpreadElement extends BaseNode {
+  type: "SpreadElement";
+  argument: Expression;
+}
+
+export interface Super extends BaseNode {
+  type: "Super";
+}
+
+export interface TaggedTemplateExpression extends BaseNode {
+  type: "TaggedTemplateExpression";
+  tag: Expression;
+  quasi: TemplateLiteral;
+}
+
+export interface TemplateElement extends BaseNode {
+  type: "TemplateElement";
+  value: any;
+  tail: boolean;
+}
+
+export interface TemplateLiteral extends BaseNode {
+  type: "TemplateLiteral";
+  quasis: Array<TemplateElement>;
+  expressions: Array<Expression>;
+}
+
+export interface YieldExpression extends BaseNode {
+  type: "YieldExpression";
+  argument: Expression | null;
+  delegate: boolean;
+}
+
+export interface AnyTypeAnnotation extends BaseNode {
+  type: "AnyTypeAnnotation";
+}
+
+export interface ArrayTypeAnnotation extends BaseNode {
+  type: "ArrayTypeAnnotation";
+  elementType: FlowType;
+}
+
+export interface BooleanTypeAnnotation extends BaseNode {
+  type: "BooleanTypeAnnotation";
+}
+
+export interface BooleanLiteralTypeAnnotation extends BaseNode {
+  type: "BooleanLiteralTypeAnnotation";
+  value: boolean;
+}
+
+export interface NullLiteralTypeAnnotation extends BaseNode {
+  type: "NullLiteralTypeAnnotation";
+}
+
+export interface ClassImplements extends BaseNode {
+  type: "ClassImplements";
+  id: Identifier;
+  typeParameters: TypeParameterInstantiation | null;
+}
+
+export interface DeclareClass extends BaseNode {
+  type: "DeclareClass";
+  id: Identifier;
+  typeParameters: TypeParameterInstantiation | null;
+  body: ObjectTypeAnnotation;
+  mixins: Array<InterfaceExtends> | null;
+}
+
+export interface DeclareFunction extends BaseNode {
+  type: "DeclareFunction";
+  id: Identifier;
+  predicate: DeclaredPredicate | null;
+}
+
+export interface DeclareInterface extends BaseNode {
+  type: "DeclareInterface";
+  id: Identifier;
+  typeParameters: TypeParameterDeclaration | null;
+  body: ObjectTypeAnnotation;
+  mixins: Array<InterfaceExtends> | null;
+}
+
+export interface DeclareModule extends BaseNode {
+  type: "DeclareModule";
+  id: Identifier | StringLiteral;
+  body: BlockStatement;
+  kind: "CommonJS" | "ES" | null;
+}
+
+export interface DeclareModuleExports extends BaseNode {
+  type: "DeclareModuleExports";
+  typeAnnotation: TypeAnnotation;
+}
+
+export interface DeclareTypeAlias extends BaseNode {
+  type: "DeclareTypeAlias";
+  id: Identifier;
+  typeParameters: TypeParameterDeclaration | null;
+  right: FlowType;
+}
+
+export interface DeclareOpaqueType extends BaseNode {
+  type: "DeclareOpaqueType";
+  id: Identifier;
+  typeParameters: TypeParameterDeclaration | null;
+  supertype: FlowType | null;
+}
+
+export interface DeclareVariable extends BaseNode {
+  type: "DeclareVariable";
+  id: Identifier;
+}
+
+export interface DeclareExportDeclaration extends BaseNode {
+  type: "DeclareExportDeclaration";
+  declaration: Flow | null;
+  specifiers: Array<ExportSpecifier | ExportNamespaceSpecifier> | null;
+  source: StringLiteral | null;
+}
+
+export interface DeclareExportAllDeclaration extends BaseNode {
+  type: "DeclareExportAllDeclaration";
+  source: StringLiteral;
+  exportKind: ["type","value"] | null;
+}
+
+export interface DeclaredPredicate extends BaseNode {
+  type: "DeclaredPredicate";
+  value: Flow;
+}
+
+export interface ExistsTypeAnnotation extends BaseNode {
+  type: "ExistsTypeAnnotation";
+}
+
+export interface FunctionTypeAnnotation extends BaseNode {
+  type: "FunctionTypeAnnotation";
+  typeParameters: TypeParameterDeclaration | null;
+  params: Array<FunctionTypeParam>;
+  rest: FunctionTypeParam | null;
+  returnType: FlowType;
+}
+
+export interface FunctionTypeParam extends BaseNode {
+  type: "FunctionTypeParam";
+  name: Identifier | null;
+  typeAnnotation: FlowType;
+  optional: boolean | null;
+}
+
+export interface GenericTypeAnnotation extends BaseNode {
+  type: "GenericTypeAnnotation";
+  id: Identifier;
+  typeParameters: TypeParameterInstantiation | null;
+}
+
+export interface InferredPredicate extends BaseNode {
+  type: "InferredPredicate";
+}
+
+export interface InterfaceExtends extends BaseNode {
+  type: "InterfaceExtends";
+  id: Identifier;
+  typeParameters: TypeParameterInstantiation | null;
+}
+
+export interface InterfaceDeclaration extends BaseNode {
+  type: "InterfaceDeclaration";
+  id: Identifier;
+  typeParameters: TypeParameterDeclaration | null;
+  body: ObjectTypeAnnotation;
+  mixins: Array<InterfaceExtends> | null;
+}
+
+export interface IntersectionTypeAnnotation extends BaseNode {
+  type: "IntersectionTypeAnnotation";
+  types: Array<FlowType>;
+}
+
+export interface MixedTypeAnnotation extends BaseNode {
+  type: "MixedTypeAnnotation";
+}
+
+export interface EmptyTypeAnnotation extends BaseNode {
+  type: "EmptyTypeAnnotation";
+}
+
+export interface NullableTypeAnnotation extends BaseNode {
+  type: "NullableTypeAnnotation";
+  typeAnnotation: FlowType;
+}
+
+export interface NumberLiteralTypeAnnotation extends BaseNode {
+  type: "NumberLiteralTypeAnnotation";
+  value: number;
+}
+
+export interface NumberTypeAnnotation extends BaseNode {
+  type: "NumberTypeAnnotation";
+}
+
+export interface ObjectTypeAnnotation extends BaseNode {
+  type: "ObjectTypeAnnotation";
+  properties: Array<ObjectTypeProperty | ObjectTypeSpreadProperty>;
+  indexers: Array<ObjectTypeIndexer> | null;
+  callProperties: Array<ObjectTypeCallProperty> | null;
+  exact: boolean;
+}
+
+export interface ObjectTypeCallProperty extends BaseNode {
+  type: "ObjectTypeCallProperty";
+  value: FlowType;
+}
+
+export interface ObjectTypeIndexer extends BaseNode {
+  type: "ObjectTypeIndexer";
+  id: Identifier | null;
+  key: FlowType;
+  value: FlowType;
+  variance: Variance | null;
+}
+
+export interface ObjectTypeProperty extends BaseNode {
+  type: "ObjectTypeProperty";
+  key: Identifier | StringLiteral;
+  value: FlowType;
+  variance: Variance | null;
+  kind: "init" | "get" | "set" | null;
+  optional: boolean | null;
+}
+
+export interface ObjectTypeSpreadProperty extends BaseNode {
+  type: "ObjectTypeSpreadProperty";
+  argument: FlowType;
+}
+
+export interface OpaqueType extends BaseNode {
+  type: "OpaqueType";
+  id: Identifier;
+  typeParameters: TypeParameterDeclaration | null;
+  supertype: FlowType | null;
+  impltype: FlowType;
+}
+
+export interface QualifiedTypeIdentifier extends BaseNode {
+  type: "QualifiedTypeIdentifier";
+  id: Identifier;
+  qualification: Identifier | QualifiedTypeIdentifier;
+}
+
+export interface StringLiteralTypeAnnotation extends BaseNode {
+  type: "StringLiteralTypeAnnotation";
+  value: string;
+}
+
+export interface StringTypeAnnotation extends BaseNode {
+  type: "StringTypeAnnotation";
+}
+
+export interface ThisTypeAnnotation extends BaseNode {
+  type: "ThisTypeAnnotation";
+}
+
+export interface TupleTypeAnnotation extends BaseNode {
+  type: "TupleTypeAnnotation";
+  types: Array<FlowType>;
+}
+
+export interface TypeofTypeAnnotation extends BaseNode {
+  type: "TypeofTypeAnnotation";
+  argument: FlowType;
+}
+
+export interface TypeAlias extends BaseNode {
+  type: "TypeAlias";
+  id: Identifier;
+  typeParameters: TypeParameterDeclaration | null;
+  right: FlowType;
+}
+
+export interface TypeAnnotation extends BaseNode {
+  type: "TypeAnnotation";
+  typeAnnotation: FlowType;
+}
+
+export interface TypeCastExpression extends BaseNode {
+  type: "TypeCastExpression";
+  expression: Expression;
+  typeAnnotation: TypeAnnotation;
+}
+
+export interface TypeParameter extends BaseNode {
+  type: "TypeParameter";
+  bound: TypeAnnotation | null;
+  variance: Variance | null;
+  name: string | null;
+}
+
+export interface TypeParameterDeclaration extends BaseNode {
+  type: "TypeParameterDeclaration";
+  params: Array<TypeParameter>;
+}
+
+export interface TypeParameterInstantiation extends BaseNode {
+  type: "TypeParameterInstantiation";
+  params: Array<FlowType>;
+}
+
+export interface UnionTypeAnnotation extends BaseNode {
+  type: "UnionTypeAnnotation";
+  types: Array<FlowType>;
+}
+
+export interface Variance extends BaseNode {
+  type: "Variance";
+  kind: "minus" | "plus";
+}
+
+export interface VoidTypeAnnotation extends BaseNode {
+  type: "VoidTypeAnnotation";
+}
+
+export interface JSXAttribute extends BaseNode {
+  type: "JSXAttribute";
+  name: JSXIdentifier | JSXNamespacedName;
+  value: JSXElement | JSXFragment | StringLiteral | JSXExpressionContainer | null;
+}
+
+export interface JSXClosingElement extends BaseNode {
+  type: "JSXClosingElement";
+  name: JSXIdentifier | JSXMemberExpression;
+}
+
+export interface JSXElement extends BaseNode {
+  type: "JSXElement";
+  openingElement: JSXOpeningElement;
+  closingElement: JSXClosingElement | null;
+  children: Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment>;
+  selfClosing: any;
+}
+
+export interface JSXEmptyExpression extends BaseNode {
+  type: "JSXEmptyExpression";
+}
+
+export interface JSXExpressionContainer extends BaseNode {
+  type: "JSXExpressionContainer";
+  expression: Expression;
+}
+
+export interface JSXSpreadChild extends BaseNode {
+  type: "JSXSpreadChild";
+  expression: Expression;
+}
+
+export interface JSXIdentifier extends BaseNode {
+  type: "JSXIdentifier";
+  name: string;
+}
+
+export interface JSXMemberExpression extends BaseNode {
+  type: "JSXMemberExpression";
+  object: JSXMemberExpression | JSXIdentifier;
+  property: JSXIdentifier;
+}
+
+export interface JSXNamespacedName extends BaseNode {
+  type: "JSXNamespacedName";
+  namespace: JSXIdentifier;
+  name: JSXIdentifier;
+}
+
+export interface JSXOpeningElement extends BaseNode {
+  type: "JSXOpeningElement";
+  name: JSXIdentifier | JSXMemberExpression;
+  attributes: Array<JSXAttribute | JSXSpreadAttribute>;
+  selfClosing: boolean;
+}
+
+export interface JSXSpreadAttribute extends BaseNode {
+  type: "JSXSpreadAttribute";
+  argument: Expression;
+}
+
+export interface JSXText extends BaseNode {
+  type: "JSXText";
+  value: string;
+}
+
+export interface JSXFragment extends BaseNode {
+  type: "JSXFragment";
+  openingFragment: JSXOpeningFragment;
+  closingFragment: JSXClosingFragment;
+  children: Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment>;
+}
+
+export interface JSXOpeningFragment extends BaseNode {
+  type: "JSXOpeningFragment";
+}
+
+export interface JSXClosingFragment extends BaseNode {
+  type: "JSXClosingFragment";
+}
+
+export interface Noop extends BaseNode {
+  type: "Noop";
+}
+
+export interface ParenthesizedExpression extends BaseNode {
+  type: "ParenthesizedExpression";
+  expression: Expression;
+}
+
+export interface AwaitExpression extends BaseNode {
+  type: "AwaitExpression";
+  argument: Expression;
+}
+
+export interface BindExpression extends BaseNode {
+  type: "BindExpression";
+  object: any;
+  callee: any;
+}
+
+export interface ClassProperty extends BaseNode {
+  type: "ClassProperty";
+  key: Identifier | StringLiteral | NumericLiteral | Expression;
+  value: Expression | null;
+  typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
+  decorators: Array<Decorator> | null;
+  computed: boolean;
+  abstract: boolean | null;
+  accessibility: "public" | "private" | "protected" | null;
+  definite: boolean | null;
+  optional: boolean | null;
+  readonly: boolean | null;
+}
+
+export interface OptionalMemberExpression extends BaseNode {
+  type: "OptionalMemberExpression";
+  object: Expression;
+  property: any;
+  computed: boolean;
+  optional: boolean;
+}
+
+export interface OptionalCallExpression extends BaseNode {
+  type: "OptionalCallExpression";
+  callee: Expression;
+  arguments: Array<Expression | SpreadElement | JSXNamespacedName>;
+  optional: boolean;
+  typeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
+}
+
+export interface ClassPrivateProperty extends BaseNode {
+  type: "ClassPrivateProperty";
+  key: PrivateName;
+  value: Expression | null;
+}
+
+export interface Import extends BaseNode {
+  type: "Import";
+}
+
+export interface Decorator extends BaseNode {
+  type: "Decorator";
+  callee: Expression;
+  arguments: Array<Expression | SpreadElement> | null;
+}
+
+export interface DoExpression extends BaseNode {
+  type: "DoExpression";
+  body: BlockStatement;
+}
+
+export interface ExportDefaultSpecifier extends BaseNode {
+  type: "ExportDefaultSpecifier";
+  exported: Identifier;
+}
+
+export interface ExportNamespaceSpecifier extends BaseNode {
+  type: "ExportNamespaceSpecifier";
+  exported: Identifier;
+}
+
+export interface PrivateName extends BaseNode {
+  type: "PrivateName";
+  id: Identifier;
+}
+
+export interface TSParameterProperty extends BaseNode {
+  type: "TSParameterProperty";
+  parameter: Identifier | AssignmentPattern;
+  accessibility: "public" | "private" | "protected" | null;
+  readonly: boolean | null;
+}
+
+export interface TSDeclareFunction extends BaseNode {
+  type: "TSDeclareFunction";
+  id: Identifier | null;
+  typeParameters: TSTypeParameterDeclaration | Noop | null;
+  params: Array<LVal>;
+  returnType: TSTypeAnnotation | Noop | null;
+  async: boolean;
+  declare: boolean | null;
+  generator: boolean;
+}
+
+export interface TSDeclareMethod extends BaseNode {
+  type: "TSDeclareMethod";
+  decorators: Array<Decorator> | null;
+  key: Identifier | StringLiteral | NumericLiteral | Expression;
+  typeParameters: TSTypeParameterDeclaration | Noop | null;
+  params: Array<LVal>;
+  returnType: TSTypeAnnotation | Noop | null;
+  abstract: boolean | null;
+  access: "public" | "private" | "protected" | null;
+  accessibility: "public" | "private" | "protected" | null;
+  async: boolean;
+  computed: boolean;
+  generator: boolean;
+  kind: "get" | "set" | "method" | "constructor";
+  optional: boolean | null;
+}
+
+export interface TSQualifiedName extends BaseNode {
+  type: "TSQualifiedName";
+  left: TSEntityName;
+  right: Identifier;
+}
+
+export interface TSCallSignatureDeclaration extends BaseNode {
+  type: "TSCallSignatureDeclaration";
+  typeParameters: TSTypeParameterDeclaration | null;
+  parameters: Array<Identifier | RestElement> | null;
+  typeAnnotation: TSTypeAnnotation | null;
+}
+
+export interface TSConstructSignatureDeclaration extends BaseNode {
+  type: "TSConstructSignatureDeclaration";
+  typeParameters: TSTypeParameterDeclaration | null;
+  parameters: Array<Identifier | RestElement> | null;
+  typeAnnotation: TSTypeAnnotation | null;
+}
+
+export interface TSPropertySignature extends BaseNode {
+  type: "TSPropertySignature";
+  key: Expression;
+  typeAnnotation: TSTypeAnnotation | null;
+  initializer: Expression | null;
+  computed: boolean | null;
+  optional: boolean | null;
+  readonly: boolean | null;
+}
+
+export interface TSMethodSignature extends BaseNode {
+  type: "TSMethodSignature";
+  key: Expression;
+  typeParameters: TSTypeParameterDeclaration | null;
+  parameters: Array<Identifier | RestElement> | null;
+  typeAnnotation: TSTypeAnnotation | null;
+  computed: boolean | null;
+  optional: boolean | null;
+}
+
+export interface TSIndexSignature extends BaseNode {
+  type: "TSIndexSignature";
+  parameters: Array<Identifier>;
+  typeAnnotation: TSTypeAnnotation | null;
+  readonly: boolean | null;
+}
+
+export interface TSAnyKeyword extends BaseNode {
+  type: "TSAnyKeyword";
+}
+
+export interface TSNumberKeyword extends BaseNode {
+  type: "TSNumberKeyword";
+}
+
+export interface TSObjectKeyword extends BaseNode {
+  type: "TSObjectKeyword";
+}
+
+export interface TSBooleanKeyword extends BaseNode {
+  type: "TSBooleanKeyword";
+}
+
+export interface TSStringKeyword extends BaseNode {
+  type: "TSStringKeyword";
+}
+
+export interface TSSymbolKeyword extends BaseNode {
+  type: "TSSymbolKeyword";
+}
+
+export interface TSVoidKeyword extends BaseNode {
+  type: "TSVoidKeyword";
+}
+
+export interface TSUndefinedKeyword extends BaseNode {
+  type: "TSUndefinedKeyword";
+}
+
+export interface TSNullKeyword extends BaseNode {
+  type: "TSNullKeyword";
+}
+
+export interface TSNeverKeyword extends BaseNode {
+  type: "TSNeverKeyword";
+}
+
+export interface TSThisType extends BaseNode {
+  type: "TSThisType";
+}
+
+export interface TSFunctionType extends BaseNode {
+  type: "TSFunctionType";
+  typeParameters: TSTypeParameterDeclaration | null;
+  typeAnnotation: TSTypeAnnotation | null;
+  parameters: Array<Identifier | RestElement> | null;
+}
+
+export interface TSConstructorType extends BaseNode {
+  type: "TSConstructorType";
+  typeParameters: TSTypeParameterDeclaration | null;
+  typeAnnotation: TSTypeAnnotation | null;
+  parameters: Array<Identifier | RestElement> | null;
+}
+
+export interface TSTypeReference extends BaseNode {
+  type: "TSTypeReference";
+  typeName: TSEntityName;
+  typeParameters: TSTypeParameterInstantiation | null;
+}
+
+export interface TSTypePredicate extends BaseNode {
+  type: "TSTypePredicate";
+  parameterName: Identifier | TSThisType;
+  typeAnnotation: TSTypeAnnotation;
+}
+
+export interface TSTypeQuery extends BaseNode {
+  type: "TSTypeQuery";
+  exprName: TSEntityName;
+}
+
+export interface TSTypeLiteral extends BaseNode {
+  type: "TSTypeLiteral";
+  members: Array<TSTypeElement>;
+}
+
+export interface TSArrayType extends BaseNode {
+  type: "TSArrayType";
+  elementType: TSType;
+}
+
+export interface TSTupleType extends BaseNode {
+  type: "TSTupleType";
+  elementTypes: Array<TSType>;
+}
+
+export interface TSUnionType extends BaseNode {
+  type: "TSUnionType";
+  types: Array<TSType>;
+}
+
+export interface TSIntersectionType extends BaseNode {
+  type: "TSIntersectionType";
+  types: Array<TSType>;
+}
+
+export interface TSConditionalType extends BaseNode {
+  type: "TSConditionalType";
+  checkType: TSType;
+  extendsType: TSType;
+  trueType: TSType;
+  falseType: TSType;
+}
+
+export interface TSInferType extends BaseNode {
+  type: "TSInferType";
+  typeParameter: TSType;
+}
+
+export interface TSParenthesizedType extends BaseNode {
+  type: "TSParenthesizedType";
+  typeAnnotation: TSType;
+}
+
+export interface TSTypeOperator extends BaseNode {
+  type: "TSTypeOperator";
+  typeAnnotation: TSType;
+  operator: string | null;
+}
+
+export interface TSIndexedAccessType extends BaseNode {
+  type: "TSIndexedAccessType";
+  objectType: TSType;
+  indexType: TSType;
+}
+
+export interface TSMappedType extends BaseNode {
+  type: "TSMappedType";
+  typeParameter: TSTypeParameter;
+  typeAnnotation: TSType | null;
+  optional: boolean | null;
+  readonly: boolean | null;
+}
+
+export interface TSLiteralType extends BaseNode {
+  type: "TSLiteralType";
+  literal: NumericLiteral | StringLiteral | BooleanLiteral;
+}
+
+export interface TSExpressionWithTypeArguments extends BaseNode {
+  type: "TSExpressionWithTypeArguments";
+  expression: TSEntityName;
+  typeParameters: TSTypeParameterInstantiation | null;
+}
+
+export interface TSInterfaceDeclaration extends BaseNode {
+  type: "TSInterfaceDeclaration";
+  id: Identifier;
+  typeParameters: TSTypeParameterDeclaration | null;
+  body: TSInterfaceBody;
+  declare: boolean | null;
+}
+
+export interface TSInterfaceBody extends BaseNode {
+  type: "TSInterfaceBody";
+  body: Array<TSTypeElement>;
+}
+
+export interface TSTypeAliasDeclaration extends BaseNode {
+  type: "TSTypeAliasDeclaration";
+  id: Identifier;
+  typeParameters: TSTypeParameterDeclaration | null;
+  typeAnnotation: TSType;
+  declare: boolean | null;
+}
+
+export interface TSAsExpression extends BaseNode {
+  type: "TSAsExpression";
+  expression: Expression;
+  typeAnnotation: TSType;
+}
+
+export interface TSTypeAssertion extends BaseNode {
+  type: "TSTypeAssertion";
+  typeAnnotation: TSType;
+  expression: Expression;
+}
+
+export interface TSEnumDeclaration extends BaseNode {
+  type: "TSEnumDeclaration";
+  id: Identifier;
+  members: Array<TSEnumMember>;
+  declare: boolean | null;
+  initializer: Expression | null;
+}
+
+export interface TSEnumMember extends BaseNode {
+  type: "TSEnumMember";
+  id: Identifier | StringLiteral;
+  initializer: Expression | null;
+}
+
+export interface TSModuleDeclaration extends BaseNode {
+  type: "TSModuleDeclaration";
+  id: Identifier | StringLiteral;
+  body: TSModuleBlock | TSModuleDeclaration;
+  declare: boolean | null;
+  global: boolean | null;
+}
+
+export interface TSModuleBlock extends BaseNode {
+  type: "TSModuleBlock";
+  body: Array<Statement>;
+}
+
+export interface TSImportEqualsDeclaration extends BaseNode {
+  type: "TSImportEqualsDeclaration";
+  id: Identifier;
+  moduleReference: TSEntityName | TSExternalModuleReference;
+  isExport: boolean | null;
+}
+
+export interface TSExternalModuleReference extends BaseNode {
+  type: "TSExternalModuleReference";
+  expression: StringLiteral;
+}
+
+export interface TSNonNullExpression extends BaseNode {
+  type: "TSNonNullExpression";
+  expression: Expression;
+}
+
+export interface TSExportAssignment extends BaseNode {
+  type: "TSExportAssignment";
+  expression: Expression;
+}
+
+export interface TSNamespaceExportDeclaration extends BaseNode {
+  type: "TSNamespaceExportDeclaration";
+  id: Identifier;
+}
+
+export interface TSTypeAnnotation extends BaseNode {
+  type: "TSTypeAnnotation";
+  typeAnnotation: TSType;
+}
+
+export interface TSTypeParameterInstantiation extends BaseNode {
+  type: "TSTypeParameterInstantiation";
+  params: Array<TSType>;
+}
+
+export interface TSTypeParameterDeclaration extends BaseNode {
+  type: "TSTypeParameterDeclaration";
+  params: Array<TSTypeParameter>;
+}
+
+export interface TSTypeParameter extends BaseNode {
+  type: "TSTypeParameter";
+  constraint: TSType | null;
+  name: string | null;
+}
+
+/**
+ * @deprecated Use `NumericLiteral`
+ */
+export type NumberLiteral = NumericLiteral;
+
+/**
+ * @deprecated Use `RegExpLiteral`
+ */
+export type RegexLiteral = RegExpLiteral;
+
+/**
+ * @deprecated Use `RestElement`
+ */
+export type RestProperty = RestElement;
+
+/**
+ * @deprecated Use `SpreadElement`
+ */
+export type SpreadProperty = SpreadElement;
+
+export type Expression = ArrayExpression | AssignmentExpression | BinaryExpression | CallExpression | ConditionalExpression | FunctionExpression | Identifier | StringLiteral | NumericLiteral | NullLiteral | BooleanLiteral | RegExpLiteral | LogicalExpression | MemberExpression | NewExpression | ObjectExpression | SequenceExpression | ThisExpression | UnaryExpression | UpdateExpression | ArrowFunctionExpression | ClassExpression | MetaProperty | Super | TaggedTemplateExpression | TemplateLiteral | YieldExpression | TypeCastExpression | JSXElement | JSXFragment | ParenthesizedExpression | AwaitExpression | BindExpression | OptionalMemberExpression | OptionalCallExpression | Import | DoExpression | TSAsExpression | TSTypeAssertion | TSNonNullExpression;
+export type Binary = BinaryExpression | LogicalExpression;
+export type Scopable = BlockStatement | CatchClause | DoWhileStatement | ForInStatement | ForStatement | FunctionDeclaration | FunctionExpression | Program | ObjectMethod | SwitchStatement | WhileStatement | ArrowFunctionExpression | ClassDeclaration | ClassExpression | ForOfStatement | ClassMethod;
+export type BlockParent = BlockStatement | CatchClause | DoWhileStatement | ForInStatement | ForStatement | FunctionDeclaration | FunctionExpression | Program | ObjectMethod | SwitchStatement | WhileStatement | ArrowFunctionExpression | ForOfStatement | ClassMethod;
+export type Block = BlockStatement | Program;
+export type Statement = BlockStatement | BreakStatement | ContinueStatement | DebuggerStatement | DoWhileStatement | EmptyStatement | ExpressionStatement | ForInStatement | ForStatement | FunctionDeclaration | IfStatement | LabeledStatement | ReturnStatement | SwitchStatement | ThrowStatement | TryStatement | VariableDeclaration | WhileStatement | WithStatement | ClassDeclaration | ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ForOfStatement | ImportDeclaration | DeclareClass | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareTypeAlias | DeclareOpaqueType | DeclareVariable | DeclareExportDeclaration | DeclareExportAllDeclaration | InterfaceDeclaration | OpaqueType | TypeAlias | TSDeclareFunction | TSInterfaceDeclaration | TSTypeAliasDeclaration | TSEnumDeclaration | TSModuleDeclaration | TSImportEqualsDeclaration | TSExportAssignment | TSNamespaceExportDeclaration;
+export type Terminatorless = BreakStatement | ContinueStatement | ReturnStatement | ThrowStatement | YieldExpression | AwaitExpression;
+export type CompletionStatement = BreakStatement | ContinueStatement | ReturnStatement | ThrowStatement;
+export type Conditional = ConditionalExpression | IfStatement;
+export type Loop = DoWhileStatement | ForInStatement | ForStatement | WhileStatement | ForOfStatement;
+export type While = DoWhileStatement | WhileStatement;
+export type ExpressionWrapper = ExpressionStatement | TypeCastExpression | ParenthesizedExpression;
+export type For = ForInStatement | ForStatement | ForOfStatement;
+export type ForXStatement = ForInStatement | ForOfStatement;
+export type Function = FunctionDeclaration | FunctionExpression | ObjectMethod | ArrowFunctionExpression | ClassMethod;
+export type FunctionParent = FunctionDeclaration | FunctionExpression | ObjectMethod | ArrowFunctionExpression | ClassMethod;
+export type Pureish = FunctionDeclaration | FunctionExpression | StringLiteral | NumericLiteral | NullLiteral | BooleanLiteral | ArrowFunctionExpression | ClassDeclaration | ClassExpression;
+export type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration | ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ImportDeclaration | DeclareClass | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareTypeAlias | DeclareOpaqueType | DeclareVariable | DeclareExportDeclaration | DeclareExportAllDeclaration | InterfaceDeclaration | OpaqueType | TypeAlias | TSDeclareFunction | TSInterfaceDeclaration | TSTypeAliasDeclaration | TSEnumDeclaration | TSModuleDeclaration;
+export type PatternLike = Identifier | RestElement | AssignmentPattern | ArrayPattern | ObjectPattern;
+export type LVal = Identifier | MemberExpression | RestElement | AssignmentPattern | ArrayPattern | ObjectPattern | TSParameterProperty;
+export type TSEntityName = Identifier | TSQualifiedName;
+export type Literal = StringLiteral | NumericLiteral | NullLiteral | BooleanLiteral | RegExpLiteral | TemplateLiteral;
+export type Immutable = StringLiteral | NumericLiteral | NullLiteral | BooleanLiteral | JSXAttribute | JSXClosingElement | JSXElement | JSXExpressionContainer | JSXSpreadChild | JSXOpeningElement | JSXText | JSXFragment | JSXOpeningFragment | JSXClosingFragment;
+export type UserWhitespacable = ObjectMethod | ObjectProperty | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeProperty | ObjectTypeSpreadProperty;
+export type Method = ObjectMethod | ClassMethod;
+export type ObjectMember = ObjectMethod | ObjectProperty;
+export type Property = ObjectProperty | ClassProperty | ClassPrivateProperty;
+export type UnaryLike = UnaryExpression | SpreadElement;
+export type Pattern = AssignmentPattern | ArrayPattern | ObjectPattern;
+export type Class = ClassDeclaration | ClassExpression;
+export type ModuleDeclaration = ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ImportDeclaration;
+export type ExportDeclaration = ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration;
+export type ModuleSpecifier = ExportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier;
+export type Flow = AnyTypeAnnotation | ArrayTypeAnnotation | BooleanTypeAnnotation | BooleanLiteralTypeAnnotation | NullLiteralTypeAnnotation | ClassImplements | DeclareClass | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareTypeAlias | DeclareOpaqueType | DeclareVariable | DeclareExportDeclaration | DeclareExportAllDeclaration | DeclaredPredicate | ExistsTypeAnnotation | FunctionTypeAnnotation | FunctionTypeParam | GenericTypeAnnotation | InferredPredicate | InterfaceExtends | InterfaceDeclaration | IntersectionTypeAnnotation | MixedTypeAnnotation | EmptyTypeAnnotation | NullableTypeAnnotation | NumberLiteralTypeAnnotation | NumberTypeAnnotation | ObjectTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | QualifiedTypeIdentifier | StringLiteralTypeAnnotation | StringTypeAnnotation | ThisTypeAnnotation | TupleTypeAnnotation | TypeofTypeAnnotation | TypeAlias | TypeAnnotation | TypeCastExpression | TypeParameter | TypeParameterDeclaration | TypeParameterInstantiation | UnionTypeAnnotation | Variance | VoidTypeAnnotation;
+export type FlowType = AnyTypeAnnotation | ArrayTypeAnnotation | BooleanTypeAnnotation | BooleanLiteralTypeAnnotation | NullLiteralTypeAnnotation | ExistsTypeAnnotation | FunctionTypeAnnotation | GenericTypeAnnotation | IntersectionTypeAnnotation | MixedTypeAnnotation | EmptyTypeAnnotation | NullableTypeAnnotation | NumberLiteralTypeAnnotation | NumberTypeAnnotation | ObjectTypeAnnotation | StringLiteralTypeAnnotation | StringTypeAnnotation | ThisTypeAnnotation | TupleTypeAnnotation | TypeofTypeAnnotation | UnionTypeAnnotation | VoidTypeAnnotation;
+export type FlowBaseAnnotation = AnyTypeAnnotation | BooleanTypeAnnotation | NullLiteralTypeAnnotation | MixedTypeAnnotation | EmptyTypeAnnotation | NumberTypeAnnotation | StringTypeAnnotation | ThisTypeAnnotation | VoidTypeAnnotation;
+export type FlowDeclaration = DeclareClass | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareTypeAlias | DeclareOpaqueType | DeclareVariable | DeclareExportDeclaration | DeclareExportAllDeclaration | InterfaceDeclaration | OpaqueType | TypeAlias;
+export type FlowPredicate = DeclaredPredicate | InferredPredicate;
+export type JSX = JSXAttribute | JSXClosingElement | JSXElement | JSXEmptyExpression | JSXExpressionContainer | JSXSpreadChild | JSXIdentifier | JSXMemberExpression | JSXNamespacedName | JSXOpeningElement | JSXSpreadAttribute | JSXText | JSXFragment | JSXOpeningFragment | JSXClosingFragment;
+export type Private = ClassPrivateProperty | PrivateName;
+export type TSTypeElement = TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSPropertySignature | TSMethodSignature | TSIndexSignature;
+export type TSType = TSAnyKeyword | TSNumberKeyword | TSObjectKeyword | TSBooleanKeyword | TSStringKeyword | TSSymbolKeyword | TSVoidKeyword | TSUndefinedKeyword | TSNullKeyword | TSNeverKeyword | TSThisType | TSFunctionType | TSConstructorType | TSTypeReference | TSTypePredicate | TSTypeQuery | TSTypeLiteral | TSArrayType | TSTupleType | TSUnionType | TSIntersectionType | TSConditionalType | TSInferType | TSParenthesizedType | TSTypeOperator | TSIndexedAccessType | TSMappedType | TSLiteralType | TSExpressionWithTypeArguments;
+export function arrayExpression(elements?: Array<null | Expression | SpreadElement>): ArrayExpression;
+export function assignmentExpression(operator: string, left: LVal, right: Expression): AssignmentExpression;
+export function binaryExpression(operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=", left: Expression, right: Expression): BinaryExpression;
+export function directive(value: DirectiveLiteral): Directive;
+export function directiveLiteral(value: string): DirectiveLiteral;
+export function blockStatement(body: Array<Statement>, directives?: Array<Directive>): BlockStatement;
+export function breakStatement(label?: Identifier | null): BreakStatement;
+export function callExpression(callee: Expression, _arguments: Array<Expression | SpreadElement | JSXNamespacedName>, optional?: true | false | null, typeParameters?: TypeParameterInstantiation | TSTypeParameterInstantiation | null): CallExpression;
+export function catchClause(param: Identifier | null | undefined, body: BlockStatement): CatchClause;
+export function conditionalExpression(test: Expression, consequent: Expression, alternate: Expression): ConditionalExpression;
+export function continueStatement(label?: Identifier | null): ContinueStatement;
+export function debuggerStatement(): DebuggerStatement;
+export function doWhileStatement(test: Expression, body: Statement): DoWhileStatement;
+export function emptyStatement(): EmptyStatement;
+export function expressionStatement(expression: Expression): ExpressionStatement;
+export function file(program: Program, comments: any, tokens: any): File;
+export function forInStatement(left: VariableDeclaration | LVal, right: Expression, body: Statement): ForInStatement;
+export function forStatement(init: VariableDeclaration | Expression | null | undefined, test: Expression | null | undefined, update: Expression | null | undefined, body: Statement): ForStatement;
+export function functionDeclaration(id: Identifier | null | undefined, params: Array<LVal>, body: BlockStatement, generator?: boolean, async?: boolean, declare?: boolean | null, returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null, typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null): FunctionDeclaration;
+export function functionExpression(id: Identifier | null | undefined, params: Array<LVal>, body: BlockStatement, generator?: boolean, async?: boolean, returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null, typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null): FunctionExpression;
+export function identifier(name: string, decorators?: Array<Decorator> | null, optional?: boolean | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null): Identifier;
+export function ifStatement(test: Expression, consequent: Statement, alternate?: Statement | null): IfStatement;
+export function labeledStatement(label: Identifier, body: Statement): LabeledStatement;
+export function stringLiteral(value: string): StringLiteral;
+export function numericLiteral(value: number): NumericLiteral;
+export function nullLiteral(): NullLiteral;
+export function booleanLiteral(value: boolean): BooleanLiteral;
+export function regExpLiteral(pattern: string, flags?: string): RegExpLiteral;
+export function logicalExpression(operator: "||" | "&&" | "??", left: Expression, right: Expression): LogicalExpression;
+export function memberExpression(object: Expression, property: any, computed?: boolean, optional?: true | false | null): MemberExpression;
+export function newExpression(callee: Expression, _arguments: Array<Expression | SpreadElement | JSXNamespacedName>, optional?: true | false | null, typeParameters?: TypeParameterInstantiation | TSTypeParameterInstantiation | null): NewExpression;
+export function program(body: Array<Statement>, directives?: Array<Directive>, sourceType?: "script" | "module", sourceFile?: string | null): Program;
+export function objectExpression(properties: Array<ObjectMethod | ObjectProperty | SpreadElement>): ObjectExpression;
+export function objectMethod(kind: "method" | "get" | "set" | undefined, key: any, params: Array<LVal>, body: BlockStatement, computed?: boolean, async?: boolean, decorators?: Array<Decorator> | null, generator?: boolean, returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null, typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null): ObjectMethod;
+export function objectProperty(key: any, value: Expression | PatternLike, computed?: boolean, shorthand?: boolean, decorators?: Array<Decorator> | null): ObjectProperty;
+export function restElement(argument: LVal, decorators?: Array<Decorator> | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null): RestElement;
+export function returnStatement(argument?: Expression | null): ReturnStatement;
+export function sequenceExpression(expressions: Array<Expression>): SequenceExpression;
+export function switchCase(test: Expression | null | undefined, consequent: Array<Statement>): SwitchCase;
+export function switchStatement(discriminant: Expression, cases: Array<SwitchCase>): SwitchStatement;
+export function thisExpression(): ThisExpression;
+export function throwStatement(argument: Expression): ThrowStatement;
+export function tryStatement(block: BlockStatement, handler?: CatchClause | null, finalizer?: BlockStatement | null): TryStatement;
+export function unaryExpression(operator: "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof", argument: Expression, prefix?: boolean): UnaryExpression;
+export function updateExpression(operator: "++" | "--", argument: Expression, prefix?: boolean): UpdateExpression;
+export function variableDeclaration(kind: "var" | "let" | "const", declarations: Array<VariableDeclarator>, declare?: boolean | null): VariableDeclaration;
+export function variableDeclarator(id: LVal, init?: Expression | null, definite?: boolean | null): VariableDeclarator;
+export function whileStatement(test: Expression, body: BlockStatement | Statement): WhileStatement;
+export function withStatement(object: Expression, body: BlockStatement | Statement): WithStatement;
+export function assignmentPattern(left: Identifier | ObjectPattern | ArrayPattern, right: Expression, decorators?: Array<Decorator> | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null): AssignmentPattern;
+export function arrayPattern(elements: Array<PatternLike>, decorators?: Array<Decorator> | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null): ArrayPattern;
+export function arrowFunctionExpression(params: Array<LVal>, body: BlockStatement | Expression, async?: boolean, expression?: boolean | null, generator?: boolean, returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null, typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null): ArrowFunctionExpression;
+export function classBody(body: Array<ClassMethod | ClassProperty | ClassPrivateProperty | TSDeclareMethod | TSIndexSignature>): ClassBody;
+export function classDeclaration(id: Identifier | null | undefined, superClass: Expression | null | undefined, body: ClassBody, decorators?: Array<Decorator> | null, abstract?: boolean | null, declare?: boolean | null, _implements?: Array<TSExpressionWithTypeArguments | ClassImplements> | null, mixins?: any | null, superTypeParameters?: TypeParameterInstantiation | TSTypeParameterInstantiation | null, typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null): ClassDeclaration;
+export function classExpression(id: Identifier | null | undefined, superClass: Expression | null | undefined, body: ClassBody, decorators?: Array<Decorator> | null, _implements?: Array<TSExpressionWithTypeArguments | ClassImplements> | null, mixins?: any | null, superTypeParameters?: TypeParameterInstantiation | TSTypeParameterInstantiation | null, typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null): ClassExpression;
+export function exportAllDeclaration(source: StringLiteral): ExportAllDeclaration;
+export function exportDefaultDeclaration(declaration: FunctionDeclaration | TSDeclareFunction | ClassDeclaration | Expression): ExportDefaultDeclaration;
+export function exportNamedDeclaration(declaration: Declaration | null | undefined, specifiers: Array<ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier>, source?: StringLiteral | null): ExportNamedDeclaration;
+export function exportSpecifier(local: Identifier, exported: Identifier): ExportSpecifier;
+export function forOfStatement(left: VariableDeclaration | LVal, right: Expression, body: Statement, _await?: boolean): ForOfStatement;
+export function importDeclaration(specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>, source: StringLiteral): ImportDeclaration;
+export function importDefaultSpecifier(local: Identifier): ImportDefaultSpecifier;
+export function importNamespaceSpecifier(local: Identifier): ImportNamespaceSpecifier;
+export function importSpecifier(local: Identifier, imported: Identifier, importKind?: null | "type" | "typeof" | null): ImportSpecifier;
+export function metaProperty(meta: Identifier, property: Identifier): MetaProperty;
+export function classMethod(kind: "get" | "set" | "method" | "constructor" | undefined, key: Identifier | StringLiteral | NumericLiteral | Expression, params: Array<LVal>, body: BlockStatement, computed?: boolean, _static?: boolean | null, abstract?: boolean | null, access?: "public" | "private" | "protected" | null, accessibility?: "public" | "private" | "protected" | null, async?: boolean, decorators?: Array<Decorator> | null, generator?: boolean, optional?: boolean | null, returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null, typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null): ClassMethod;
+export function objectPattern(properties: Array<RestElement | ObjectProperty>, decorators?: Array<Decorator> | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null): ObjectPattern;
+export function spreadElement(argument: Expression): SpreadElement;
+export function taggedTemplateExpression(tag: Expression, quasi: TemplateLiteral): TaggedTemplateExpression;
+export function templateElement(value: any, tail?: boolean): TemplateElement;
+export function templateLiteral(quasis: Array<TemplateElement>, expressions: Array<Expression>): TemplateLiteral;
+export function yieldExpression(argument?: Expression | null, delegate?: boolean): YieldExpression;
+export function anyTypeAnnotation(): AnyTypeAnnotation;
+export function arrayTypeAnnotation(elementType: FlowType): ArrayTypeAnnotation;
+export function booleanTypeAnnotation(): BooleanTypeAnnotation;
+export function booleanLiteralTypeAnnotation(value: boolean): BooleanLiteralTypeAnnotation;
+export function nullLiteralTypeAnnotation(): NullLiteralTypeAnnotation;
+export function classImplements(id: Identifier, typeParameters?: TypeParameterInstantiation | null): ClassImplements;
+export function declareClass(id: Identifier, typeParameters: TypeParameterInstantiation | null | undefined, _extends: Array<InterfaceExtends> | null | undefined, body: ObjectTypeAnnotation, _implements?: Array<ClassImplements> | null, mixins?: Array<InterfaceExtends> | null): DeclareClass;
+export function declareFunction(id: Identifier, predicate?: DeclaredPredicate | null): DeclareFunction;
+export function declareInterface(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: Array<InterfaceExtends> | null | undefined, body: ObjectTypeAnnotation, _implements?: Array<ClassImplements> | null, mixins?: Array<InterfaceExtends> | null): DeclareInterface;
+export function declareModule(id: Identifier | StringLiteral, body: BlockStatement, kind?: "CommonJS" | "ES" | null): DeclareModule;
+export function declareModuleExports(typeAnnotation: TypeAnnotation): DeclareModuleExports;
+export function declareTypeAlias(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, right: FlowType): DeclareTypeAlias;
+export function declareOpaqueType(id: Identifier, typeParameters?: TypeParameterDeclaration | null, supertype?: FlowType | null): DeclareOpaqueType;
+export function declareVariable(id: Identifier): DeclareVariable;
+export function declareExportDeclaration(declaration?: Flow | null, specifiers?: Array<ExportSpecifier | ExportNamespaceSpecifier> | null, source?: StringLiteral | null, _default?: boolean | null): DeclareExportDeclaration;
+export function declareExportAllDeclaration(source: StringLiteral, exportKind?: ["type","value"] | null): DeclareExportAllDeclaration;
+export function declaredPredicate(value: Flow): DeclaredPredicate;
+export function existsTypeAnnotation(): ExistsTypeAnnotation;
+export function functionTypeAnnotation(typeParameters: TypeParameterDeclaration | null | undefined, params: Array<FunctionTypeParam>, rest: FunctionTypeParam | null | undefined, returnType: FlowType): FunctionTypeAnnotation;
+export function functionTypeParam(name: Identifier | null | undefined, typeAnnotation: FlowType, optional?: boolean | null): FunctionTypeParam;
+export function genericTypeAnnotation(id: Identifier, typeParameters?: TypeParameterInstantiation | null): GenericTypeAnnotation;
+export function inferredPredicate(): InferredPredicate;
+export function interfaceExtends(id: Identifier, typeParameters?: TypeParameterInstantiation | null): InterfaceExtends;
+export function interfaceDeclaration(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: Array<InterfaceExtends> | null | undefined, body: ObjectTypeAnnotation, _implements?: Array<ClassImplements> | null, mixins?: Array<InterfaceExtends> | null): InterfaceDeclaration;
+export function intersectionTypeAnnotation(types: Array<FlowType>): IntersectionTypeAnnotation;
+export function mixedTypeAnnotation(): MixedTypeAnnotation;
+export function emptyTypeAnnotation(): EmptyTypeAnnotation;
+export function nullableTypeAnnotation(typeAnnotation: FlowType): NullableTypeAnnotation;
+export function numberLiteralTypeAnnotation(value: number): NumberLiteralTypeAnnotation;
+export function numberTypeAnnotation(): NumberTypeAnnotation;
+export function objectTypeAnnotation(properties: Array<ObjectTypeProperty | ObjectTypeSpreadProperty>, indexers?: Array<ObjectTypeIndexer> | null, callProperties?: Array<ObjectTypeCallProperty> | null, exact?: boolean): ObjectTypeAnnotation;
+export function objectTypeCallProperty(value: FlowType, _static?: boolean | null): ObjectTypeCallProperty;
+export function objectTypeIndexer(id: Identifier | null | undefined, key: FlowType, value: FlowType, variance?: Variance | null, _static?: boolean | null): ObjectTypeIndexer;
+export function objectTypeProperty(key: Identifier | StringLiteral, value: FlowType, variance?: Variance | null, kind?: "init" | "get" | "set" | null, optional?: boolean | null, _static?: boolean | null): ObjectTypeProperty;
+export function objectTypeSpreadProperty(argument: FlowType): ObjectTypeSpreadProperty;
+export function opaqueType(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, supertype: FlowType | null | undefined, impltype: FlowType): OpaqueType;
+export function qualifiedTypeIdentifier(id: Identifier, qualification: Identifier | QualifiedTypeIdentifier): QualifiedTypeIdentifier;
+export function stringLiteralTypeAnnotation(value: string): StringLiteralTypeAnnotation;
+export function stringTypeAnnotation(): StringTypeAnnotation;
+export function thisTypeAnnotation(): ThisTypeAnnotation;
+export function tupleTypeAnnotation(types: Array<FlowType>): TupleTypeAnnotation;
+export function typeofTypeAnnotation(argument: FlowType): TypeofTypeAnnotation;
+export function typeAlias(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, right: FlowType): TypeAlias;
+export function typeAnnotation(typeAnnotation: FlowType): TypeAnnotation;
+export function typeCastExpression(expression: Expression, typeAnnotation: TypeAnnotation): TypeCastExpression;
+export function typeParameter(bound?: TypeAnnotation | null, _default?: FlowType | null, variance?: Variance | null, name?: string | null): TypeParameter;
+export function typeParameterDeclaration(params: Array<TypeParameter>): TypeParameterDeclaration;
+export function typeParameterInstantiation(params: Array<FlowType>): TypeParameterInstantiation;
+export function unionTypeAnnotation(types: Array<FlowType>): UnionTypeAnnotation;
+export function variance(kind: "minus" | "plus"): Variance;
+export function voidTypeAnnotation(): VoidTypeAnnotation;
+export function jsxAttribute(name: JSXIdentifier | JSXNamespacedName, value?: JSXElement | JSXFragment | StringLiteral | JSXExpressionContainer | null): JSXAttribute;
+export function jsxClosingElement(name: JSXIdentifier | JSXMemberExpression): JSXClosingElement;
+export function jsxElement(openingElement: JSXOpeningElement, closingElement: JSXClosingElement | null | undefined, children: Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment>, selfClosing: any): JSXElement;
+export function jsxEmptyExpression(): JSXEmptyExpression;
+export function jsxExpressionContainer(expression: Expression): JSXExpressionContainer;
+export function jsxSpreadChild(expression: Expression): JSXSpreadChild;
+export function jsxIdentifier(name: string): JSXIdentifier;
+export function jsxMemberExpression(object: JSXMemberExpression | JSXIdentifier, property: JSXIdentifier): JSXMemberExpression;
+export function jsxNamespacedName(namespace: JSXIdentifier, name: JSXIdentifier): JSXNamespacedName;
+export function jsxOpeningElement(name: JSXIdentifier | JSXMemberExpression, attributes: Array<JSXAttribute | JSXSpreadAttribute>, selfClosing?: boolean): JSXOpeningElement;
+export function jsxSpreadAttribute(argument: Expression): JSXSpreadAttribute;
+export function jsxText(value: string): JSXText;
+export function jsxFragment(openingFragment: JSXOpeningFragment, closingFragment: JSXClosingFragment, children: Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment>): JSXFragment;
+export function jsxOpeningFragment(): JSXOpeningFragment;
+export function jsxClosingFragment(): JSXClosingFragment;
+export function noop(): Noop;
+export function parenthesizedExpression(expression: Expression): ParenthesizedExpression;
+export function awaitExpression(argument: Expression): AwaitExpression;
+export function bindExpression(object: any, callee: any): BindExpression;
+export function classProperty(key: Identifier | StringLiteral | NumericLiteral | Expression, value?: Expression | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null, decorators?: Array<Decorator> | null, computed?: boolean, abstract?: boolean | null, accessibility?: "public" | "private" | "protected" | null, definite?: boolean | null, optional?: boolean | null, readonly?: boolean | null, _static?: boolean | null): ClassProperty;
+export function optionalMemberExpression(object: Expression, property: any, computed: boolean | undefined, optional: boolean): OptionalMemberExpression;
+export function optionalCallExpression(callee: Expression, _arguments: Array<Expression | SpreadElement | JSXNamespacedName>, optional: boolean, typeParameters?: TypeParameterInstantiation | TSTypeParameterInstantiation | null): OptionalCallExpression;
+export function classPrivateProperty(key: PrivateName, value?: Expression | null): ClassPrivateProperty;
+export function decorator(callee: Expression, _arguments?: Array<Expression | SpreadElement> | null): Decorator;
+export function doExpression(body: BlockStatement): DoExpression;
+export function exportDefaultSpecifier(exported: Identifier): ExportDefaultSpecifier;
+export function exportNamespaceSpecifier(exported: Identifier): ExportNamespaceSpecifier;
+export function privateName(id: Identifier): PrivateName;
+export function tsParameterProperty(parameter: Identifier | AssignmentPattern, accessibility?: "public" | "private" | "protected" | null, readonly?: boolean | null): TSParameterProperty;
+export function tsDeclareFunction(id: Identifier | null | undefined, typeParameters: TSTypeParameterDeclaration | Noop | null | undefined, params: Array<LVal>, returnType?: TSTypeAnnotation | Noop | null, async?: boolean, declare?: boolean | null, generator?: boolean): TSDeclareFunction;
+export function tsDeclareMethod(decorators: Array<Decorator> | null | undefined, key: Identifier | StringLiteral | NumericLiteral | Expression, typeParameters: TSTypeParameterDeclaration | Noop | null | undefined, params: Array<LVal>, returnType?: TSTypeAnnotation | Noop | null, abstract?: boolean | null, access?: "public" | "private" | "protected" | null, accessibility?: "public" | "private" | "protected" | null, async?: boolean, computed?: boolean, generator?: boolean, kind?: "get" | "set" | "method" | "constructor", optional?: boolean | null, _static?: boolean | null): TSDeclareMethod;
+export function tsQualifiedName(left: TSEntityName, right: Identifier): TSQualifiedName;
+export function tsCallSignatureDeclaration(typeParameters?: TSTypeParameterDeclaration | null, parameters?: Array<Identifier | RestElement> | null, typeAnnotation?: TSTypeAnnotation | null): TSCallSignatureDeclaration;
+export function tsConstructSignatureDeclaration(typeParameters?: TSTypeParameterDeclaration | null, parameters?: Array<Identifier | RestElement> | null, typeAnnotation?: TSTypeAnnotation | null): TSConstructSignatureDeclaration;
+export function tsPropertySignature(key: Expression, typeAnnotation?: TSTypeAnnotation | null, initializer?: Expression | null, computed?: boolean | null, optional?: boolean | null, readonly?: boolean | null): TSPropertySignature;
+export function tsMethodSignature(key: Expression, typeParameters?: TSTypeParameterDeclaration | null, parameters?: Array<Identifier | RestElement> | null, typeAnnotation?: TSTypeAnnotation | null, computed?: boolean | null, optional?: boolean | null): TSMethodSignature;
+export function tsIndexSignature(parameters: Array<Identifier>, typeAnnotation?: TSTypeAnnotation | null, readonly?: boolean | null): TSIndexSignature;
+export function tsAnyKeyword(): TSAnyKeyword;
+export function tsNumberKeyword(): TSNumberKeyword;
+export function tsObjectKeyword(): TSObjectKeyword;
+export function tsBooleanKeyword(): TSBooleanKeyword;
+export function tsStringKeyword(): TSStringKeyword;
+export function tsSymbolKeyword(): TSSymbolKeyword;
+export function tsVoidKeyword(): TSVoidKeyword;
+export function tsUndefinedKeyword(): TSUndefinedKeyword;
+export function tsNullKeyword(): TSNullKeyword;
+export function tsNeverKeyword(): TSNeverKeyword;
+export function tsThisType(): TSThisType;
+export function tsFunctionType(typeParameters?: TSTypeParameterDeclaration | null, typeAnnotation?: TSTypeAnnotation | null, parameters?: Array<Identifier | RestElement> | null): TSFunctionType;
+export function tsConstructorType(typeParameters?: TSTypeParameterDeclaration | null, typeAnnotation?: TSTypeAnnotation | null, parameters?: Array<Identifier | RestElement> | null): TSConstructorType;
+export function tsTypeReference(typeName: TSEntityName, typeParameters?: TSTypeParameterInstantiation | null): TSTypeReference;
+export function tsTypePredicate(parameterName: Identifier | TSThisType, typeAnnotation: TSTypeAnnotation): TSTypePredicate;
+export function tsTypeQuery(exprName: TSEntityName): TSTypeQuery;
+export function tsTypeLiteral(members: Array<TSTypeElement>): TSTypeLiteral;
+export function tsArrayType(elementType: TSType): TSArrayType;
+export function tsTupleType(elementTypes: Array<TSType>): TSTupleType;
+export function tsUnionType(types: Array<TSType>): TSUnionType;
+export function tsIntersectionType(types: Array<TSType>): TSIntersectionType;
+export function tsConditionalType(checkType: TSType, extendsType: TSType, trueType: TSType, falseType: TSType): TSConditionalType;
+export function tsInferType(typeParameter: TSType): TSInferType;
+export function tsParenthesizedType(typeAnnotation: TSType): TSParenthesizedType;
+export function tsTypeOperator(typeAnnotation: TSType, operator?: string | null): TSTypeOperator;
+export function tsIndexedAccessType(objectType: TSType, indexType: TSType): TSIndexedAccessType;
+export function tsMappedType(typeParameter: TSTypeParameter, typeAnnotation?: TSType | null, optional?: boolean | null, readonly?: boolean | null): TSMappedType;
+export function tsLiteralType(literal: NumericLiteral | StringLiteral | BooleanLiteral): TSLiteralType;
+export function tsExpressionWithTypeArguments(expression: TSEntityName, typeParameters?: TSTypeParameterInstantiation | null): TSExpressionWithTypeArguments;
+export function tsInterfaceDeclaration(id: Identifier, typeParameters: TSTypeParameterDeclaration | null | undefined, _extends: Array<TSExpressionWithTypeArguments> | null | undefined, body: TSInterfaceBody, declare?: boolean | null): TSInterfaceDeclaration;
+export function tsInterfaceBody(body: Array<TSTypeElement>): TSInterfaceBody;
+export function tsTypeAliasDeclaration(id: Identifier, typeParameters: TSTypeParameterDeclaration | null | undefined, typeAnnotation: TSType, declare?: boolean | null): TSTypeAliasDeclaration;
+export function tsAsExpression(expression: Expression, typeAnnotation: TSType): TSAsExpression;
+export function tsTypeAssertion(typeAnnotation: TSType, expression: Expression): TSTypeAssertion;
+export function tsEnumDeclaration(id: Identifier, members: Array<TSEnumMember>, _const?: boolean | null, declare?: boolean | null, initializer?: Expression | null): TSEnumDeclaration;
+export function tsEnumMember(id: Identifier | StringLiteral, initializer?: Expression | null): TSEnumMember;
+export function tsModuleDeclaration(id: Identifier | StringLiteral, body: TSModuleBlock | TSModuleDeclaration, declare?: boolean | null, global?: boolean | null): TSModuleDeclaration;
+export function tsModuleBlock(body: Array<Statement>): TSModuleBlock;
+export function tsImportEqualsDeclaration(id: Identifier, moduleReference: TSEntityName | TSExternalModuleReference, isExport?: boolean | null): TSImportEqualsDeclaration;
+export function tsExternalModuleReference(expression: StringLiteral): TSExternalModuleReference;
+export function tsNonNullExpression(expression: Expression): TSNonNullExpression;
+export function tsExportAssignment(expression: Expression): TSExportAssignment;
+export function tsNamespaceExportDeclaration(id: Identifier): TSNamespaceExportDeclaration;
+export function tsTypeAnnotation(typeAnnotation: TSType): TSTypeAnnotation;
+export function tsTypeParameterInstantiation(params: Array<TSType>): TSTypeParameterInstantiation;
+export function tsTypeParameterDeclaration(params: Array<TSTypeParameter>): TSTypeParameterDeclaration;
+export function tsTypeParameter(constraint?: TSType | null, _default?: TSType | null, name?: string | null): TSTypeParameter;
+export function isAnyTypeAnnotation(node: object, opts?: object | null): node is AnyTypeAnnotation;
+export function isArrayExpression(node: object, opts?: object | null): node is ArrayExpression;
+export function isArrayPattern(node: object, opts?: object | null): node is ArrayPattern;
+export function isArrayTypeAnnotation(node: object, opts?: object | null): node is ArrayTypeAnnotation;
+export function isArrowFunctionExpression(node: object, opts?: object | null): node is ArrowFunctionExpression;
+export function isAssignmentExpression(node: object, opts?: object | null): node is AssignmentExpression;
+export function isAssignmentPattern(node: object, opts?: object | null): node is AssignmentPattern;
+export function isAwaitExpression(node: object, opts?: object | null): node is AwaitExpression;
+export function isBinary(node: object, opts?: object | null): boolean;
+export function isBinaryExpression(node: object, opts?: object | null): node is BinaryExpression;
+export function isBindExpression(node: object, opts?: object | null): node is BindExpression;
+export function isBlock(node: object, opts?: object | null): boolean;
+export function isBlockParent(node: object, opts?: object | null): boolean;
+export function isBlockStatement(node: object, opts?: object | null): node is BlockStatement;
+export function isBooleanLiteral(node: object, opts?: object | null): node is BooleanLiteral;
+export function isBooleanLiteralTypeAnnotation(node: object, opts?: object | null): node is BooleanLiteralTypeAnnotation;
+export function isBooleanTypeAnnotation(node: object, opts?: object | null): node is BooleanTypeAnnotation;
+export function isBreakStatement(node: object, opts?: object | null): node is BreakStatement;
+export function isCallExpression(node: object, opts?: object | null): node is CallExpression;
+export function isCatchClause(node: object, opts?: object | null): node is CatchClause;
+export function isClass(node: object, opts?: object | null): boolean;
+export function isClassBody(node: object, opts?: object | null): node is ClassBody;
+export function isClassDeclaration(node: object, opts?: object | null): node is ClassDeclaration;
+export function isClassExpression(node: object, opts?: object | null): node is ClassExpression;
+export function isClassImplements(node: object, opts?: object | null): node is ClassImplements;
+export function isClassMethod(node: object, opts?: object | null): node is ClassMethod;
+export function isClassPrivateProperty(node: object, opts?: object | null): node is ClassPrivateProperty;
+export function isClassProperty(node: object, opts?: object | null): node is ClassProperty;
+export function isCompletionStatement(node: object, opts?: object | null): boolean;
+export function isConditional(node: object, opts?: object | null): boolean;
+export function isConditionalExpression(node: object, opts?: object | null): node is ConditionalExpression;
+export function isContinueStatement(node: object, opts?: object | null): node is ContinueStatement;
+export function isDebuggerStatement(node: object, opts?: object | null): node is DebuggerStatement;
+export function isDeclaration(node: object, opts?: object | null): boolean;
+export function isDeclareClass(node: object, opts?: object | null): node is DeclareClass;
+export function isDeclareExportAllDeclaration(node: object, opts?: object | null): node is DeclareExportAllDeclaration;
+export function isDeclareExportDeclaration(node: object, opts?: object | null): node is DeclareExportDeclaration;
+export function isDeclareFunction(node: object, opts?: object | null): node is DeclareFunction;
+export function isDeclareInterface(node: object, opts?: object | null): node is DeclareInterface;
+export function isDeclareModule(node: object, opts?: object | null): node is DeclareModule;
+export function isDeclareModuleExports(node: object, opts?: object | null): node is DeclareModuleExports;
+export function isDeclareOpaqueType(node: object, opts?: object | null): node is DeclareOpaqueType;
+export function isDeclareTypeAlias(node: object, opts?: object | null): node is DeclareTypeAlias;
+export function isDeclareVariable(node: object, opts?: object | null): node is DeclareVariable;
+export function isDeclaredPredicate(node: object, opts?: object | null): node is DeclaredPredicate;
+export function isDecorator(node: object, opts?: object | null): node is Decorator;
+export function isDirective(node: object, opts?: object | null): node is Directive;
+export function isDirectiveLiteral(node: object, opts?: object | null): node is DirectiveLiteral;
+export function isDoExpression(node: object, opts?: object | null): node is DoExpression;
+export function isDoWhileStatement(node: object, opts?: object | null): node is DoWhileStatement;
+export function isEmptyStatement(node: object, opts?: object | null): node is EmptyStatement;
+export function isEmptyTypeAnnotation(node: object, opts?: object | null): node is EmptyTypeAnnotation;
+export function isExistsTypeAnnotation(node: object, opts?: object | null): node is ExistsTypeAnnotation;
+export function isExportAllDeclaration(node: object, opts?: object | null): node is ExportAllDeclaration;
+export function isExportDeclaration(node: object, opts?: object | null): boolean;
+export function isExportDefaultDeclaration(node: object, opts?: object | null): node is ExportDefaultDeclaration;
+export function isExportDefaultSpecifier(node: object, opts?: object | null): node is ExportDefaultSpecifier;
+export function isExportNamedDeclaration(node: object, opts?: object | null): node is ExportNamedDeclaration;
+export function isExportNamespaceSpecifier(node: object, opts?: object | null): node is ExportNamespaceSpecifier;
+export function isExportSpecifier(node: object, opts?: object | null): node is ExportSpecifier;
+export function isExpression(node: object, opts?: object | null): boolean;
+export function isExpressionStatement(node: object, opts?: object | null): node is ExpressionStatement;
+export function isExpressionWrapper(node: object, opts?: object | null): boolean;
+export function isFile(node: object, opts?: object | null): node is File;
+export function isFlow(node: object, opts?: object | null): boolean;
+export function isFlowBaseAnnotation(node: object, opts?: object | null): boolean;
+export function isFlowDeclaration(node: object, opts?: object | null): boolean;
+export function isFlowPredicate(node: object, opts?: object | null): boolean;
+export function isFlowType(node: object, opts?: object | null): boolean;
+export function isFor(node: object, opts?: object | null): boolean;
+export function isForInStatement(node: object, opts?: object | null): node is ForInStatement;
+export function isForOfStatement(node: object, opts?: object | null): node is ForOfStatement;
+export function isForStatement(node: object, opts?: object | null): node is ForStatement;
+export function isForXStatement(node: object, opts?: object | null): boolean;
+export function isFunction(node: object, opts?: object | null): boolean;
+export function isFunctionDeclaration(node: object, opts?: object | null): node is FunctionDeclaration;
+export function isFunctionExpression(node: object, opts?: object | null): node is FunctionExpression;
+export function isFunctionParent(node: object, opts?: object | null): boolean;
+export function isFunctionTypeAnnotation(node: object, opts?: object | null): node is FunctionTypeAnnotation;
+export function isFunctionTypeParam(node: object, opts?: object | null): node is FunctionTypeParam;
+export function isGenericTypeAnnotation(node: object, opts?: object | null): node is GenericTypeAnnotation;
+export function isIdentifier(node: object, opts?: object | null): node is Identifier;
+export function isIfStatement(node: object, opts?: object | null): node is IfStatement;
+export function isImmutable(node: object, opts?: object | null): boolean;
+export function isImport(node: object, opts?: object | null): node is Import;
+export function isImportDeclaration(node: object, opts?: object | null): node is ImportDeclaration;
+export function isImportDefaultSpecifier(node: object, opts?: object | null): node is ImportDefaultSpecifier;
+export function isImportNamespaceSpecifier(node: object, opts?: object | null): node is ImportNamespaceSpecifier;
+export function isImportSpecifier(node: object, opts?: object | null): node is ImportSpecifier;
+export function isInferredPredicate(node: object, opts?: object | null): node is InferredPredicate;
+export function isInterfaceDeclaration(node: object, opts?: object | null): node is InterfaceDeclaration;
+export function isInterfaceExtends(node: object, opts?: object | null): node is InterfaceExtends;
+export function isIntersectionTypeAnnotation(node: object, opts?: object | null): node is IntersectionTypeAnnotation;
+export function isJSX(node: object, opts?: object | null): boolean;
+export function isJSXAttribute(node: object, opts?: object | null): node is JSXAttribute;
+export function isJSXClosingElement(node: object, opts?: object | null): node is JSXClosingElement;
+export function isJSXClosingFragment(node: object, opts?: object | null): node is JSXClosingFragment;
+export function isJSXElement(node: object, opts?: object | null): node is JSXElement;
+export function isJSXEmptyExpression(node: object, opts?: object | null): node is JSXEmptyExpression;
+export function isJSXExpressionContainer(node: object, opts?: object | null): node is JSXExpressionContainer;
+export function isJSXFragment(node: object, opts?: object | null): node is JSXFragment;
+export function isJSXIdentifier(node: object, opts?: object | null): node is JSXIdentifier;
+export function isJSXMemberExpression(node: object, opts?: object | null): node is JSXMemberExpression;
+export function isJSXNamespacedName(node: object, opts?: object | null): node is JSXNamespacedName;
+export function isJSXOpeningElement(node: object, opts?: object | null): node is JSXOpeningElement;
+export function isJSXOpeningFragment(node: object, opts?: object | null): node is JSXOpeningFragment;
+export function isJSXSpreadAttribute(node: object, opts?: object | null): node is JSXSpreadAttribute;
+export function isJSXSpreadChild(node: object, opts?: object | null): node is JSXSpreadChild;
+export function isJSXText(node: object, opts?: object | null): node is JSXText;
+export function isLVal(node: object, opts?: object | null): boolean;
+export function isLabeledStatement(node: object, opts?: object | null): node is LabeledStatement;
+export function isLiteral(node: object, opts?: object | null): boolean;
+export function isLogicalExpression(node: object, opts?: object | null): node is LogicalExpression;
+export function isLoop(node: object, opts?: object | null): boolean;
+export function isMemberExpression(node: object, opts?: object | null): node is MemberExpression;
+export function isMetaProperty(node: object, opts?: object | null): node is MetaProperty;
+export function isMethod(node: object, opts?: object | null): boolean;
+export function isMixedTypeAnnotation(node: object, opts?: object | null): node is MixedTypeAnnotation;
+export function isModuleDeclaration(node: object, opts?: object | null): boolean;
+export function isModuleSpecifier(node: object, opts?: object | null): boolean;
+export function isNewExpression(node: object, opts?: object | null): node is NewExpression;
+export function isNoop(node: object, opts?: object | null): node is Noop;
+export function isNullLiteral(node: object, opts?: object | null): node is NullLiteral;
+export function isNullLiteralTypeAnnotation(node: object, opts?: object | null): node is NullLiteralTypeAnnotation;
+export function isNullableTypeAnnotation(node: object, opts?: object | null): node is NullableTypeAnnotation;
+export function isNumberLiteral(node: object, opts?: object | null): boolean;
+export function isNumberLiteralTypeAnnotation(node: object, opts?: object | null): node is NumberLiteralTypeAnnotation;
+export function isNumberTypeAnnotation(node: object, opts?: object | null): node is NumberTypeAnnotation;
+export function isNumericLiteral(node: object, opts?: object | null): node is NumericLiteral;
+export function isObjectExpression(node: object, opts?: object | null): node is ObjectExpression;
+export function isObjectMember(node: object, opts?: object | null): boolean;
+export function isObjectMethod(node: object, opts?: object | null): node is ObjectMethod;
+export function isObjectPattern(node: object, opts?: object | null): node is ObjectPattern;
+export function isObjectProperty(node: object, opts?: object | null): node is ObjectProperty;
+export function isObjectTypeAnnotation(node: object, opts?: object | null): node is ObjectTypeAnnotation;
+export function isObjectTypeCallProperty(node: object, opts?: object | null): node is ObjectTypeCallProperty;
+export function isObjectTypeIndexer(node: object, opts?: object | null): node is ObjectTypeIndexer;
+export function isObjectTypeProperty(node: object, opts?: object | null): node is ObjectTypeProperty;
+export function isObjectTypeSpreadProperty(node: object, opts?: object | null): node is ObjectTypeSpreadProperty;
+export function isOpaqueType(node: object, opts?: object | null): node is OpaqueType;
+export function isOptionalCallExpression(node: object, opts?: object | null): node is OptionalCallExpression;
+export function isOptionalMemberExpression(node: object, opts?: object | null): node is OptionalMemberExpression;
+export function isParenthesizedExpression(node: object, opts?: object | null): node is ParenthesizedExpression;
+export function isPattern(node: object, opts?: object | null): boolean;
+export function isPatternLike(node: object, opts?: object | null): boolean;
+export function isPrivate(node: object, opts?: object | null): boolean;
+export function isPrivateName(node: object, opts?: object | null): node is PrivateName;
+export function isProgram(node: object, opts?: object | null): node is Program;
+export function isProperty(node: object, opts?: object | null): boolean;
+export function isPureish(node: object, opts?: object | null): boolean;
+export function isQualifiedTypeIdentifier(node: object, opts?: object | null): node is QualifiedTypeIdentifier;
+export function isRegExpLiteral(node: object, opts?: object | null): node is RegExpLiteral;
+export function isRegexLiteral(node: object, opts?: object | null): boolean;
+export function isRestElement(node: object, opts?: object | null): node is RestElement;
+export function isRestProperty(node: object, opts?: object | null): boolean;
+export function isReturnStatement(node: object, opts?: object | null): node is ReturnStatement;
+export function isScopable(node: object, opts?: object | null): boolean;
+export function isSequenceExpression(node: object, opts?: object | null): node is SequenceExpression;
+export function isSpreadElement(node: object, opts?: object | null): node is SpreadElement;
+export function isSpreadProperty(node: object, opts?: object | null): boolean;
+export function isStatement(node: object, opts?: object | null): boolean;
+export function isStringLiteral(node: object, opts?: object | null): node is StringLiteral;
+export function isStringLiteralTypeAnnotation(node: object, opts?: object | null): node is StringLiteralTypeAnnotation;
+export function isStringTypeAnnotation(node: object, opts?: object | null): node is StringTypeAnnotation;
+export function isSuper(node: object, opts?: object | null): node is Super;
+export function isSwitchCase(node: object, opts?: object | null): node is SwitchCase;
+export function isSwitchStatement(node: object, opts?: object | null): node is SwitchStatement;
+export function isTSAnyKeyword(node: object, opts?: object | null): node is TSAnyKeyword;
+export function isTSArrayType(node: object, opts?: object | null): node is TSArrayType;
+export function isTSAsExpression(node: object, opts?: object | null): node is TSAsExpression;
+export function isTSBooleanKeyword(node: object, opts?: object | null): node is TSBooleanKeyword;
+export function isTSCallSignatureDeclaration(node: object, opts?: object | null): node is TSCallSignatureDeclaration;
+export function isTSConditionalType(node: object, opts?: object | null): node is TSConditionalType;
+export function isTSConstructSignatureDeclaration(node: object, opts?: object | null): node is TSConstructSignatureDeclaration;
+export function isTSConstructorType(node: object, opts?: object | null): node is TSConstructorType;
+export function isTSDeclareFunction(node: object, opts?: object | null): node is TSDeclareFunction;
+export function isTSDeclareMethod(node: object, opts?: object | null): node is TSDeclareMethod;
+export function isTSEntityName(node: object, opts?: object | null): boolean;
+export function isTSEnumDeclaration(node: object, opts?: object | null): node is TSEnumDeclaration;
+export function isTSEnumMember(node: object, opts?: object | null): node is TSEnumMember;
+export function isTSExportAssignment(node: object, opts?: object | null): node is TSExportAssignment;
+export function isTSExpressionWithTypeArguments(node: object, opts?: object | null): node is TSExpressionWithTypeArguments;
+export function isTSExternalModuleReference(node: object, opts?: object | null): node is TSExternalModuleReference;
+export function isTSFunctionType(node: object, opts?: object | null): node is TSFunctionType;
+export function isTSImportEqualsDeclaration(node: object, opts?: object | null): node is TSImportEqualsDeclaration;
+export function isTSIndexSignature(node: object, opts?: object | null): node is TSIndexSignature;
+export function isTSIndexedAccessType(node: object, opts?: object | null): node is TSIndexedAccessType;
+export function isTSInferType(node: object, opts?: object | null): node is TSInferType;
+export function isTSInterfaceBody(node: object, opts?: object | null): node is TSInterfaceBody;
+export function isTSInterfaceDeclaration(node: object, opts?: object | null): node is TSInterfaceDeclaration;
+export function isTSIntersectionType(node: object, opts?: object | null): node is TSIntersectionType;
+export function isTSLiteralType(node: object, opts?: object | null): node is TSLiteralType;
+export function isTSMappedType(node: object, opts?: object | null): node is TSMappedType;
+export function isTSMethodSignature(node: object, opts?: object | null): node is TSMethodSignature;
+export function isTSModuleBlock(node: object, opts?: object | null): node is TSModuleBlock;
+export function isTSModuleDeclaration(node: object, opts?: object | null): node is TSModuleDeclaration;
+export function isTSNamespaceExportDeclaration(node: object, opts?: object | null): node is TSNamespaceExportDeclaration;
+export function isTSNeverKeyword(node: object, opts?: object | null): node is TSNeverKeyword;
+export function isTSNonNullExpression(node: object, opts?: object | null): node is TSNonNullExpression;
+export function isTSNullKeyword(node: object, opts?: object | null): node is TSNullKeyword;
+export function isTSNumberKeyword(node: object, opts?: object | null): node is TSNumberKeyword;
+export function isTSObjectKeyword(node: object, opts?: object | null): node is TSObjectKeyword;
+export function isTSParameterProperty(node: object, opts?: object | null): node is TSParameterProperty;
+export function isTSParenthesizedType(node: object, opts?: object | null): node is TSParenthesizedType;
+export function isTSPropertySignature(node: object, opts?: object | null): node is TSPropertySignature;
+export function isTSQualifiedName(node: object, opts?: object | null): node is TSQualifiedName;
+export function isTSStringKeyword(node: object, opts?: object | null): node is TSStringKeyword;
+export function isTSSymbolKeyword(node: object, opts?: object | null): node is TSSymbolKeyword;
+export function isTSThisType(node: object, opts?: object | null): node is TSThisType;
+export function isTSTupleType(node: object, opts?: object | null): node is TSTupleType;
+export function isTSType(node: object, opts?: object | null): boolean;
+export function isTSTypeAliasDeclaration(node: object, opts?: object | null): node is TSTypeAliasDeclaration;
+export function isTSTypeAnnotation(node: object, opts?: object | null): node is TSTypeAnnotation;
+export function isTSTypeAssertion(node: object, opts?: object | null): node is TSTypeAssertion;
+export function isTSTypeElement(node: object, opts?: object | null): boolean;
+export function isTSTypeLiteral(node: object, opts?: object | null): node is TSTypeLiteral;
+export function isTSTypeOperator(node: object, opts?: object | null): node is TSTypeOperator;
+export function isTSTypeParameter(node: object, opts?: object | null): node is TSTypeParameter;
+export function isTSTypeParameterDeclaration(node: object, opts?: object | null): node is TSTypeParameterDeclaration;
+export function isTSTypeParameterInstantiation(node: object, opts?: object | null): node is TSTypeParameterInstantiation;
+export function isTSTypePredicate(node: object, opts?: object | null): node is TSTypePredicate;
+export function isTSTypeQuery(node: object, opts?: object | null): node is TSTypeQuery;
+export function isTSTypeReference(node: object, opts?: object | null): node is TSTypeReference;
+export function isTSUndefinedKeyword(node: object, opts?: object | null): node is TSUndefinedKeyword;
+export function isTSUnionType(node: object, opts?: object | null): node is TSUnionType;
+export function isTSVoidKeyword(node: object, opts?: object | null): node is TSVoidKeyword;
+export function isTaggedTemplateExpression(node: object, opts?: object | null): node is TaggedTemplateExpression;
+export function isTemplateElement(node: object, opts?: object | null): node is TemplateElement;
+export function isTemplateLiteral(node: object, opts?: object | null): node is TemplateLiteral;
+export function isTerminatorless(node: object, opts?: object | null): boolean;
+export function isThisExpression(node: object, opts?: object | null): node is ThisExpression;
+export function isThisTypeAnnotation(node: object, opts?: object | null): node is ThisTypeAnnotation;
+export function isThrowStatement(node: object, opts?: object | null): node is ThrowStatement;
+export function isTryStatement(node: object, opts?: object | null): node is TryStatement;
+export function isTupleTypeAnnotation(node: object, opts?: object | null): node is TupleTypeAnnotation;
+export function isTypeAlias(node: object, opts?: object | null): node is TypeAlias;
+export function isTypeAnnotation(node: object, opts?: object | null): node is TypeAnnotation;
+export function isTypeCastExpression(node: object, opts?: object | null): node is TypeCastExpression;
+export function isTypeParameter(node: object, opts?: object | null): node is TypeParameter;
+export function isTypeParameterDeclaration(node: object, opts?: object | null): node is TypeParameterDeclaration;
+export function isTypeParameterInstantiation(node: object, opts?: object | null): node is TypeParameterInstantiation;
+export function isTypeofTypeAnnotation(node: object, opts?: object | null): node is TypeofTypeAnnotation;
+export function isUnaryExpression(node: object, opts?: object | null): node is UnaryExpression;
+export function isUnaryLike(node: object, opts?: object | null): boolean;
+export function isUnionTypeAnnotation(node: object, opts?: object | null): node is UnionTypeAnnotation;
+export function isUpdateExpression(node: object, opts?: object | null): node is UpdateExpression;
+export function isUserWhitespacable(node: object, opts?: object | null): boolean;
+export function isVariableDeclaration(node: object, opts?: object | null): node is VariableDeclaration;
+export function isVariableDeclarator(node: object, opts?: object | null): node is VariableDeclarator;
+export function isVariance(node: object, opts?: object | null): node is Variance;
+export function isVoidTypeAnnotation(node: object, opts?: object | null): node is VoidTypeAnnotation;
+export function isWhile(node: object, opts?: object | null): boolean;
+export function isWhileStatement(node: object, opts?: object | null): node is WhileStatement;
+export function isWithStatement(node: object, opts?: object | null): node is WithStatement;
+export function isYieldExpression(node: object, opts?: object | null): node is YieldExpression;
+export function validate(n: Node, key: string, value: any): void;
+export function clone<T extends Node>(n: T): T;
+export function cloneDeep<T extends Node>(n: T): T;
+export function removeProperties(
+  n: Node,
+  opts?: { preserveComments: boolean } | null
+): void;
+export function removePropertiesDeep<T extends Node>(
+  n: T,
+  opts?: { preserveComments: boolean } | null
+): T;
+export type TraversalAncestors = ReadonlyArray<{
+  node: Node,
+  key: string,
+  index?: number,
+}>;
+export type TraversalHandler<T> = (node: Node, parent: TraversalAncestors, type: T) => void;
+export type TraversalHandlers<T> = {
+  enter?: TraversalHandler<T>,
+  exit?: TraversalHandler<T>,
+};
+export function traverse<T>(n: Node, h: TraversalHandler<T> | TraversalHandlers<T>, state?: T): void;
diff --git a/node_modules/@babel/types/lib/index.js b/node_modules/@babel/types/lib/index.js
new file mode 100644
index 00000000..7e62e5a5
--- /dev/null
+++ b/node_modules/@babel/types/lib/index.js
@@ -0,0 +1,570 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  react: true,
+  assertNode: true,
+  createTypeAnnotationBasedOnTypeof: true,
+  createUnionTypeAnnotation: true,
+  cloneNode: true,
+  clone: true,
+  cloneDeep: true,
+  cloneWithoutLoc: true,
+  addComment: true,
+  addComments: true,
+  inheritInnerComments: true,
+  inheritLeadingComments: true,
+  inheritsComments: true,
+  inheritTrailingComments: true,
+  removeComments: true,
+  ensureBlock: true,
+  toBindingIdentifierName: true,
+  toBlock: true,
+  toComputedKey: true,
+  toExpression: true,
+  toIdentifier: true,
+  toKeyAlias: true,
+  toSequenceExpression: true,
+  toStatement: true,
+  valueToNode: true,
+  appendToMemberExpression: true,
+  inherits: true,
+  prependToMemberExpression: true,
+  removeProperties: true,
+  removePropertiesDeep: true,
+  removeTypeDuplicates: true,
+  getBindingIdentifiers: true,
+  getOuterBindingIdentifiers: true,
+  traverse: true,
+  traverseFast: true,
+  shallowEqual: true,
+  is: true,
+  isBinding: true,
+  isBlockScoped: true,
+  isImmutable: true,
+  isLet: true,
+  isNode: true,
+  isNodesEquivalent: true,
+  isReferenced: true,
+  isScope: true,
+  isSpecifierDefault: true,
+  isType: true,
+  isValidES3Identifier: true,
+  isValidIdentifier: true,
+  isVar: true,
+  matchesPattern: true,
+  validate: true,
+  buildMatchMemberExpression: true
+};
+Object.defineProperty(exports, "assertNode", {
+  enumerable: true,
+  get: function get() {
+    return _assertNode.default;
+  }
+});
+Object.defineProperty(exports, "createTypeAnnotationBasedOnTypeof", {
+  enumerable: true,
+  get: function get() {
+    return _createTypeAnnotationBasedOnTypeof.default;
+  }
+});
+Object.defineProperty(exports, "createUnionTypeAnnotation", {
+  enumerable: true,
+  get: function get() {
+    return _createUnionTypeAnnotation.default;
+  }
+});
+Object.defineProperty(exports, "cloneNode", {
+  enumerable: true,
+  get: function get() {
+    return _cloneNode.default;
+  }
+});
+Object.defineProperty(exports, "clone", {
+  enumerable: true,
+  get: function get() {
+    return _clone.default;
+  }
+});
+Object.defineProperty(exports, "cloneDeep", {
+  enumerable: true,
+  get: function get() {
+    return _cloneDeep.default;
+  }
+});
+Object.defineProperty(exports, "cloneWithoutLoc", {
+  enumerable: true,
+  get: function get() {
+    return _cloneWithoutLoc.default;
+  }
+});
+Object.defineProperty(exports, "addComment", {
+  enumerable: true,
+  get: function get() {
+    return _addComment.default;
+  }
+});
+Object.defineProperty(exports, "addComments", {
+  enumerable: true,
+  get: function get() {
+    return _addComments.default;
+  }
+});
+Object.defineProperty(exports, "inheritInnerComments", {
+  enumerable: true,
+  get: function get() {
+    return _inheritInnerComments.default;
+  }
+});
+Object.defineProperty(exports, "inheritLeadingComments", {
+  enumerable: true,
+  get: function get() {
+    return _inheritLeadingComments.default;
+  }
+});
+Object.defineProperty(exports, "inheritsComments", {
+  enumerable: true,
+  get: function get() {
+    return _inheritsComments.default;
+  }
+});
+Object.defineProperty(exports, "inheritTrailingComments", {
+  enumerable: true,
+  get: function get() {
+    return _inheritTrailingComments.default;
+  }
+});
+Object.defineProperty(exports, "removeComments", {
+  enumerable: true,
+  get: function get() {
+    return _removeComments.default;
+  }
+});
+Object.defineProperty(exports, "ensureBlock", {
+  enumerable: true,
+  get: function get() {
+    return _ensureBlock.default;
+  }
+});
+Object.defineProperty(exports, "toBindingIdentifierName", {
+  enumerable: true,
+  get: function get() {
+    return _toBindingIdentifierName.default;
+  }
+});
+Object.defineProperty(exports, "toBlock", {
+  enumerable: true,
+  get: function get() {
+    return _toBlock.default;
+  }
+});
+Object.defineProperty(exports, "toComputedKey", {
+  enumerable: true,
+  get: function get() {
+    return _toComputedKey.default;
+  }
+});
+Object.defineProperty(exports, "toExpression", {
+  enumerable: true,
+  get: function get() {
+    return _toExpression.default;
+  }
+});
+Object.defineProperty(exports, "toIdentifier", {
+  enumerable: true,
+  get: function get() {
+    return _toIdentifier.default;
+  }
+});
+Object.defineProperty(exports, "toKeyAlias", {
+  enumerable: true,
+  get: function get() {
+    return _toKeyAlias.default;
+  }
+});
+Object.defineProperty(exports, "toSequenceExpression", {
+  enumerable: true,
+  get: function get() {
+    return _toSequenceExpression.default;
+  }
+});
+Object.defineProperty(exports, "toStatement", {
+  enumerable: true,
+  get: function get() {
+    return _toStatement.default;
+  }
+});
+Object.defineProperty(exports, "valueToNode", {
+  enumerable: true,
+  get: function get() {
+    return _valueToNode.default;
+  }
+});
+Object.defineProperty(exports, "appendToMemberExpression", {
+  enumerable: true,
+  get: function get() {
+    return _appendToMemberExpression.default;
+  }
+});
+Object.defineProperty(exports, "inherits", {
+  enumerable: true,
+  get: function get() {
+    return _inherits.default;
+  }
+});
+Object.defineProperty(exports, "prependToMemberExpression", {
+  enumerable: true,
+  get: function get() {
+    return _prependToMemberExpression.default;
+  }
+});
+Object.defineProperty(exports, "removeProperties", {
+  enumerable: true,
+  get: function get() {
+    return _removeProperties.default;
+  }
+});
+Object.defineProperty(exports, "removePropertiesDeep", {
+  enumerable: true,
+  get: function get() {
+    return _removePropertiesDeep.default;
+  }
+});
+Object.defineProperty(exports, "removeTypeDuplicates", {
+  enumerable: true,
+  get: function get() {
+    return _removeTypeDuplicates.default;
+  }
+});
+Object.defineProperty(exports, "getBindingIdentifiers", {
+  enumerable: true,
+  get: function get() {
+    return _getBindingIdentifiers.default;
+  }
+});
+Object.defineProperty(exports, "getOuterBindingIdentifiers", {
+  enumerable: true,
+  get: function get() {
+    return _getOuterBindingIdentifiers.default;
+  }
+});
+Object.defineProperty(exports, "traverse", {
+  enumerable: true,
+  get: function get() {
+    return _traverse.default;
+  }
+});
+Object.defineProperty(exports, "traverseFast", {
+  enumerable: true,
+  get: function get() {
+    return _traverseFast.default;
+  }
+});
+Object.defineProperty(exports, "shallowEqual", {
+  enumerable: true,
+  get: function get() {
+    return _shallowEqual.default;
+  }
+});
+Object.defineProperty(exports, "is", {
+  enumerable: true,
+  get: function get() {
+    return _is.default;
+  }
+});
+Object.defineProperty(exports, "isBinding", {
+  enumerable: true,
+  get: function get() {
+    return _isBinding.default;
+  }
+});
+Object.defineProperty(exports, "isBlockScoped", {
+  enumerable: true,
+  get: function get() {
+    return _isBlockScoped.default;
+  }
+});
+Object.defineProperty(exports, "isImmutable", {
+  enumerable: true,
+  get: function get() {
+    return _isImmutable.default;
+  }
+});
+Object.defineProperty(exports, "isLet", {
+  enumerable: true,
+  get: function get() {
+    return _isLet.default;
+  }
+});
+Object.defineProperty(exports, "isNode", {
+  enumerable: true,
+  get: function get() {
+    return _isNode.default;
+  }
+});
+Object.defineProperty(exports, "isNodesEquivalent", {
+  enumerable: true,
+  get: function get() {
+    return _isNodesEquivalent.default;
+  }
+});
+Object.defineProperty(exports, "isReferenced", {
+  enumerable: true,
+  get: function get() {
+    return _isReferenced.default;
+  }
+});
+Object.defineProperty(exports, "isScope", {
+  enumerable: true,
+  get: function get() {
+    return _isScope.default;
+  }
+});
+Object.defineProperty(exports, "isSpecifierDefault", {
+  enumerable: true,
+  get: function get() {
+    return _isSpecifierDefault.default;
+  }
+});
+Object.defineProperty(exports, "isType", {
+  enumerable: true,
+  get: function get() {
+    return _isType.default;
+  }
+});
+Object.defineProperty(exports, "isValidES3Identifier", {
+  enumerable: true,
+  get: function get() {
+    return _isValidES3Identifier.default;
+  }
+});
+Object.defineProperty(exports, "isValidIdentifier", {
+  enumerable: true,
+  get: function get() {
+    return _isValidIdentifier.default;
+  }
+});
+Object.defineProperty(exports, "isVar", {
+  enumerable: true,
+  get: function get() {
+    return _isVar.default;
+  }
+});
+Object.defineProperty(exports, "matchesPattern", {
+  enumerable: true,
+  get: function get() {
+    return _matchesPattern.default;
+  }
+});
+Object.defineProperty(exports, "validate", {
+  enumerable: true,
+  get: function get() {
+    return _validate.default;
+  }
+});
+Object.defineProperty(exports, "buildMatchMemberExpression", {
+  enumerable: true,
+  get: function get() {
+    return _buildMatchMemberExpression.default;
+  }
+});
+exports.react = void 0;
+
+var _isReactComponent = _interopRequireDefault(require("./validators/react/isReactComponent"));
+
+var _isCompatTag = _interopRequireDefault(require("./validators/react/isCompatTag"));
+
+var _buildChildren = _interopRequireDefault(require("./builders/react/buildChildren"));
+
+var _assertNode = _interopRequireDefault(require("./asserts/assertNode"));
+
+var _generated = require("./asserts/generated");
+
+Object.keys(_generated).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _generated[key];
+    }
+  });
+});
+
+var _createTypeAnnotationBasedOnTypeof = _interopRequireDefault(require("./builders/flow/createTypeAnnotationBasedOnTypeof"));
+
+var _createUnionTypeAnnotation = _interopRequireDefault(require("./builders/flow/createUnionTypeAnnotation"));
+
+var _generated2 = require("./builders/generated");
+
+Object.keys(_generated2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _generated2[key];
+    }
+  });
+});
+
+var _cloneNode = _interopRequireDefault(require("./clone/cloneNode"));
+
+var _clone = _interopRequireDefault(require("./clone/clone"));
+
+var _cloneDeep = _interopRequireDefault(require("./clone/cloneDeep"));
+
+var _cloneWithoutLoc = _interopRequireDefault(require("./clone/cloneWithoutLoc"));
+
+var _addComment = _interopRequireDefault(require("./comments/addComment"));
+
+var _addComments = _interopRequireDefault(require("./comments/addComments"));
+
+var _inheritInnerComments = _interopRequireDefault(require("./comments/inheritInnerComments"));
+
+var _inheritLeadingComments = _interopRequireDefault(require("./comments/inheritLeadingComments"));
+
+var _inheritsComments = _interopRequireDefault(require("./comments/inheritsComments"));
+
+var _inheritTrailingComments = _interopRequireDefault(require("./comments/inheritTrailingComments"));
+
+var _removeComments = _interopRequireDefault(require("./comments/removeComments"));
+
+var _generated3 = require("./constants/generated");
+
+Object.keys(_generated3).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _generated3[key];
+    }
+  });
+});
+
+var _constants = require("./constants");
+
+Object.keys(_constants).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _constants[key];
+    }
+  });
+});
+
+var _ensureBlock = _interopRequireDefault(require("./converters/ensureBlock"));
+
+var _toBindingIdentifierName = _interopRequireDefault(require("./converters/toBindingIdentifierName"));
+
+var _toBlock = _interopRequireDefault(require("./converters/toBlock"));
+
+var _toComputedKey = _interopRequireDefault(require("./converters/toComputedKey"));
+
+var _toExpression = _interopRequireDefault(require("./converters/toExpression"));
+
+var _toIdentifier = _interopRequireDefault(require("./converters/toIdentifier"));
+
+var _toKeyAlias = _interopRequireDefault(require("./converters/toKeyAlias"));
+
+var _toSequenceExpression = _interopRequireDefault(require("./converters/toSequenceExpression"));
+
+var _toStatement = _interopRequireDefault(require("./converters/toStatement"));
+
+var _valueToNode = _interopRequireDefault(require("./converters/valueToNode"));
+
+var _definitions = require("./definitions");
+
+Object.keys(_definitions).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _definitions[key];
+    }
+  });
+});
+
+var _appendToMemberExpression = _interopRequireDefault(require("./modifications/appendToMemberExpression"));
+
+var _inherits = _interopRequireDefault(require("./modifications/inherits"));
+
+var _prependToMemberExpression = _interopRequireDefault(require("./modifications/prependToMemberExpression"));
+
+var _removeProperties = _interopRequireDefault(require("./modifications/removeProperties"));
+
+var _removePropertiesDeep = _interopRequireDefault(require("./modifications/removePropertiesDeep"));
+
+var _removeTypeDuplicates = _interopRequireDefault(require("./modifications/flow/removeTypeDuplicates"));
+
+var _getBindingIdentifiers = _interopRequireDefault(require("./retrievers/getBindingIdentifiers"));
+
+var _getOuterBindingIdentifiers = _interopRequireDefault(require("./retrievers/getOuterBindingIdentifiers"));
+
+var _traverse = _interopRequireDefault(require("./traverse/traverse"));
+
+var _traverseFast = _interopRequireDefault(require("./traverse/traverseFast"));
+
+var _shallowEqual = _interopRequireDefault(require("./utils/shallowEqual"));
+
+var _is = _interopRequireDefault(require("./validators/is"));
+
+var _isBinding = _interopRequireDefault(require("./validators/isBinding"));
+
+var _isBlockScoped = _interopRequireDefault(require("./validators/isBlockScoped"));
+
+var _isImmutable = _interopRequireDefault(require("./validators/isImmutable"));
+
+var _isLet = _interopRequireDefault(require("./validators/isLet"));
+
+var _isNode = _interopRequireDefault(require("./validators/isNode"));
+
+var _isNodesEquivalent = _interopRequireDefault(require("./validators/isNodesEquivalent"));
+
+var _isReferenced = _interopRequireDefault(require("./validators/isReferenced"));
+
+var _isScope = _interopRequireDefault(require("./validators/isScope"));
+
+var _isSpecifierDefault = _interopRequireDefault(require("./validators/isSpecifierDefault"));
+
+var _isType = _interopRequireDefault(require("./validators/isType"));
+
+var _isValidES3Identifier = _interopRequireDefault(require("./validators/isValidES3Identifier"));
+
+var _isValidIdentifier = _interopRequireDefault(require("./validators/isValidIdentifier"));
+
+var _isVar = _interopRequireDefault(require("./validators/isVar"));
+
+var _matchesPattern = _interopRequireDefault(require("./validators/matchesPattern"));
+
+var _validate = _interopRequireDefault(require("./validators/validate"));
+
+var _buildMatchMemberExpression = _interopRequireDefault(require("./validators/buildMatchMemberExpression"));
+
+var _generated4 = require("./validators/generated");
+
+Object.keys(_generated4).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _generated4[key];
+    }
+  });
+});
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const react = {
+  isReactComponent: _isReactComponent.default,
+  isCompatTag: _isCompatTag.default,
+  buildChildren: _buildChildren.default
+};
+exports.react = react;
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/index.js.flow b/node_modules/@babel/types/lib/index.js.flow
new file mode 100644
index 00000000..bd5fde60
--- /dev/null
+++ b/node_modules/@babel/types/lib/index.js.flow
@@ -0,0 +1,1851 @@
+// NOTE: This file is autogenerated. Do not modify.
+// See scripts/generators/flow.js for script used.
+
+declare class BabelNodeComment {
+  value: string;
+  start: number;
+  end: number;
+  loc: BabelNodeSourceLocation;
+}
+
+declare class BabelNodeBlockComment extends BabelNodeComment {
+  type: "BlockComment";
+}
+
+declare class BabelNodeLineComment extends BabelNodeComment {
+  type: "LineComment";
+}
+
+declare class BabelNodeSourceLocation {
+  start: {
+    line: number;
+    column: number;
+  };
+
+  end: {
+    line: number;
+    column: number;
+  };
+}
+
+declare class BabelNode {
+  leadingComments?: Array<BabelNodeComment>;
+  innerComments?: Array<BabelNodeComment>;
+  trailingComments?: Array<BabelNodeComment>;
+  start: ?number;
+  end: ?number;
+  loc: ?BabelNodeSourceLocation;
+}
+
+declare class BabelNodeArrayExpression extends BabelNode {
+  type: "ArrayExpression";
+  elements?: Array<null | BabelNodeExpression | BabelNodeSpreadElement>;
+}
+
+declare class BabelNodeAssignmentExpression extends BabelNode {
+  type: "AssignmentExpression";
+  operator: string;
+  left: BabelNodeLVal;
+  right: BabelNodeExpression;
+}
+
+declare class BabelNodeBinaryExpression extends BabelNode {
+  type: "BinaryExpression";
+  operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=";
+  left: BabelNodeExpression;
+  right: BabelNodeExpression;
+}
+
+declare class BabelNodeDirective extends BabelNode {
+  type: "Directive";
+  value: BabelNodeDirectiveLiteral;
+}
+
+declare class BabelNodeDirectiveLiteral extends BabelNode {
+  type: "DirectiveLiteral";
+  value: string;
+}
+
+declare class BabelNodeBlockStatement extends BabelNode {
+  type: "BlockStatement";
+  body: Array<BabelNodeStatement>;
+  directives?: Array<BabelNodeDirective>;
+}
+
+declare class BabelNodeBreakStatement extends BabelNode {
+  type: "BreakStatement";
+  label?: BabelNodeIdentifier;
+}
+
+declare class BabelNodeCallExpression extends BabelNode {
+  type: "CallExpression";
+  callee: BabelNodeExpression;
+  arguments: Array<BabelNodeExpression | BabelNodeSpreadElement | BabelNodeJSXNamespacedName>;
+  optional?: true | false;
+  typeParameters?: BabelNodeTypeParameterInstantiation | BabelNodeTSTypeParameterInstantiation;
+}
+
+declare class BabelNodeCatchClause extends BabelNode {
+  type: "CatchClause";
+  param?: BabelNodeIdentifier;
+  body: BabelNodeBlockStatement;
+}
+
+declare class BabelNodeConditionalExpression extends BabelNode {
+  type: "ConditionalExpression";
+  test: BabelNodeExpression;
+  consequent: BabelNodeExpression;
+  alternate: BabelNodeExpression;
+}
+
+declare class BabelNodeContinueStatement extends BabelNode {
+  type: "ContinueStatement";
+  label?: BabelNodeIdentifier;
+}
+
+declare class BabelNodeDebuggerStatement extends BabelNode {
+  type: "DebuggerStatement";
+}
+
+declare class BabelNodeDoWhileStatement extends BabelNode {
+  type: "DoWhileStatement";
+  test: BabelNodeExpression;
+  body: BabelNodeStatement;
+}
+
+declare class BabelNodeEmptyStatement extends BabelNode {
+  type: "EmptyStatement";
+}
+
+declare class BabelNodeExpressionStatement extends BabelNode {
+  type: "ExpressionStatement";
+  expression: BabelNodeExpression;
+}
+
+declare class BabelNodeFile extends BabelNode {
+  type: "File";
+  program: BabelNodeProgram;
+  comments: any;
+  tokens: any;
+}
+
+declare class BabelNodeForInStatement extends BabelNode {
+  type: "ForInStatement";
+  left: BabelNodeVariableDeclaration | BabelNodeLVal;
+  right: BabelNodeExpression;
+  body: BabelNodeStatement;
+}
+
+declare class BabelNodeForStatement extends BabelNode {
+  type: "ForStatement";
+  init?: BabelNodeVariableDeclaration | BabelNodeExpression;
+  test?: BabelNodeExpression;
+  update?: BabelNodeExpression;
+  body: BabelNodeStatement;
+}
+
+declare class BabelNodeFunctionDeclaration extends BabelNode {
+  type: "FunctionDeclaration";
+  id?: BabelNodeIdentifier;
+  params: Array<BabelNodeLVal>;
+  body: BabelNodeBlockStatement;
+  generator?: boolean;
+  async?: boolean;
+  declare?: boolean;
+  returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
+  typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
+}
+
+declare class BabelNodeFunctionExpression extends BabelNode {
+  type: "FunctionExpression";
+  id?: BabelNodeIdentifier;
+  params: Array<BabelNodeLVal>;
+  body: BabelNodeBlockStatement;
+  generator?: boolean;
+  async?: boolean;
+  returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
+  typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
+}
+
+declare class BabelNodeIdentifier extends BabelNode {
+  type: "Identifier";
+  name: string;
+  decorators?: Array<BabelNodeDecorator>;
+  optional?: boolean;
+  typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
+}
+
+declare class BabelNodeIfStatement extends BabelNode {
+  type: "IfStatement";
+  test: BabelNodeExpression;
+  consequent: BabelNodeStatement;
+  alternate?: BabelNodeStatement;
+}
+
+declare class BabelNodeLabeledStatement extends BabelNode {
+  type: "LabeledStatement";
+  label: BabelNodeIdentifier;
+  body: BabelNodeStatement;
+}
+
+declare class BabelNodeStringLiteral extends BabelNode {
+  type: "StringLiteral";
+  value: string;
+}
+
+declare class BabelNodeNumericLiteral extends BabelNode {
+  type: "NumericLiteral";
+  value: number;
+}
+
+declare class BabelNodeNullLiteral extends BabelNode {
+  type: "NullLiteral";
+}
+
+declare class BabelNodeBooleanLiteral extends BabelNode {
+  type: "BooleanLiteral";
+  value: boolean;
+}
+
+declare class BabelNodeRegExpLiteral extends BabelNode {
+  type: "RegExpLiteral";
+  pattern: string;
+  flags?: string;
+}
+
+declare class BabelNodeLogicalExpression extends BabelNode {
+  type: "LogicalExpression";
+  operator: "||" | "&&" | "??";
+  left: BabelNodeExpression;
+  right: BabelNodeExpression;
+}
+
+declare class BabelNodeMemberExpression extends BabelNode {
+  type: "MemberExpression";
+  object: BabelNodeExpression;
+  property: any;
+  computed?: boolean;
+  optional?: true | false;
+}
+
+declare class BabelNodeNewExpression extends BabelNode {
+  type: "NewExpression";
+  callee: BabelNodeExpression;
+  arguments: Array<BabelNodeExpression | BabelNodeSpreadElement | BabelNodeJSXNamespacedName>;
+  optional?: true | false;
+  typeParameters?: BabelNodeTypeParameterInstantiation | BabelNodeTSTypeParameterInstantiation;
+}
+
+declare class BabelNodeProgram extends BabelNode {
+  type: "Program";
+  body: Array<BabelNodeStatement>;
+  directives?: Array<BabelNodeDirective>;
+  sourceType?: "script" | "module";
+  sourceFile?: string;
+}
+
+declare class BabelNodeObjectExpression extends BabelNode {
+  type: "ObjectExpression";
+  properties: Array<BabelNodeObjectMethod | BabelNodeObjectProperty | BabelNodeSpreadElement>;
+}
+
+declare class BabelNodeObjectMethod extends BabelNode {
+  type: "ObjectMethod";
+  kind?: "method" | "get" | "set";
+  key: any;
+  params: Array<BabelNodeLVal>;
+  body: BabelNodeBlockStatement;
+  computed?: boolean;
+  async?: boolean;
+  decorators?: Array<BabelNodeDecorator>;
+  generator?: boolean;
+  returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
+  typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
+}
+
+declare class BabelNodeObjectProperty extends BabelNode {
+  type: "ObjectProperty";
+  key: any;
+  value: BabelNodeExpression | BabelNodePatternLike;
+  computed?: boolean;
+  shorthand?: boolean;
+  decorators?: Array<BabelNodeDecorator>;
+}
+
+declare class BabelNodeRestElement extends BabelNode {
+  type: "RestElement";
+  argument: BabelNodeLVal;
+  decorators?: Array<BabelNodeDecorator>;
+  typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
+}
+
+declare class BabelNodeReturnStatement extends BabelNode {
+  type: "ReturnStatement";
+  argument?: BabelNodeExpression;
+}
+
+declare class BabelNodeSequenceExpression extends BabelNode {
+  type: "SequenceExpression";
+  expressions: Array<BabelNodeExpression>;
+}
+
+declare class BabelNodeSwitchCase extends BabelNode {
+  type: "SwitchCase";
+  test?: BabelNodeExpression;
+  consequent: Array<BabelNodeStatement>;
+}
+
+declare class BabelNodeSwitchStatement extends BabelNode {
+  type: "SwitchStatement";
+  discriminant: BabelNodeExpression;
+  cases: Array<BabelNodeSwitchCase>;
+}
+
+declare class BabelNodeThisExpression extends BabelNode {
+  type: "ThisExpression";
+}
+
+declare class BabelNodeThrowStatement extends BabelNode {
+  type: "ThrowStatement";
+  argument: BabelNodeExpression;
+}
+
+declare class BabelNodeTryStatement extends BabelNode {
+  type: "TryStatement";
+  block: BabelNodeBlockStatement;
+  handler?: BabelNodeCatchClause;
+  finalizer?: BabelNodeBlockStatement;
+}
+
+declare class BabelNodeUnaryExpression extends BabelNode {
+  type: "UnaryExpression";
+  operator: "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof";
+  argument: BabelNodeExpression;
+  prefix?: boolean;
+}
+
+declare class BabelNodeUpdateExpression extends BabelNode {
+  type: "UpdateExpression";
+  operator: "++" | "--";
+  argument: BabelNodeExpression;
+  prefix?: boolean;
+}
+
+declare class BabelNodeVariableDeclaration extends BabelNode {
+  type: "VariableDeclaration";
+  kind: "var" | "let" | "const";
+  declarations: Array<BabelNodeVariableDeclarator>;
+  declare?: boolean;
+}
+
+declare class BabelNodeVariableDeclarator extends BabelNode {
+  type: "VariableDeclarator";
+  id: BabelNodeLVal;
+  init?: BabelNodeExpression;
+  definite?: boolean;
+}
+
+declare class BabelNodeWhileStatement extends BabelNode {
+  type: "WhileStatement";
+  test: BabelNodeExpression;
+  body: BabelNodeBlockStatement | BabelNodeStatement;
+}
+
+declare class BabelNodeWithStatement extends BabelNode {
+  type: "WithStatement";
+  object: BabelNodeExpression;
+  body: BabelNodeBlockStatement | BabelNodeStatement;
+}
+
+declare class BabelNodeAssignmentPattern extends BabelNode {
+  type: "AssignmentPattern";
+  left: BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeArrayPattern;
+  right: BabelNodeExpression;
+  decorators?: Array<BabelNodeDecorator>;
+  typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
+}
+
+declare class BabelNodeArrayPattern extends BabelNode {
+  type: "ArrayPattern";
+  elements: Array<BabelNodePatternLike>;
+  decorators?: Array<BabelNodeDecorator>;
+  typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
+}
+
+declare class BabelNodeArrowFunctionExpression extends BabelNode {
+  type: "ArrowFunctionExpression";
+  params: Array<BabelNodeLVal>;
+  body: BabelNodeBlockStatement | BabelNodeExpression;
+  async?: boolean;
+  expression?: boolean;
+  generator?: boolean;
+  returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
+  typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
+}
+
+declare class BabelNodeClassBody extends BabelNode {
+  type: "ClassBody";
+  body: Array<BabelNodeClassMethod | BabelNodeClassProperty | BabelNodeClassPrivateProperty | BabelNodeTSDeclareMethod | BabelNodeTSIndexSignature>;
+}
+
+declare class BabelNodeClassDeclaration extends BabelNode {
+  type: "ClassDeclaration";
+  id?: BabelNodeIdentifier;
+  superClass?: BabelNodeExpression;
+  body: BabelNodeClassBody;
+  decorators?: Array<BabelNodeDecorator>;
+  abstract?: boolean;
+  declare?: boolean;
+  mixins?: any;
+  superTypeParameters?: BabelNodeTypeParameterInstantiation | BabelNodeTSTypeParameterInstantiation;
+  typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
+}
+
+declare class BabelNodeClassExpression extends BabelNode {
+  type: "ClassExpression";
+  id?: BabelNodeIdentifier;
+  superClass?: BabelNodeExpression;
+  body: BabelNodeClassBody;
+  decorators?: Array<BabelNodeDecorator>;
+  mixins?: any;
+  superTypeParameters?: BabelNodeTypeParameterInstantiation | BabelNodeTSTypeParameterInstantiation;
+  typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
+}
+
+declare class BabelNodeExportAllDeclaration extends BabelNode {
+  type: "ExportAllDeclaration";
+  source: BabelNodeStringLiteral;
+}
+
+declare class BabelNodeExportDefaultDeclaration extends BabelNode {
+  type: "ExportDefaultDeclaration";
+  declaration: BabelNodeFunctionDeclaration | BabelNodeTSDeclareFunction | BabelNodeClassDeclaration | BabelNodeExpression;
+}
+
+declare class BabelNodeExportNamedDeclaration extends BabelNode {
+  type: "ExportNamedDeclaration";
+  declaration?: BabelNodeDeclaration;
+  specifiers: Array<BabelNodeExportSpecifier | BabelNodeExportDefaultSpecifier | BabelNodeExportNamespaceSpecifier>;
+  source?: BabelNodeStringLiteral;
+}
+
+declare class BabelNodeExportSpecifier extends BabelNode {
+  type: "ExportSpecifier";
+  local: BabelNodeIdentifier;
+  exported: BabelNodeIdentifier;
+}
+
+declare class BabelNodeForOfStatement extends BabelNode {
+  type: "ForOfStatement";
+  left: BabelNodeVariableDeclaration | BabelNodeLVal;
+  right: BabelNodeExpression;
+  body: BabelNodeStatement;
+}
+
+declare class BabelNodeImportDeclaration extends BabelNode {
+  type: "ImportDeclaration";
+  specifiers: Array<BabelNodeImportSpecifier | BabelNodeImportDefaultSpecifier | BabelNodeImportNamespaceSpecifier>;
+  source: BabelNodeStringLiteral;
+}
+
+declare class BabelNodeImportDefaultSpecifier extends BabelNode {
+  type: "ImportDefaultSpecifier";
+  local: BabelNodeIdentifier;
+}
+
+declare class BabelNodeImportNamespaceSpecifier extends BabelNode {
+  type: "ImportNamespaceSpecifier";
+  local: BabelNodeIdentifier;
+}
+
+declare class BabelNodeImportSpecifier extends BabelNode {
+  type: "ImportSpecifier";
+  local: BabelNodeIdentifier;
+  imported: BabelNodeIdentifier;
+  importKind?: null | "type" | "typeof";
+}
+
+declare class BabelNodeMetaProperty extends BabelNode {
+  type: "MetaProperty";
+  meta: BabelNodeIdentifier;
+  property: BabelNodeIdentifier;
+}
+
+declare class BabelNodeClassMethod extends BabelNode {
+  type: "ClassMethod";
+  kind?: "get" | "set" | "method" | "constructor";
+  key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeExpression;
+  params: Array<BabelNodeLVal>;
+  body: BabelNodeBlockStatement;
+  computed?: boolean;
+  abstract?: boolean;
+  access?: "public" | "private" | "protected";
+  accessibility?: "public" | "private" | "protected";
+  async?: boolean;
+  decorators?: Array<BabelNodeDecorator>;
+  generator?: boolean;
+  optional?: boolean;
+  returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
+  typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
+}
+
+declare class BabelNodeObjectPattern extends BabelNode {
+  type: "ObjectPattern";
+  properties: Array<BabelNodeRestElement | BabelNodeObjectProperty>;
+  decorators?: Array<BabelNodeDecorator>;
+  typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
+}
+
+declare class BabelNodeSpreadElement extends BabelNode {
+  type: "SpreadElement";
+  argument: BabelNodeExpression;
+}
+
+declare class BabelNodeSuper extends BabelNode {
+  type: "Super";
+}
+
+declare class BabelNodeTaggedTemplateExpression extends BabelNode {
+  type: "TaggedTemplateExpression";
+  tag: BabelNodeExpression;
+  quasi: BabelNodeTemplateLiteral;
+}
+
+declare class BabelNodeTemplateElement extends BabelNode {
+  type: "TemplateElement";
+  value: any;
+  tail?: boolean;
+}
+
+declare class BabelNodeTemplateLiteral extends BabelNode {
+  type: "TemplateLiteral";
+  quasis: Array<BabelNodeTemplateElement>;
+  expressions: Array<BabelNodeExpression>;
+}
+
+declare class BabelNodeYieldExpression extends BabelNode {
+  type: "YieldExpression";
+  argument?: BabelNodeExpression;
+  delegate?: boolean;
+}
+
+declare class BabelNodeAnyTypeAnnotation extends BabelNode {
+  type: "AnyTypeAnnotation";
+}
+
+declare class BabelNodeArrayTypeAnnotation extends BabelNode {
+  type: "ArrayTypeAnnotation";
+  elementType: BabelNodeFlowType;
+}
+
+declare class BabelNodeBooleanTypeAnnotation extends BabelNode {
+  type: "BooleanTypeAnnotation";
+}
+
+declare class BabelNodeBooleanLiteralTypeAnnotation extends BabelNode {
+  type: "BooleanLiteralTypeAnnotation";
+  value: boolean;
+}
+
+declare class BabelNodeNullLiteralTypeAnnotation extends BabelNode {
+  type: "NullLiteralTypeAnnotation";
+}
+
+declare class BabelNodeClassImplements extends BabelNode {
+  type: "ClassImplements";
+  id: BabelNodeIdentifier;
+  typeParameters?: BabelNodeTypeParameterInstantiation;
+}
+
+declare class BabelNodeDeclareClass extends BabelNode {
+  type: "DeclareClass";
+  id: BabelNodeIdentifier;
+  typeParameters?: BabelNodeTypeParameterInstantiation;
+  body: BabelNodeObjectTypeAnnotation;
+  mixins?: Array<BabelNodeInterfaceExtends>;
+}
+
+declare class BabelNodeDeclareFunction extends BabelNode {
+  type: "DeclareFunction";
+  id: BabelNodeIdentifier;
+  predicate?: BabelNodeDeclaredPredicate;
+}
+
+declare class BabelNodeDeclareInterface extends BabelNode {
+  type: "DeclareInterface";
+  id: BabelNodeIdentifier;
+  typeParameters?: BabelNodeTypeParameterDeclaration;
+  body: BabelNodeObjectTypeAnnotation;
+  mixins?: Array<BabelNodeInterfaceExtends>;
+}
+
+declare class BabelNodeDeclareModule extends BabelNode {
+  type: "DeclareModule";
+  id: BabelNodeIdentifier | BabelNodeStringLiteral;
+  body: BabelNodeBlockStatement;
+  kind?: "CommonJS" | "ES";
+}
+
+declare class BabelNodeDeclareModuleExports extends BabelNode {
+  type: "DeclareModuleExports";
+  typeAnnotation: BabelNodeTypeAnnotation;
+}
+
+declare class BabelNodeDeclareTypeAlias extends BabelNode {
+  type: "DeclareTypeAlias";
+  id: BabelNodeIdentifier;
+  typeParameters?: BabelNodeTypeParameterDeclaration;
+  right: BabelNodeFlowType;
+}
+
+declare class BabelNodeDeclareOpaqueType extends BabelNode {
+  type: "DeclareOpaqueType";
+  id: BabelNodeIdentifier;
+  typeParameters?: BabelNodeTypeParameterDeclaration;
+  supertype?: BabelNodeFlowType;
+}
+
+declare class BabelNodeDeclareVariable extends BabelNode {
+  type: "DeclareVariable";
+  id: BabelNodeIdentifier;
+}
+
+declare class BabelNodeDeclareExportDeclaration extends BabelNode {
+  type: "DeclareExportDeclaration";
+  declaration?: BabelNodeFlow;
+  specifiers?: Array<BabelNodeExportSpecifier | BabelNodeExportNamespaceSpecifier>;
+  source?: BabelNodeStringLiteral;
+}
+
+declare class BabelNodeDeclareExportAllDeclaration extends BabelNode {
+  type: "DeclareExportAllDeclaration";
+  source: BabelNodeStringLiteral;
+  exportKind?: ["type","value"];
+}
+
+declare class BabelNodeDeclaredPredicate extends BabelNode {
+  type: "DeclaredPredicate";
+  value: BabelNodeFlow;
+}
+
+declare class BabelNodeExistsTypeAnnotation extends BabelNode {
+  type: "ExistsTypeAnnotation";
+}
+
+declare class BabelNodeFunctionTypeAnnotation extends BabelNode {
+  type: "FunctionTypeAnnotation";
+  typeParameters?: BabelNodeTypeParameterDeclaration;
+  params: Array<BabelNodeFunctionTypeParam>;
+  rest?: BabelNodeFunctionTypeParam;
+  returnType: BabelNodeFlowType;
+}
+
+declare class BabelNodeFunctionTypeParam extends BabelNode {
+  type: "FunctionTypeParam";
+  name?: BabelNodeIdentifier;
+  typeAnnotation: BabelNodeFlowType;
+  optional?: boolean;
+}
+
+declare class BabelNodeGenericTypeAnnotation extends BabelNode {
+  type: "GenericTypeAnnotation";
+  id: BabelNodeIdentifier;
+  typeParameters?: BabelNodeTypeParameterInstantiation;
+}
+
+declare class BabelNodeInferredPredicate extends BabelNode {
+  type: "InferredPredicate";
+}
+
+declare class BabelNodeInterfaceExtends extends BabelNode {
+  type: "InterfaceExtends";
+  id: BabelNodeIdentifier;
+  typeParameters?: BabelNodeTypeParameterInstantiation;
+}
+
+declare class BabelNodeInterfaceDeclaration extends BabelNode {
+  type: "InterfaceDeclaration";
+  id: BabelNodeIdentifier;
+  typeParameters?: BabelNodeTypeParameterDeclaration;
+  body: BabelNodeObjectTypeAnnotation;
+  mixins?: Array<BabelNodeInterfaceExtends>;
+}
+
+declare class BabelNodeIntersectionTypeAnnotation extends BabelNode {
+  type: "IntersectionTypeAnnotation";
+  types: Array<BabelNodeFlowType>;
+}
+
+declare class BabelNodeMixedTypeAnnotation extends BabelNode {
+  type: "MixedTypeAnnotation";
+}
+
+declare class BabelNodeEmptyTypeAnnotation extends BabelNode {
+  type: "EmptyTypeAnnotation";
+}
+
+declare class BabelNodeNullableTypeAnnotation extends BabelNode {
+  type: "NullableTypeAnnotation";
+  typeAnnotation: BabelNodeFlowType;
+}
+
+declare class BabelNodeNumberLiteralTypeAnnotation extends BabelNode {
+  type: "NumberLiteralTypeAnnotation";
+  value: number;
+}
+
+declare class BabelNodeNumberTypeAnnotation extends BabelNode {
+  type: "NumberTypeAnnotation";
+}
+
+declare class BabelNodeObjectTypeAnnotation extends BabelNode {
+  type: "ObjectTypeAnnotation";
+  properties: Array<BabelNodeObjectTypeProperty | BabelNodeObjectTypeSpreadProperty>;
+  indexers?: Array<BabelNodeObjectTypeIndexer>;
+  callProperties?: Array<BabelNodeObjectTypeCallProperty>;
+  exact?: boolean;
+}
+
+declare class BabelNodeObjectTypeCallProperty extends BabelNode {
+  type: "ObjectTypeCallProperty";
+  value: BabelNodeFlowType;
+}
+
+declare class BabelNodeObjectTypeIndexer extends BabelNode {
+  type: "ObjectTypeIndexer";
+  id?: BabelNodeIdentifier;
+  key: BabelNodeFlowType;
+  value: BabelNodeFlowType;
+  variance?: BabelNodeVariance;
+}
+
+declare class BabelNodeObjectTypeProperty extends BabelNode {
+  type: "ObjectTypeProperty";
+  key: BabelNodeIdentifier | BabelNodeStringLiteral;
+  value: BabelNodeFlowType;
+  variance?: BabelNodeVariance;
+  kind?: "init" | "get" | "set";
+  optional?: boolean;
+}
+
+declare class BabelNodeObjectTypeSpreadProperty extends BabelNode {
+  type: "ObjectTypeSpreadProperty";
+  argument: BabelNodeFlowType;
+}
+
+declare class BabelNodeOpaqueType extends BabelNode {
+  type: "OpaqueType";
+  id: BabelNodeIdentifier;
+  typeParameters?: BabelNodeTypeParameterDeclaration;
+  supertype?: BabelNodeFlowType;
+  impltype: BabelNodeFlowType;
+}
+
+declare class BabelNodeQualifiedTypeIdentifier extends BabelNode {
+  type: "QualifiedTypeIdentifier";
+  id: BabelNodeIdentifier;
+  qualification: BabelNodeIdentifier | BabelNodeQualifiedTypeIdentifier;
+}
+
+declare class BabelNodeStringLiteralTypeAnnotation extends BabelNode {
+  type: "StringLiteralTypeAnnotation";
+  value: string;
+}
+
+declare class BabelNodeStringTypeAnnotation extends BabelNode {
+  type: "StringTypeAnnotation";
+}
+
+declare class BabelNodeThisTypeAnnotation extends BabelNode {
+  type: "ThisTypeAnnotation";
+}
+
+declare class BabelNodeTupleTypeAnnotation extends BabelNode {
+  type: "TupleTypeAnnotation";
+  types: Array<BabelNodeFlowType>;
+}
+
+declare class BabelNodeTypeofTypeAnnotation extends BabelNode {
+  type: "TypeofTypeAnnotation";
+  argument: BabelNodeFlowType;
+}
+
+declare class BabelNodeTypeAlias extends BabelNode {
+  type: "TypeAlias";
+  id: BabelNodeIdentifier;
+  typeParameters?: BabelNodeTypeParameterDeclaration;
+  right: BabelNodeFlowType;
+}
+
+declare class BabelNodeTypeAnnotation extends BabelNode {
+  type: "TypeAnnotation";
+  typeAnnotation: BabelNodeFlowType;
+}
+
+declare class BabelNodeTypeCastExpression extends BabelNode {
+  type: "TypeCastExpression";
+  expression: BabelNodeExpression;
+  typeAnnotation: BabelNodeTypeAnnotation;
+}
+
+declare class BabelNodeTypeParameter extends BabelNode {
+  type: "TypeParameter";
+  bound?: BabelNodeTypeAnnotation;
+  variance?: BabelNodeVariance;
+  name?: string;
+}
+
+declare class BabelNodeTypeParameterDeclaration extends BabelNode {
+  type: "TypeParameterDeclaration";
+  params: Array<BabelNodeTypeParameter>;
+}
+
+declare class BabelNodeTypeParameterInstantiation extends BabelNode {
+  type: "TypeParameterInstantiation";
+  params: Array<BabelNodeFlowType>;
+}
+
+declare class BabelNodeUnionTypeAnnotation extends BabelNode {
+  type: "UnionTypeAnnotation";
+  types: Array<BabelNodeFlowType>;
+}
+
+declare class BabelNodeVariance extends BabelNode {
+  type: "Variance";
+  kind: "minus" | "plus";
+}
+
+declare class BabelNodeVoidTypeAnnotation extends BabelNode {
+  type: "VoidTypeAnnotation";
+}
+
+declare class BabelNodeJSXAttribute extends BabelNode {
+  type: "JSXAttribute";
+  name: BabelNodeJSXIdentifier | BabelNodeJSXNamespacedName;
+  value?: BabelNodeJSXElement | BabelNodeJSXFragment | BabelNodeStringLiteral | BabelNodeJSXExpressionContainer;
+}
+
+declare class BabelNodeJSXClosingElement extends BabelNode {
+  type: "JSXClosingElement";
+  name: BabelNodeJSXIdentifier | BabelNodeJSXMemberExpression;
+}
+
+declare class BabelNodeJSXElement extends BabelNode {
+  type: "JSXElement";
+  openingElement: BabelNodeJSXOpeningElement;
+  closingElement?: BabelNodeJSXClosingElement;
+  children: Array<BabelNodeJSXText | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXElement | BabelNodeJSXFragment>;
+  selfClosing: any;
+}
+
+declare class BabelNodeJSXEmptyExpression extends BabelNode {
+  type: "JSXEmptyExpression";
+}
+
+declare class BabelNodeJSXExpressionContainer extends BabelNode {
+  type: "JSXExpressionContainer";
+  expression: BabelNodeExpression;
+}
+
+declare class BabelNodeJSXSpreadChild extends BabelNode {
+  type: "JSXSpreadChild";
+  expression: BabelNodeExpression;
+}
+
+declare class BabelNodeJSXIdentifier extends BabelNode {
+  type: "JSXIdentifier";
+  name: string;
+}
+
+declare class BabelNodeJSXMemberExpression extends BabelNode {
+  type: "JSXMemberExpression";
+  object: BabelNodeJSXMemberExpression | BabelNodeJSXIdentifier;
+  property: BabelNodeJSXIdentifier;
+}
+
+declare class BabelNodeJSXNamespacedName extends BabelNode {
+  type: "JSXNamespacedName";
+  namespace: BabelNodeJSXIdentifier;
+  name: BabelNodeJSXIdentifier;
+}
+
+declare class BabelNodeJSXOpeningElement extends BabelNode {
+  type: "JSXOpeningElement";
+  name: BabelNodeJSXIdentifier | BabelNodeJSXMemberExpression;
+  attributes: Array<BabelNodeJSXAttribute | BabelNodeJSXSpreadAttribute>;
+  selfClosing?: boolean;
+}
+
+declare class BabelNodeJSXSpreadAttribute extends BabelNode {
+  type: "JSXSpreadAttribute";
+  argument: BabelNodeExpression;
+}
+
+declare class BabelNodeJSXText extends BabelNode {
+  type: "JSXText";
+  value: string;
+}
+
+declare class BabelNodeJSXFragment extends BabelNode {
+  type: "JSXFragment";
+  openingFragment: BabelNodeJSXOpeningFragment;
+  closingFragment: BabelNodeJSXClosingFragment;
+  children: Array<BabelNodeJSXText | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXElement | BabelNodeJSXFragment>;
+}
+
+declare class BabelNodeJSXOpeningFragment extends BabelNode {
+  type: "JSXOpeningFragment";
+}
+
+declare class BabelNodeJSXClosingFragment extends BabelNode {
+  type: "JSXClosingFragment";
+}
+
+declare class BabelNodeNoop extends BabelNode {
+  type: "Noop";
+}
+
+declare class BabelNodeParenthesizedExpression extends BabelNode {
+  type: "ParenthesizedExpression";
+  expression: BabelNodeExpression;
+}
+
+declare class BabelNodeAwaitExpression extends BabelNode {
+  type: "AwaitExpression";
+  argument: BabelNodeExpression;
+}
+
+declare class BabelNodeBindExpression extends BabelNode {
+  type: "BindExpression";
+  object: any;
+  callee: any;
+}
+
+declare class BabelNodeClassProperty extends BabelNode {
+  type: "ClassProperty";
+  key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeExpression;
+  value?: BabelNodeExpression;
+  typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
+  decorators?: Array<BabelNodeDecorator>;
+  computed?: boolean;
+  abstract?: boolean;
+  accessibility?: "public" | "private" | "protected";
+  definite?: boolean;
+  optional?: boolean;
+  readonly?: boolean;
+}
+
+declare class BabelNodeOptionalMemberExpression extends BabelNode {
+  type: "OptionalMemberExpression";
+  object: BabelNodeExpression;
+  property: any;
+  computed?: boolean;
+  optional: boolean;
+}
+
+declare class BabelNodeOptionalCallExpression extends BabelNode {
+  type: "OptionalCallExpression";
+  callee: BabelNodeExpression;
+  arguments: Array<BabelNodeExpression | BabelNodeSpreadElement | BabelNodeJSXNamespacedName>;
+  optional: boolean;
+  typeParameters?: BabelNodeTypeParameterInstantiation | BabelNodeTSTypeParameterInstantiation;
+}
+
+declare class BabelNodeClassPrivateProperty extends BabelNode {
+  type: "ClassPrivateProperty";
+  key: BabelNodePrivateName;
+  value?: BabelNodeExpression;
+}
+
+declare class BabelNodeImport extends BabelNode {
+  type: "Import";
+}
+
+declare class BabelNodeDecorator extends BabelNode {
+  type: "Decorator";
+  callee: BabelNodeExpression;
+  arguments?: Array<BabelNodeExpression | BabelNodeSpreadElement>;
+}
+
+declare class BabelNodeDoExpression extends BabelNode {
+  type: "DoExpression";
+  body: BabelNodeBlockStatement;
+}
+
+declare class BabelNodeExportDefaultSpecifier extends BabelNode {
+  type: "ExportDefaultSpecifier";
+  exported: BabelNodeIdentifier;
+}
+
+declare class BabelNodeExportNamespaceSpecifier extends BabelNode {
+  type: "ExportNamespaceSpecifier";
+  exported: BabelNodeIdentifier;
+}
+
+declare class BabelNodePrivateName extends BabelNode {
+  type: "PrivateName";
+  id: BabelNodeIdentifier;
+}
+
+declare class BabelNodeTSParameterProperty extends BabelNode {
+  type: "TSParameterProperty";
+  parameter: BabelNodeIdentifier | BabelNodeAssignmentPattern;
+  accessibility?: "public" | "private" | "protected";
+  readonly?: boolean;
+}
+
+declare class BabelNodeTSDeclareFunction extends BabelNode {
+  type: "TSDeclareFunction";
+  id?: BabelNodeIdentifier;
+  typeParameters?: BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
+  params: Array<BabelNodeLVal>;
+  returnType?: BabelNodeTSTypeAnnotation | BabelNodeNoop;
+  async?: boolean;
+  declare?: boolean;
+  generator?: boolean;
+}
+
+declare class BabelNodeTSDeclareMethod extends BabelNode {
+  type: "TSDeclareMethod";
+  decorators?: Array<BabelNodeDecorator>;
+  key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeExpression;
+  typeParameters?: BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
+  params: Array<BabelNodeLVal>;
+  returnType?: BabelNodeTSTypeAnnotation | BabelNodeNoop;
+  abstract?: boolean;
+  access?: "public" | "private" | "protected";
+  accessibility?: "public" | "private" | "protected";
+  async?: boolean;
+  computed?: boolean;
+  generator?: boolean;
+  kind?: "get" | "set" | "method" | "constructor";
+  optional?: boolean;
+}
+
+declare class BabelNodeTSQualifiedName extends BabelNode {
+  type: "TSQualifiedName";
+  left: BabelNodeTSEntityName;
+  right: BabelNodeIdentifier;
+}
+
+declare class BabelNodeTSCallSignatureDeclaration extends BabelNode {
+  type: "TSCallSignatureDeclaration";
+  typeParameters?: BabelNodeTSTypeParameterDeclaration;
+  parameters?: Array<BabelNodeIdentifier | BabelNodeRestElement>;
+  typeAnnotation?: BabelNodeTSTypeAnnotation;
+}
+
+declare class BabelNodeTSConstructSignatureDeclaration extends BabelNode {
+  type: "TSConstructSignatureDeclaration";
+  typeParameters?: BabelNodeTSTypeParameterDeclaration;
+  parameters?: Array<BabelNodeIdentifier | BabelNodeRestElement>;
+  typeAnnotation?: BabelNodeTSTypeAnnotation;
+}
+
+declare class BabelNodeTSPropertySignature extends BabelNode {
+  type: "TSPropertySignature";
+  key: BabelNodeExpression;
+  typeAnnotation?: BabelNodeTSTypeAnnotation;
+  initializer?: BabelNodeExpression;
+  computed?: boolean;
+  optional?: boolean;
+  readonly?: boolean;
+}
+
+declare class BabelNodeTSMethodSignature extends BabelNode {
+  type: "TSMethodSignature";
+  key: BabelNodeExpression;
+  typeParameters?: BabelNodeTSTypeParameterDeclaration;
+  parameters?: Array<BabelNodeIdentifier | BabelNodeRestElement>;
+  typeAnnotation?: BabelNodeTSTypeAnnotation;
+  computed?: boolean;
+  optional?: boolean;
+}
+
+declare class BabelNodeTSIndexSignature extends BabelNode {
+  type: "TSIndexSignature";
+  parameters: Array<BabelNodeIdentifier>;
+  typeAnnotation?: BabelNodeTSTypeAnnotation;
+  readonly?: boolean;
+}
+
+declare class BabelNodeTSAnyKeyword extends BabelNode {
+  type: "TSAnyKeyword";
+}
+
+declare class BabelNodeTSNumberKeyword extends BabelNode {
+  type: "TSNumberKeyword";
+}
+
+declare class BabelNodeTSObjectKeyword extends BabelNode {
+  type: "TSObjectKeyword";
+}
+
+declare class BabelNodeTSBooleanKeyword extends BabelNode {
+  type: "TSBooleanKeyword";
+}
+
+declare class BabelNodeTSStringKeyword extends BabelNode {
+  type: "TSStringKeyword";
+}
+
+declare class BabelNodeTSSymbolKeyword extends BabelNode {
+  type: "TSSymbolKeyword";
+}
+
+declare class BabelNodeTSVoidKeyword extends BabelNode {
+  type: "TSVoidKeyword";
+}
+
+declare class BabelNodeTSUndefinedKeyword extends BabelNode {
+  type: "TSUndefinedKeyword";
+}
+
+declare class BabelNodeTSNullKeyword extends BabelNode {
+  type: "TSNullKeyword";
+}
+
+declare class BabelNodeTSNeverKeyword extends BabelNode {
+  type: "TSNeverKeyword";
+}
+
+declare class BabelNodeTSThisType extends BabelNode {
+  type: "TSThisType";
+}
+
+declare class BabelNodeTSFunctionType extends BabelNode {
+  type: "TSFunctionType";
+  typeParameters?: BabelNodeTSTypeParameterDeclaration;
+  typeAnnotation?: BabelNodeTSTypeAnnotation;
+  parameters?: Array<BabelNodeIdentifier | BabelNodeRestElement>;
+}
+
+declare class BabelNodeTSConstructorType extends BabelNode {
+  type: "TSConstructorType";
+  typeParameters?: BabelNodeTSTypeParameterDeclaration;
+  typeAnnotation?: BabelNodeTSTypeAnnotation;
+  parameters?: Array<BabelNodeIdentifier | BabelNodeRestElement>;
+}
+
+declare class BabelNodeTSTypeReference extends BabelNode {
+  type: "TSTypeReference";
+  typeName: BabelNodeTSEntityName;
+  typeParameters?: BabelNodeTSTypeParameterInstantiation;
+}
+
+declare class BabelNodeTSTypePredicate extends BabelNode {
+  type: "TSTypePredicate";
+  parameterName: BabelNodeIdentifier | BabelNodeTSThisType;
+  typeAnnotation: BabelNodeTSTypeAnnotation;
+}
+
+declare class BabelNodeTSTypeQuery extends BabelNode {
+  type: "TSTypeQuery";
+  exprName: BabelNodeTSEntityName;
+}
+
+declare class BabelNodeTSTypeLiteral extends BabelNode {
+  type: "TSTypeLiteral";
+  members: Array<BabelNodeTSTypeElement>;
+}
+
+declare class BabelNodeTSArrayType extends BabelNode {
+  type: "TSArrayType";
+  elementType: BabelNodeTSType;
+}
+
+declare class BabelNodeTSTupleType extends BabelNode {
+  type: "TSTupleType";
+  elementTypes: Array<BabelNodeTSType>;
+}
+
+declare class BabelNodeTSUnionType extends BabelNode {
+  type: "TSUnionType";
+  types: Array<BabelNodeTSType>;
+}
+
+declare class BabelNodeTSIntersectionType extends BabelNode {
+  type: "TSIntersectionType";
+  types: Array<BabelNodeTSType>;
+}
+
+declare class BabelNodeTSConditionalType extends BabelNode {
+  type: "TSConditionalType";
+  checkType: BabelNodeTSType;
+  extendsType: BabelNodeTSType;
+  trueType: BabelNodeTSType;
+  falseType: BabelNodeTSType;
+}
+
+declare class BabelNodeTSInferType extends BabelNode {
+  type: "TSInferType";
+  typeParameter: BabelNodeTSType;
+}
+
+declare class BabelNodeTSParenthesizedType extends BabelNode {
+  type: "TSParenthesizedType";
+  typeAnnotation: BabelNodeTSType;
+}
+
+declare class BabelNodeTSTypeOperator extends BabelNode {
+  type: "TSTypeOperator";
+  typeAnnotation: BabelNodeTSType;
+  operator?: string;
+}
+
+declare class BabelNodeTSIndexedAccessType extends BabelNode {
+  type: "TSIndexedAccessType";
+  objectType: BabelNodeTSType;
+  indexType: BabelNodeTSType;
+}
+
+declare class BabelNodeTSMappedType extends BabelNode {
+  type: "TSMappedType";
+  typeParameter: BabelNodeTSTypeParameter;
+  typeAnnotation?: BabelNodeTSType;
+  optional?: boolean;
+  readonly?: boolean;
+}
+
+declare class BabelNodeTSLiteralType extends BabelNode {
+  type: "TSLiteralType";
+  literal: BabelNodeNumericLiteral | BabelNodeStringLiteral | BabelNodeBooleanLiteral;
+}
+
+declare class BabelNodeTSExpressionWithTypeArguments extends BabelNode {
+  type: "TSExpressionWithTypeArguments";
+  expression: BabelNodeTSEntityName;
+  typeParameters?: BabelNodeTSTypeParameterInstantiation;
+}
+
+declare class BabelNodeTSInterfaceDeclaration extends BabelNode {
+  type: "TSInterfaceDeclaration";
+  id: BabelNodeIdentifier;
+  typeParameters?: BabelNodeTSTypeParameterDeclaration;
+  body: BabelNodeTSInterfaceBody;
+  declare?: boolean;
+}
+
+declare class BabelNodeTSInterfaceBody extends BabelNode {
+  type: "TSInterfaceBody";
+  body: Array<BabelNodeTSTypeElement>;
+}
+
+declare class BabelNodeTSTypeAliasDeclaration extends BabelNode {
+  type: "TSTypeAliasDeclaration";
+  id: BabelNodeIdentifier;
+  typeParameters?: BabelNodeTSTypeParameterDeclaration;
+  typeAnnotation: BabelNodeTSType;
+  declare?: boolean;
+}
+
+declare class BabelNodeTSAsExpression extends BabelNode {
+  type: "TSAsExpression";
+  expression: BabelNodeExpression;
+  typeAnnotation: BabelNodeTSType;
+}
+
+declare class BabelNodeTSTypeAssertion extends BabelNode {
+  type: "TSTypeAssertion";
+  typeAnnotation: BabelNodeTSType;
+  expression: BabelNodeExpression;
+}
+
+declare class BabelNodeTSEnumDeclaration extends BabelNode {
+  type: "TSEnumDeclaration";
+  id: BabelNodeIdentifier;
+  members: Array<BabelNodeTSEnumMember>;
+  declare?: boolean;
+  initializer?: BabelNodeExpression;
+}
+
+declare class BabelNodeTSEnumMember extends BabelNode {
+  type: "TSEnumMember";
+  id: BabelNodeIdentifier | BabelNodeStringLiteral;
+  initializer?: BabelNodeExpression;
+}
+
+declare class BabelNodeTSModuleDeclaration extends BabelNode {
+  type: "TSModuleDeclaration";
+  id: BabelNodeIdentifier | BabelNodeStringLiteral;
+  body: BabelNodeTSModuleBlock | BabelNodeTSModuleDeclaration;
+  declare?: boolean;
+  global?: boolean;
+}
+
+declare class BabelNodeTSModuleBlock extends BabelNode {
+  type: "TSModuleBlock";
+  body: Array<BabelNodeStatement>;
+}
+
+declare class BabelNodeTSImportEqualsDeclaration extends BabelNode {
+  type: "TSImportEqualsDeclaration";
+  id: BabelNodeIdentifier;
+  moduleReference: BabelNodeTSEntityName | BabelNodeTSExternalModuleReference;
+  isExport?: boolean;
+}
+
+declare class BabelNodeTSExternalModuleReference extends BabelNode {
+  type: "TSExternalModuleReference";
+  expression: BabelNodeStringLiteral;
+}
+
+declare class BabelNodeTSNonNullExpression extends BabelNode {
+  type: "TSNonNullExpression";
+  expression: BabelNodeExpression;
+}
+
+declare class BabelNodeTSExportAssignment extends BabelNode {
+  type: "TSExportAssignment";
+  expression: BabelNodeExpression;
+}
+
+declare class BabelNodeTSNamespaceExportDeclaration extends BabelNode {
+  type: "TSNamespaceExportDeclaration";
+  id: BabelNodeIdentifier;
+}
+
+declare class BabelNodeTSTypeAnnotation extends BabelNode {
+  type: "TSTypeAnnotation";
+  typeAnnotation: BabelNodeTSType;
+}
+
+declare class BabelNodeTSTypeParameterInstantiation extends BabelNode {
+  type: "TSTypeParameterInstantiation";
+  params: Array<BabelNodeTSType>;
+}
+
+declare class BabelNodeTSTypeParameterDeclaration extends BabelNode {
+  type: "TSTypeParameterDeclaration";
+  params: Array<BabelNodeTSTypeParameter>;
+}
+
+declare class BabelNodeTSTypeParameter extends BabelNode {
+  type: "TSTypeParameter";
+  constraint?: BabelNodeTSType;
+  name?: string;
+}
+
+type BabelNodeExpression = BabelNodeArrayExpression | BabelNodeAssignmentExpression | BabelNodeBinaryExpression | BabelNodeCallExpression | BabelNodeConditionalExpression | BabelNodeFunctionExpression | BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeNullLiteral | BabelNodeBooleanLiteral | BabelNodeRegExpLiteral | BabelNodeLogicalExpression | BabelNodeMemberExpression | BabelNodeNewExpression | BabelNodeObjectExpression | BabelNodeSequenceExpression | BabelNodeThisExpression | BabelNodeUnaryExpression | BabelNodeUpdateExpression | BabelNodeArrowFunctionExpression | BabelNodeClassExpression | BabelNodeMetaProperty | BabelNodeSuper | BabelNodeTaggedTemplateExpression | BabelNodeTemplateLiteral | BabelNodeYieldExpression | BabelNodeTypeCastExpression | BabelNodeJSXElement | BabelNodeJSXFragment | BabelNodeParenthesizedExpression | BabelNodeAwaitExpression | BabelNodeBindExpression | BabelNodeOptionalMemberExpression | BabelNodeOptionalCallExpression | BabelNodeImport | BabelNodeDoExpression | BabelNodeTSAsExpression | BabelNodeTSTypeAssertion | BabelNodeTSNonNullExpression;
+type BabelNodeBinary = BabelNodeBinaryExpression | BabelNodeLogicalExpression;
+type BabelNodeScopable = BabelNodeBlockStatement | BabelNodeCatchClause | BabelNodeDoWhileStatement | BabelNodeForInStatement | BabelNodeForStatement | BabelNodeFunctionDeclaration | BabelNodeFunctionExpression | BabelNodeProgram | BabelNodeObjectMethod | BabelNodeSwitchStatement | BabelNodeWhileStatement | BabelNodeArrowFunctionExpression | BabelNodeClassDeclaration | BabelNodeClassExpression | BabelNodeForOfStatement | BabelNodeClassMethod;
+type BabelNodeBlockParent = BabelNodeBlockStatement | BabelNodeCatchClause | BabelNodeDoWhileStatement | BabelNodeForInStatement | BabelNodeForStatement | BabelNodeFunctionDeclaration | BabelNodeFunctionExpression | BabelNodeProgram | BabelNodeObjectMethod | BabelNodeSwitchStatement | BabelNodeWhileStatement | BabelNodeArrowFunctionExpression | BabelNodeForOfStatement | BabelNodeClassMethod;
+type BabelNodeBlock = BabelNodeBlockStatement | BabelNodeProgram;
+type BabelNodeStatement = BabelNodeBlockStatement | BabelNodeBreakStatement | BabelNodeContinueStatement | BabelNodeDebuggerStatement | BabelNodeDoWhileStatement | BabelNodeEmptyStatement | BabelNodeExpressionStatement | BabelNodeForInStatement | BabelNodeForStatement | BabelNodeFunctionDeclaration | BabelNodeIfStatement | BabelNodeLabeledStatement | BabelNodeReturnStatement | BabelNodeSwitchStatement | BabelNodeThrowStatement | BabelNodeTryStatement | BabelNodeVariableDeclaration | BabelNodeWhileStatement | BabelNodeWithStatement | BabelNodeClassDeclaration | BabelNodeExportAllDeclaration | BabelNodeExportDefaultDeclaration | BabelNodeExportNamedDeclaration | BabelNodeForOfStatement | BabelNodeImportDeclaration | BabelNodeDeclareClass | BabelNodeDeclareFunction | BabelNodeDeclareInterface | BabelNodeDeclareModule | BabelNodeDeclareModuleExports | BabelNodeDeclareTypeAlias | BabelNodeDeclareOpaqueType | BabelNodeDeclareVariable | BabelNodeDeclareExportDeclaration | BabelNodeDeclareExportAllDeclaration | BabelNodeInterfaceDeclaration | BabelNodeOpaqueType | BabelNodeTypeAlias | BabelNodeTSDeclareFunction | BabelNodeTSInterfaceDeclaration | BabelNodeTSTypeAliasDeclaration | BabelNodeTSEnumDeclaration | BabelNodeTSModuleDeclaration | BabelNodeTSImportEqualsDeclaration | BabelNodeTSExportAssignment | BabelNodeTSNamespaceExportDeclaration;
+type BabelNodeTerminatorless = BabelNodeBreakStatement | BabelNodeContinueStatement | BabelNodeReturnStatement | BabelNodeThrowStatement | BabelNodeYieldExpression | BabelNodeAwaitExpression;
+type BabelNodeCompletionStatement = BabelNodeBreakStatement | BabelNodeContinueStatement | BabelNodeReturnStatement | BabelNodeThrowStatement;
+type BabelNodeConditional = BabelNodeConditionalExpression | BabelNodeIfStatement;
+type BabelNodeLoop = BabelNodeDoWhileStatement | BabelNodeForInStatement | BabelNodeForStatement | BabelNodeWhileStatement | BabelNodeForOfStatement;
+type BabelNodeWhile = BabelNodeDoWhileStatement | BabelNodeWhileStatement;
+type BabelNodeExpressionWrapper = BabelNodeExpressionStatement | BabelNodeTypeCastExpression | BabelNodeParenthesizedExpression;
+type BabelNodeFor = BabelNodeForInStatement | BabelNodeForStatement | BabelNodeForOfStatement;
+type BabelNodeForXStatement = BabelNodeForInStatement | BabelNodeForOfStatement;
+type BabelNodeFunction = BabelNodeFunctionDeclaration | BabelNodeFunctionExpression | BabelNodeObjectMethod | BabelNodeArrowFunctionExpression | BabelNodeClassMethod;
+type BabelNodeFunctionParent = BabelNodeFunctionDeclaration | BabelNodeFunctionExpression | BabelNodeObjectMethod | BabelNodeArrowFunctionExpression | BabelNodeClassMethod;
+type BabelNodePureish = BabelNodeFunctionDeclaration | BabelNodeFunctionExpression | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeNullLiteral | BabelNodeBooleanLiteral | BabelNodeArrowFunctionExpression | BabelNodeClassDeclaration | BabelNodeClassExpression;
+type BabelNodeDeclaration = BabelNodeFunctionDeclaration | BabelNodeVariableDeclaration | BabelNodeClassDeclaration | BabelNodeExportAllDeclaration | BabelNodeExportDefaultDeclaration | BabelNodeExportNamedDeclaration | BabelNodeImportDeclaration | BabelNodeDeclareClass | BabelNodeDeclareFunction | BabelNodeDeclareInterface | BabelNodeDeclareModule | BabelNodeDeclareModuleExports | BabelNodeDeclareTypeAlias | BabelNodeDeclareOpaqueType | BabelNodeDeclareVariable | BabelNodeDeclareExportDeclaration | BabelNodeDeclareExportAllDeclaration | BabelNodeInterfaceDeclaration | BabelNodeOpaqueType | BabelNodeTypeAlias | BabelNodeTSDeclareFunction | BabelNodeTSInterfaceDeclaration | BabelNodeTSTypeAliasDeclaration | BabelNodeTSEnumDeclaration | BabelNodeTSModuleDeclaration;
+type BabelNodePatternLike = BabelNodeIdentifier | BabelNodeRestElement | BabelNodeAssignmentPattern | BabelNodeArrayPattern | BabelNodeObjectPattern;
+type BabelNodeLVal = BabelNodeIdentifier | BabelNodeMemberExpression | BabelNodeRestElement | BabelNodeAssignmentPattern | BabelNodeArrayPattern | BabelNodeObjectPattern | BabelNodeTSParameterProperty;
+type BabelNodeTSEntityName = BabelNodeIdentifier | BabelNodeTSQualifiedName;
+type BabelNodeLiteral = BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeNullLiteral | BabelNodeBooleanLiteral | BabelNodeRegExpLiteral | BabelNodeTemplateLiteral;
+type BabelNodeImmutable = BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeNullLiteral | BabelNodeBooleanLiteral | BabelNodeJSXAttribute | BabelNodeJSXClosingElement | BabelNodeJSXElement | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXOpeningElement | BabelNodeJSXText | BabelNodeJSXFragment | BabelNodeJSXOpeningFragment | BabelNodeJSXClosingFragment;
+type BabelNodeUserWhitespacable = BabelNodeObjectMethod | BabelNodeObjectProperty | BabelNodeObjectTypeCallProperty | BabelNodeObjectTypeIndexer | BabelNodeObjectTypeProperty | BabelNodeObjectTypeSpreadProperty;
+type BabelNodeMethod = BabelNodeObjectMethod | BabelNodeClassMethod;
+type BabelNodeObjectMember = BabelNodeObjectMethod | BabelNodeObjectProperty;
+type BabelNodeProperty = BabelNodeObjectProperty | BabelNodeClassProperty | BabelNodeClassPrivateProperty;
+type BabelNodeUnaryLike = BabelNodeUnaryExpression | BabelNodeSpreadElement;
+type BabelNodePattern = BabelNodeAssignmentPattern | BabelNodeArrayPattern | BabelNodeObjectPattern;
+type BabelNodeClass = BabelNodeClassDeclaration | BabelNodeClassExpression;
+type BabelNodeModuleDeclaration = BabelNodeExportAllDeclaration | BabelNodeExportDefaultDeclaration | BabelNodeExportNamedDeclaration | BabelNodeImportDeclaration;
+type BabelNodeExportDeclaration = BabelNodeExportAllDeclaration | BabelNodeExportDefaultDeclaration | BabelNodeExportNamedDeclaration;
+type BabelNodeModuleSpecifier = BabelNodeExportSpecifier | BabelNodeImportDefaultSpecifier | BabelNodeImportNamespaceSpecifier | BabelNodeImportSpecifier | BabelNodeExportDefaultSpecifier | BabelNodeExportNamespaceSpecifier;
+type BabelNodeFlow = BabelNodeAnyTypeAnnotation | BabelNodeArrayTypeAnnotation | BabelNodeBooleanTypeAnnotation | BabelNodeBooleanLiteralTypeAnnotation | BabelNodeNullLiteralTypeAnnotation | BabelNodeClassImplements | BabelNodeDeclareClass | BabelNodeDeclareFunction | BabelNodeDeclareInterface | BabelNodeDeclareModule | BabelNodeDeclareModuleExports | BabelNodeDeclareTypeAlias | BabelNodeDeclareOpaqueType | BabelNodeDeclareVariable | BabelNodeDeclareExportDeclaration | BabelNodeDeclareExportAllDeclaration | BabelNodeDeclaredPredicate | BabelNodeExistsTypeAnnotation | BabelNodeFunctionTypeAnnotation | BabelNodeFunctionTypeParam | BabelNodeGenericTypeAnnotation | BabelNodeInferredPredicate | BabelNodeInterfaceExtends | BabelNodeInterfaceDeclaration | BabelNodeIntersectionTypeAnnotation | BabelNodeMixedTypeAnnotation | BabelNodeEmptyTypeAnnotation | BabelNodeNullableTypeAnnotation | BabelNodeNumberLiteralTypeAnnotation | BabelNodeNumberTypeAnnotation | BabelNodeObjectTypeAnnotation | BabelNodeObjectTypeCallProperty | BabelNodeObjectTypeIndexer | BabelNodeObjectTypeProperty | BabelNodeObjectTypeSpreadProperty | BabelNodeOpaqueType | BabelNodeQualifiedTypeIdentifier | BabelNodeStringLiteralTypeAnnotation | BabelNodeStringTypeAnnotation | BabelNodeThisTypeAnnotation | BabelNodeTupleTypeAnnotation | BabelNodeTypeofTypeAnnotation | BabelNodeTypeAlias | BabelNodeTypeAnnotation | BabelNodeTypeCastExpression | BabelNodeTypeParameter | BabelNodeTypeParameterDeclaration | BabelNodeTypeParameterInstantiation | BabelNodeUnionTypeAnnotation | BabelNodeVariance | BabelNodeVoidTypeAnnotation;
+type BabelNodeFlowType = BabelNodeAnyTypeAnnotation | BabelNodeArrayTypeAnnotation | BabelNodeBooleanTypeAnnotation | BabelNodeBooleanLiteralTypeAnnotation | BabelNodeNullLiteralTypeAnnotation | BabelNodeExistsTypeAnnotation | BabelNodeFunctionTypeAnnotation | BabelNodeGenericTypeAnnotation | BabelNodeIntersectionTypeAnnotation | BabelNodeMixedTypeAnnotation | BabelNodeEmptyTypeAnnotation | BabelNodeNullableTypeAnnotation | BabelNodeNumberLiteralTypeAnnotation | BabelNodeNumberTypeAnnotation | BabelNodeObjectTypeAnnotation | BabelNodeStringLiteralTypeAnnotation | BabelNodeStringTypeAnnotation | BabelNodeThisTypeAnnotation | BabelNodeTupleTypeAnnotation | BabelNodeTypeofTypeAnnotation | BabelNodeUnionTypeAnnotation | BabelNodeVoidTypeAnnotation;
+type BabelNodeFlowBaseAnnotation = BabelNodeAnyTypeAnnotation | BabelNodeBooleanTypeAnnotation | BabelNodeNullLiteralTypeAnnotation | BabelNodeMixedTypeAnnotation | BabelNodeEmptyTypeAnnotation | BabelNodeNumberTypeAnnotation | BabelNodeStringTypeAnnotation | BabelNodeThisTypeAnnotation | BabelNodeVoidTypeAnnotation;
+type BabelNodeFlowDeclaration = BabelNodeDeclareClass | BabelNodeDeclareFunction | BabelNodeDeclareInterface | BabelNodeDeclareModule | BabelNodeDeclareModuleExports | BabelNodeDeclareTypeAlias | BabelNodeDeclareOpaqueType | BabelNodeDeclareVariable | BabelNodeDeclareExportDeclaration | BabelNodeDeclareExportAllDeclaration | BabelNodeInterfaceDeclaration | BabelNodeOpaqueType | BabelNodeTypeAlias;
+type BabelNodeFlowPredicate = BabelNodeDeclaredPredicate | BabelNodeInferredPredicate;
+type BabelNodeJSX = BabelNodeJSXAttribute | BabelNodeJSXClosingElement | BabelNodeJSXElement | BabelNodeJSXEmptyExpression | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXIdentifier | BabelNodeJSXMemberExpression | BabelNodeJSXNamespacedName | BabelNodeJSXOpeningElement | BabelNodeJSXSpreadAttribute | BabelNodeJSXText | BabelNodeJSXFragment | BabelNodeJSXOpeningFragment | BabelNodeJSXClosingFragment;
+type BabelNodePrivate = BabelNodeClassPrivateProperty | BabelNodePrivateName;
+type BabelNodeTSTypeElement = BabelNodeTSCallSignatureDeclaration | BabelNodeTSConstructSignatureDeclaration | BabelNodeTSPropertySignature | BabelNodeTSMethodSignature | BabelNodeTSIndexSignature;
+type BabelNodeTSType = BabelNodeTSAnyKeyword | BabelNodeTSNumberKeyword | BabelNodeTSObjectKeyword | BabelNodeTSBooleanKeyword | BabelNodeTSStringKeyword | BabelNodeTSSymbolKeyword | BabelNodeTSVoidKeyword | BabelNodeTSUndefinedKeyword | BabelNodeTSNullKeyword | BabelNodeTSNeverKeyword | BabelNodeTSThisType | BabelNodeTSFunctionType | BabelNodeTSConstructorType | BabelNodeTSTypeReference | BabelNodeTSTypePredicate | BabelNodeTSTypeQuery | BabelNodeTSTypeLiteral | BabelNodeTSArrayType | BabelNodeTSTupleType | BabelNodeTSUnionType | BabelNodeTSIntersectionType | BabelNodeTSConditionalType | BabelNodeTSInferType | BabelNodeTSParenthesizedType | BabelNodeTSTypeOperator | BabelNodeTSIndexedAccessType | BabelNodeTSMappedType | BabelNodeTSLiteralType | BabelNodeTSExpressionWithTypeArguments;
+
+declare module "@babel/types" {
+  declare function arrayExpression(elements?: Array<null | BabelNodeExpression | BabelNodeSpreadElement>): BabelNodeArrayExpression;
+  declare function assignmentExpression(operator: string, left: BabelNodeLVal, right: BabelNodeExpression): BabelNodeAssignmentExpression;
+  declare function binaryExpression(operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=", left: BabelNodeExpression, right: BabelNodeExpression): BabelNodeBinaryExpression;
+  declare function directive(value: BabelNodeDirectiveLiteral): BabelNodeDirective;
+  declare function directiveLiteral(value: string): BabelNodeDirectiveLiteral;
+  declare function blockStatement(body: Array<BabelNodeStatement>, directives?: Array<BabelNodeDirective>): BabelNodeBlockStatement;
+  declare function breakStatement(label?: BabelNodeIdentifier): BabelNodeBreakStatement;
+  declare function callExpression(callee: BabelNodeExpression, _arguments: Array<BabelNodeExpression | BabelNodeSpreadElement | BabelNodeJSXNamespacedName>, optional?: true | false, typeParameters?: BabelNodeTypeParameterInstantiation | BabelNodeTSTypeParameterInstantiation): BabelNodeCallExpression;
+  declare function catchClause(param?: BabelNodeIdentifier, body: BabelNodeBlockStatement): BabelNodeCatchClause;
+  declare function conditionalExpression(test: BabelNodeExpression, consequent: BabelNodeExpression, alternate: BabelNodeExpression): BabelNodeConditionalExpression;
+  declare function continueStatement(label?: BabelNodeIdentifier): BabelNodeContinueStatement;
+  declare function debuggerStatement(): BabelNodeDebuggerStatement;
+  declare function doWhileStatement(test: BabelNodeExpression, body: BabelNodeStatement): BabelNodeDoWhileStatement;
+  declare function emptyStatement(): BabelNodeEmptyStatement;
+  declare function expressionStatement(expression: BabelNodeExpression): BabelNodeExpressionStatement;
+  declare function file(program: BabelNodeProgram, comments: any, tokens: any): BabelNodeFile;
+  declare function forInStatement(left: BabelNodeVariableDeclaration | BabelNodeLVal, right: BabelNodeExpression, body: BabelNodeStatement): BabelNodeForInStatement;
+  declare function forStatement(init?: BabelNodeVariableDeclaration | BabelNodeExpression, test?: BabelNodeExpression, update?: BabelNodeExpression, body: BabelNodeStatement): BabelNodeForStatement;
+  declare function functionDeclaration(id?: BabelNodeIdentifier, params: Array<BabelNodeLVal>, body: BabelNodeBlockStatement, generator?: boolean, async?: boolean, declare?: boolean, returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop, typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop): BabelNodeFunctionDeclaration;
+  declare function functionExpression(id?: BabelNodeIdentifier, params: Array<BabelNodeLVal>, body: BabelNodeBlockStatement, generator?: boolean, async?: boolean, returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop, typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop): BabelNodeFunctionExpression;
+  declare function identifier(name: string, decorators?: Array<BabelNodeDecorator>, optional?: boolean, typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop): BabelNodeIdentifier;
+  declare function ifStatement(test: BabelNodeExpression, consequent: BabelNodeStatement, alternate?: BabelNodeStatement): BabelNodeIfStatement;
+  declare function labeledStatement(label: BabelNodeIdentifier, body: BabelNodeStatement): BabelNodeLabeledStatement;
+  declare function stringLiteral(value: string): BabelNodeStringLiteral;
+  declare function numericLiteral(value: number): BabelNodeNumericLiteral;
+  declare function nullLiteral(): BabelNodeNullLiteral;
+  declare function booleanLiteral(value: boolean): BabelNodeBooleanLiteral;
+  declare function regExpLiteral(pattern: string, flags?: string): BabelNodeRegExpLiteral;
+  declare function logicalExpression(operator: "||" | "&&" | "??", left: BabelNodeExpression, right: BabelNodeExpression): BabelNodeLogicalExpression;
+  declare function memberExpression(object: BabelNodeExpression, property: any, computed?: boolean, optional?: true | false): BabelNodeMemberExpression;
+  declare function newExpression(callee: BabelNodeExpression, _arguments: Array<BabelNodeExpression | BabelNodeSpreadElement | BabelNodeJSXNamespacedName>, optional?: true | false, typeParameters?: BabelNodeTypeParameterInstantiation | BabelNodeTSTypeParameterInstantiation): BabelNodeNewExpression;
+  declare function program(body: Array<BabelNodeStatement>, directives?: Array<BabelNodeDirective>, sourceType?: "script" | "module", sourceFile?: string): BabelNodeProgram;
+  declare function objectExpression(properties: Array<BabelNodeObjectMethod | BabelNodeObjectProperty | BabelNodeSpreadElement>): BabelNodeObjectExpression;
+  declare function objectMethod(kind?: "method" | "get" | "set", key: any, params: Array<BabelNodeLVal>, body: BabelNodeBlockStatement, computed?: boolean, async?: boolean, decorators?: Array<BabelNodeDecorator>, generator?: boolean, returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop, typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop): BabelNodeObjectMethod;
+  declare function objectProperty(key: any, value: BabelNodeExpression | BabelNodePatternLike, computed?: boolean, shorthand?: boolean, decorators?: Array<BabelNodeDecorator>): BabelNodeObjectProperty;
+  declare function restElement(argument: BabelNodeLVal, decorators?: Array<BabelNodeDecorator>, typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop): BabelNodeRestElement;
+  declare function returnStatement(argument?: BabelNodeExpression): BabelNodeReturnStatement;
+  declare function sequenceExpression(expressions: Array<BabelNodeExpression>): BabelNodeSequenceExpression;
+  declare function switchCase(test?: BabelNodeExpression, consequent: Array<BabelNodeStatement>): BabelNodeSwitchCase;
+  declare function switchStatement(discriminant: BabelNodeExpression, cases: Array<BabelNodeSwitchCase>): BabelNodeSwitchStatement;
+  declare function thisExpression(): BabelNodeThisExpression;
+  declare function throwStatement(argument: BabelNodeExpression): BabelNodeThrowStatement;
+  declare function tryStatement(block: BabelNodeBlockStatement, handler?: BabelNodeCatchClause, finalizer?: BabelNodeBlockStatement): BabelNodeTryStatement;
+  declare function unaryExpression(operator: "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof", argument: BabelNodeExpression, prefix?: boolean): BabelNodeUnaryExpression;
+  declare function updateExpression(operator: "++" | "--", argument: BabelNodeExpression, prefix?: boolean): BabelNodeUpdateExpression;
+  declare function variableDeclaration(kind: "var" | "let" | "const", declarations: Array<BabelNodeVariableDeclarator>, declare?: boolean): BabelNodeVariableDeclaration;
+  declare function variableDeclarator(id: BabelNodeLVal, init?: BabelNodeExpression, definite?: boolean): BabelNodeVariableDeclarator;
+  declare function whileStatement(test: BabelNodeExpression, body: BabelNodeBlockStatement | BabelNodeStatement): BabelNodeWhileStatement;
+  declare function withStatement(object: BabelNodeExpression, body: BabelNodeBlockStatement | BabelNodeStatement): BabelNodeWithStatement;
+  declare function assignmentPattern(left: BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeArrayPattern, right: BabelNodeExpression, decorators?: Array<BabelNodeDecorator>, typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop): BabelNodeAssignmentPattern;
+  declare function arrayPattern(elements: Array<BabelNodePatternLike>, decorators?: Array<BabelNodeDecorator>, typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop): BabelNodeArrayPattern;
+  declare function arrowFunctionExpression(params: Array<BabelNodeLVal>, body: BabelNodeBlockStatement | BabelNodeExpression, async?: boolean, expression?: boolean, generator?: boolean, returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop, typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop): BabelNodeArrowFunctionExpression;
+  declare function classBody(body: Array<BabelNodeClassMethod | BabelNodeClassProperty | BabelNodeClassPrivateProperty | BabelNodeTSDeclareMethod | BabelNodeTSIndexSignature>): BabelNodeClassBody;
+  declare function classDeclaration(id?: BabelNodeIdentifier, superClass?: BabelNodeExpression, body: BabelNodeClassBody, decorators?: Array<BabelNodeDecorator>, abstract?: boolean, declare?: boolean, _implements?: Array<BabelNodeTSExpressionWithTypeArguments | BabelNodeClassImplements>, mixins?: any, superTypeParameters?: BabelNodeTypeParameterInstantiation | BabelNodeTSTypeParameterInstantiation, typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop): BabelNodeClassDeclaration;
+  declare function classExpression(id?: BabelNodeIdentifier, superClass?: BabelNodeExpression, body: BabelNodeClassBody, decorators?: Array<BabelNodeDecorator>, _implements?: Array<BabelNodeTSExpressionWithTypeArguments | BabelNodeClassImplements>, mixins?: any, superTypeParameters?: BabelNodeTypeParameterInstantiation | BabelNodeTSTypeParameterInstantiation, typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop): BabelNodeClassExpression;
+  declare function exportAllDeclaration(source: BabelNodeStringLiteral): BabelNodeExportAllDeclaration;
+  declare function exportDefaultDeclaration(declaration: BabelNodeFunctionDeclaration | BabelNodeTSDeclareFunction | BabelNodeClassDeclaration | BabelNodeExpression): BabelNodeExportDefaultDeclaration;
+  declare function exportNamedDeclaration(declaration?: BabelNodeDeclaration, specifiers: Array<BabelNodeExportSpecifier | BabelNodeExportDefaultSpecifier | BabelNodeExportNamespaceSpecifier>, source?: BabelNodeStringLiteral): BabelNodeExportNamedDeclaration;
+  declare function exportSpecifier(local: BabelNodeIdentifier, exported: BabelNodeIdentifier): BabelNodeExportSpecifier;
+  declare function forOfStatement(left: BabelNodeVariableDeclaration | BabelNodeLVal, right: BabelNodeExpression, body: BabelNodeStatement, _await?: boolean): BabelNodeForOfStatement;
+  declare function importDeclaration(specifiers: Array<BabelNodeImportSpecifier | BabelNodeImportDefaultSpecifier | BabelNodeImportNamespaceSpecifier>, source: BabelNodeStringLiteral): BabelNodeImportDeclaration;
+  declare function importDefaultSpecifier(local: BabelNodeIdentifier): BabelNodeImportDefaultSpecifier;
+  declare function importNamespaceSpecifier(local: BabelNodeIdentifier): BabelNodeImportNamespaceSpecifier;
+  declare function importSpecifier(local: BabelNodeIdentifier, imported: BabelNodeIdentifier, importKind?: null | "type" | "typeof"): BabelNodeImportSpecifier;
+  declare function metaProperty(meta: BabelNodeIdentifier, property: BabelNodeIdentifier): BabelNodeMetaProperty;
+  declare function classMethod(kind?: "get" | "set" | "method" | "constructor", key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeExpression, params: Array<BabelNodeLVal>, body: BabelNodeBlockStatement, computed?: boolean, _static?: boolean, abstract?: boolean, access?: "public" | "private" | "protected", accessibility?: "public" | "private" | "protected", async?: boolean, decorators?: Array<BabelNodeDecorator>, generator?: boolean, optional?: boolean, returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop, typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop): BabelNodeClassMethod;
+  declare function objectPattern(properties: Array<BabelNodeRestElement | BabelNodeObjectProperty>, decorators?: Array<BabelNodeDecorator>, typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop): BabelNodeObjectPattern;
+  declare function spreadElement(argument: BabelNodeExpression): BabelNodeSpreadElement;
+  declare function taggedTemplateExpression(tag: BabelNodeExpression, quasi: BabelNodeTemplateLiteral): BabelNodeTaggedTemplateExpression;
+  declare function templateElement(value: any, tail?: boolean): BabelNodeTemplateElement;
+  declare function templateLiteral(quasis: Array<BabelNodeTemplateElement>, expressions: Array<BabelNodeExpression>): BabelNodeTemplateLiteral;
+  declare function yieldExpression(argument?: BabelNodeExpression, delegate?: boolean): BabelNodeYieldExpression;
+  declare function anyTypeAnnotation(): BabelNodeAnyTypeAnnotation;
+  declare function arrayTypeAnnotation(elementType: BabelNodeFlowType): BabelNodeArrayTypeAnnotation;
+  declare function booleanTypeAnnotation(): BabelNodeBooleanTypeAnnotation;
+  declare function booleanLiteralTypeAnnotation(value: boolean): BabelNodeBooleanLiteralTypeAnnotation;
+  declare function nullLiteralTypeAnnotation(): BabelNodeNullLiteralTypeAnnotation;
+  declare function classImplements(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterInstantiation): BabelNodeClassImplements;
+  declare function declareClass(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterInstantiation, _extends?: Array<BabelNodeInterfaceExtends>, body: BabelNodeObjectTypeAnnotation, _implements?: Array<BabelNodeClassImplements>, mixins?: Array<BabelNodeInterfaceExtends>): BabelNodeDeclareClass;
+  declare function declareFunction(id: BabelNodeIdentifier, predicate?: BabelNodeDeclaredPredicate): BabelNodeDeclareFunction;
+  declare function declareInterface(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, _extends?: Array<BabelNodeInterfaceExtends>, body: BabelNodeObjectTypeAnnotation, _implements?: Array<BabelNodeClassImplements>, mixins?: Array<BabelNodeInterfaceExtends>): BabelNodeDeclareInterface;
+  declare function declareModule(id: BabelNodeIdentifier | BabelNodeStringLiteral, body: BabelNodeBlockStatement, kind?: "CommonJS" | "ES"): BabelNodeDeclareModule;
+  declare function declareModuleExports(typeAnnotation: BabelNodeTypeAnnotation): BabelNodeDeclareModuleExports;
+  declare function declareTypeAlias(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, right: BabelNodeFlowType): BabelNodeDeclareTypeAlias;
+  declare function declareOpaqueType(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, supertype?: BabelNodeFlowType): BabelNodeDeclareOpaqueType;
+  declare function declareVariable(id: BabelNodeIdentifier): BabelNodeDeclareVariable;
+  declare function declareExportDeclaration(declaration?: BabelNodeFlow, specifiers?: Array<BabelNodeExportSpecifier | BabelNodeExportNamespaceSpecifier>, source?: BabelNodeStringLiteral, _default?: boolean): BabelNodeDeclareExportDeclaration;
+  declare function declareExportAllDeclaration(source: BabelNodeStringLiteral, exportKind?: ["type","value"]): BabelNodeDeclareExportAllDeclaration;
+  declare function declaredPredicate(value: BabelNodeFlow): BabelNodeDeclaredPredicate;
+  declare function existsTypeAnnotation(): BabelNodeExistsTypeAnnotation;
+  declare function functionTypeAnnotation(typeParameters?: BabelNodeTypeParameterDeclaration, params: Array<BabelNodeFunctionTypeParam>, rest?: BabelNodeFunctionTypeParam, returnType: BabelNodeFlowType): BabelNodeFunctionTypeAnnotation;
+  declare function functionTypeParam(name?: BabelNodeIdentifier, typeAnnotation: BabelNodeFlowType, optional?: boolean): BabelNodeFunctionTypeParam;
+  declare function genericTypeAnnotation(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterInstantiation): BabelNodeGenericTypeAnnotation;
+  declare function inferredPredicate(): BabelNodeInferredPredicate;
+  declare function interfaceExtends(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterInstantiation): BabelNodeInterfaceExtends;
+  declare function interfaceDeclaration(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, _extends?: Array<BabelNodeInterfaceExtends>, body: BabelNodeObjectTypeAnnotation, _implements?: Array<BabelNodeClassImplements>, mixins?: Array<BabelNodeInterfaceExtends>): BabelNodeInterfaceDeclaration;
+  declare function intersectionTypeAnnotation(types: Array<BabelNodeFlowType>): BabelNodeIntersectionTypeAnnotation;
+  declare function mixedTypeAnnotation(): BabelNodeMixedTypeAnnotation;
+  declare function emptyTypeAnnotation(): BabelNodeEmptyTypeAnnotation;
+  declare function nullableTypeAnnotation(typeAnnotation: BabelNodeFlowType): BabelNodeNullableTypeAnnotation;
+  declare function numberLiteralTypeAnnotation(value: number): BabelNodeNumberLiteralTypeAnnotation;
+  declare function numberTypeAnnotation(): BabelNodeNumberTypeAnnotation;
+  declare function objectTypeAnnotation(properties: Array<BabelNodeObjectTypeProperty | BabelNodeObjectTypeSpreadProperty>, indexers?: Array<BabelNodeObjectTypeIndexer>, callProperties?: Array<BabelNodeObjectTypeCallProperty>, exact?: boolean): BabelNodeObjectTypeAnnotation;
+  declare function objectTypeCallProperty(value: BabelNodeFlowType, _static?: boolean): BabelNodeObjectTypeCallProperty;
+  declare function objectTypeIndexer(id?: BabelNodeIdentifier, key: BabelNodeFlowType, value: BabelNodeFlowType, variance?: BabelNodeVariance, _static?: boolean): BabelNodeObjectTypeIndexer;
+  declare function objectTypeProperty(key: BabelNodeIdentifier | BabelNodeStringLiteral, value: BabelNodeFlowType, variance?: BabelNodeVariance, kind?: "init" | "get" | "set", optional?: boolean, _static?: boolean): BabelNodeObjectTypeProperty;
+  declare function objectTypeSpreadProperty(argument: BabelNodeFlowType): BabelNodeObjectTypeSpreadProperty;
+  declare function opaqueType(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, supertype?: BabelNodeFlowType, impltype: BabelNodeFlowType): BabelNodeOpaqueType;
+  declare function qualifiedTypeIdentifier(id: BabelNodeIdentifier, qualification: BabelNodeIdentifier | BabelNodeQualifiedTypeIdentifier): BabelNodeQualifiedTypeIdentifier;
+  declare function stringLiteralTypeAnnotation(value: string): BabelNodeStringLiteralTypeAnnotation;
+  declare function stringTypeAnnotation(): BabelNodeStringTypeAnnotation;
+  declare function thisTypeAnnotation(): BabelNodeThisTypeAnnotation;
+  declare function tupleTypeAnnotation(types: Array<BabelNodeFlowType>): BabelNodeTupleTypeAnnotation;
+  declare function typeofTypeAnnotation(argument: BabelNodeFlowType): BabelNodeTypeofTypeAnnotation;
+  declare function typeAlias(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, right: BabelNodeFlowType): BabelNodeTypeAlias;
+  declare function typeAnnotation(typeAnnotation: BabelNodeFlowType): BabelNodeTypeAnnotation;
+  declare function typeCastExpression(expression: BabelNodeExpression, typeAnnotation: BabelNodeTypeAnnotation): BabelNodeTypeCastExpression;
+  declare function typeParameter(bound?: BabelNodeTypeAnnotation, _default?: BabelNodeFlowType, variance?: BabelNodeVariance, name?: string): BabelNodeTypeParameter;
+  declare function typeParameterDeclaration(params: Array<BabelNodeTypeParameter>): BabelNodeTypeParameterDeclaration;
+  declare function typeParameterInstantiation(params: Array<BabelNodeFlowType>): BabelNodeTypeParameterInstantiation;
+  declare function unionTypeAnnotation(types: Array<BabelNodeFlowType>): BabelNodeUnionTypeAnnotation;
+  declare function variance(kind: "minus" | "plus"): BabelNodeVariance;
+  declare function voidTypeAnnotation(): BabelNodeVoidTypeAnnotation;
+  declare function jsxAttribute(name: BabelNodeJSXIdentifier | BabelNodeJSXNamespacedName, value?: BabelNodeJSXElement | BabelNodeJSXFragment | BabelNodeStringLiteral | BabelNodeJSXExpressionContainer): BabelNodeJSXAttribute;
+  declare function jsxClosingElement(name: BabelNodeJSXIdentifier | BabelNodeJSXMemberExpression): BabelNodeJSXClosingElement;
+  declare function jsxElement(openingElement: BabelNodeJSXOpeningElement, closingElement?: BabelNodeJSXClosingElement, children: Array<BabelNodeJSXText | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXElement | BabelNodeJSXFragment>, selfClosing: any): BabelNodeJSXElement;
+  declare function jsxEmptyExpression(): BabelNodeJSXEmptyExpression;
+  declare function jsxExpressionContainer(expression: BabelNodeExpression): BabelNodeJSXExpressionContainer;
+  declare function jsxSpreadChild(expression: BabelNodeExpression): BabelNodeJSXSpreadChild;
+  declare function jsxIdentifier(name: string): BabelNodeJSXIdentifier;
+  declare function jsxMemberExpression(object: BabelNodeJSXMemberExpression | BabelNodeJSXIdentifier, property: BabelNodeJSXIdentifier): BabelNodeJSXMemberExpression;
+  declare function jsxNamespacedName(namespace: BabelNodeJSXIdentifier, name: BabelNodeJSXIdentifier): BabelNodeJSXNamespacedName;
+  declare function jsxOpeningElement(name: BabelNodeJSXIdentifier | BabelNodeJSXMemberExpression, attributes: Array<BabelNodeJSXAttribute | BabelNodeJSXSpreadAttribute>, selfClosing?: boolean): BabelNodeJSXOpeningElement;
+  declare function jsxSpreadAttribute(argument: BabelNodeExpression): BabelNodeJSXSpreadAttribute;
+  declare function jsxText(value: string): BabelNodeJSXText;
+  declare function jsxFragment(openingFragment: BabelNodeJSXOpeningFragment, closingFragment: BabelNodeJSXClosingFragment, children: Array<BabelNodeJSXText | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXElement | BabelNodeJSXFragment>): BabelNodeJSXFragment;
+  declare function jsxOpeningFragment(): BabelNodeJSXOpeningFragment;
+  declare function jsxClosingFragment(): BabelNodeJSXClosingFragment;
+  declare function noop(): BabelNodeNoop;
+  declare function parenthesizedExpression(expression: BabelNodeExpression): BabelNodeParenthesizedExpression;
+  declare function awaitExpression(argument: BabelNodeExpression): BabelNodeAwaitExpression;
+  declare function bindExpression(object: any, callee: any): BabelNodeBindExpression;
+  declare function classProperty(key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeExpression, value?: BabelNodeExpression, typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop, decorators?: Array<BabelNodeDecorator>, computed?: boolean, abstract?: boolean, accessibility?: "public" | "private" | "protected", definite?: boolean, optional?: boolean, readonly?: boolean, _static?: boolean): BabelNodeClassProperty;
+  declare function optionalMemberExpression(object: BabelNodeExpression, property: any, computed?: boolean, optional: boolean): BabelNodeOptionalMemberExpression;
+  declare function optionalCallExpression(callee: BabelNodeExpression, _arguments: Array<BabelNodeExpression | BabelNodeSpreadElement | BabelNodeJSXNamespacedName>, optional: boolean, typeParameters?: BabelNodeTypeParameterInstantiation | BabelNodeTSTypeParameterInstantiation): BabelNodeOptionalCallExpression;
+  declare function classPrivateProperty(key: BabelNodePrivateName, value?: BabelNodeExpression): BabelNodeClassPrivateProperty;
+  declare function decorator(callee: BabelNodeExpression, _arguments?: Array<BabelNodeExpression | BabelNodeSpreadElement>): BabelNodeDecorator;
+  declare function doExpression(body: BabelNodeBlockStatement): BabelNodeDoExpression;
+  declare function exportDefaultSpecifier(exported: BabelNodeIdentifier): BabelNodeExportDefaultSpecifier;
+  declare function exportNamespaceSpecifier(exported: BabelNodeIdentifier): BabelNodeExportNamespaceSpecifier;
+  declare function privateName(id: BabelNodeIdentifier): BabelNodePrivateName;
+  declare function tsParameterProperty(parameter: BabelNodeIdentifier | BabelNodeAssignmentPattern, accessibility?: "public" | "private" | "protected", readonly?: boolean): BabelNodeTSParameterProperty;
+  declare function tsDeclareFunction(id?: BabelNodeIdentifier, typeParameters?: BabelNodeTSTypeParameterDeclaration | BabelNodeNoop, params: Array<BabelNodeLVal>, returnType?: BabelNodeTSTypeAnnotation | BabelNodeNoop, async?: boolean, declare?: boolean, generator?: boolean): BabelNodeTSDeclareFunction;
+  declare function tsDeclareMethod(decorators?: Array<BabelNodeDecorator>, key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeExpression, typeParameters?: BabelNodeTSTypeParameterDeclaration | BabelNodeNoop, params: Array<BabelNodeLVal>, returnType?: BabelNodeTSTypeAnnotation | BabelNodeNoop, abstract?: boolean, access?: "public" | "private" | "protected", accessibility?: "public" | "private" | "protected", async?: boolean, computed?: boolean, generator?: boolean, kind?: "get" | "set" | "method" | "constructor", optional?: boolean, _static?: boolean): BabelNodeTSDeclareMethod;
+  declare function tsQualifiedName(left: BabelNodeTSEntityName, right: BabelNodeIdentifier): BabelNodeTSQualifiedName;
+  declare function tsCallSignatureDeclaration(typeParameters?: BabelNodeTSTypeParameterDeclaration, parameters?: Array<BabelNodeIdentifier | BabelNodeRestElement>, typeAnnotation?: BabelNodeTSTypeAnnotation): BabelNodeTSCallSignatureDeclaration;
+  declare function tsConstructSignatureDeclaration(typeParameters?: BabelNodeTSTypeParameterDeclaration, parameters?: Array<BabelNodeIdentifier | BabelNodeRestElement>, typeAnnotation?: BabelNodeTSTypeAnnotation): BabelNodeTSConstructSignatureDeclaration;
+  declare function tsPropertySignature(key: BabelNodeExpression, typeAnnotation?: BabelNodeTSTypeAnnotation, initializer?: BabelNodeExpression, computed?: boolean, optional?: boolean, readonly?: boolean): BabelNodeTSPropertySignature;
+  declare function tsMethodSignature(key: BabelNodeExpression, typeParameters?: BabelNodeTSTypeParameterDeclaration, parameters?: Array<BabelNodeIdentifier | BabelNodeRestElement>, typeAnnotation?: BabelNodeTSTypeAnnotation, computed?: boolean, optional?: boolean): BabelNodeTSMethodSignature;
+  declare function tsIndexSignature(parameters: Array<BabelNodeIdentifier>, typeAnnotation?: BabelNodeTSTypeAnnotation, readonly?: boolean): BabelNodeTSIndexSignature;
+  declare function tsAnyKeyword(): BabelNodeTSAnyKeyword;
+  declare function tsNumberKeyword(): BabelNodeTSNumberKeyword;
+  declare function tsObjectKeyword(): BabelNodeTSObjectKeyword;
+  declare function tsBooleanKeyword(): BabelNodeTSBooleanKeyword;
+  declare function tsStringKeyword(): BabelNodeTSStringKeyword;
+  declare function tsSymbolKeyword(): BabelNodeTSSymbolKeyword;
+  declare function tsVoidKeyword(): BabelNodeTSVoidKeyword;
+  declare function tsUndefinedKeyword(): BabelNodeTSUndefinedKeyword;
+  declare function tsNullKeyword(): BabelNodeTSNullKeyword;
+  declare function tsNeverKeyword(): BabelNodeTSNeverKeyword;
+  declare function tsThisType(): BabelNodeTSThisType;
+  declare function tsFunctionType(typeParameters?: BabelNodeTSTypeParameterDeclaration, typeAnnotation?: BabelNodeTSTypeAnnotation, parameters?: Array<BabelNodeIdentifier | BabelNodeRestElement>): BabelNodeTSFunctionType;
+  declare function tsConstructorType(typeParameters?: BabelNodeTSTypeParameterDeclaration, typeAnnotation?: BabelNodeTSTypeAnnotation, parameters?: Array<BabelNodeIdentifier | BabelNodeRestElement>): BabelNodeTSConstructorType;
+  declare function tsTypeReference(typeName: BabelNodeTSEntityName, typeParameters?: BabelNodeTSTypeParameterInstantiation): BabelNodeTSTypeReference;
+  declare function tsTypePredicate(parameterName: BabelNodeIdentifier | BabelNodeTSThisType, typeAnnotation: BabelNodeTSTypeAnnotation): BabelNodeTSTypePredicate;
+  declare function tsTypeQuery(exprName: BabelNodeTSEntityName): BabelNodeTSTypeQuery;
+  declare function tsTypeLiteral(members: Array<BabelNodeTSTypeElement>): BabelNodeTSTypeLiteral;
+  declare function tsArrayType(elementType: BabelNodeTSType): BabelNodeTSArrayType;
+  declare function tsTupleType(elementTypes: Array<BabelNodeTSType>): BabelNodeTSTupleType;
+  declare function tsUnionType(types: Array<BabelNodeTSType>): BabelNodeTSUnionType;
+  declare function tsIntersectionType(types: Array<BabelNodeTSType>): BabelNodeTSIntersectionType;
+  declare function tsConditionalType(checkType: BabelNodeTSType, extendsType: BabelNodeTSType, trueType: BabelNodeTSType, falseType: BabelNodeTSType): BabelNodeTSConditionalType;
+  declare function tsInferType(typeParameter: BabelNodeTSType): BabelNodeTSInferType;
+  declare function tsParenthesizedType(typeAnnotation: BabelNodeTSType): BabelNodeTSParenthesizedType;
+  declare function tsTypeOperator(typeAnnotation: BabelNodeTSType, operator?: string): BabelNodeTSTypeOperator;
+  declare function tsIndexedAccessType(objectType: BabelNodeTSType, indexType: BabelNodeTSType): BabelNodeTSIndexedAccessType;
+  declare function tsMappedType(typeParameter: BabelNodeTSTypeParameter, typeAnnotation?: BabelNodeTSType, optional?: boolean, readonly?: boolean): BabelNodeTSMappedType;
+  declare function tsLiteralType(literal: BabelNodeNumericLiteral | BabelNodeStringLiteral | BabelNodeBooleanLiteral): BabelNodeTSLiteralType;
+  declare function tsExpressionWithTypeArguments(expression: BabelNodeTSEntityName, typeParameters?: BabelNodeTSTypeParameterInstantiation): BabelNodeTSExpressionWithTypeArguments;
+  declare function tsInterfaceDeclaration(id: BabelNodeIdentifier, typeParameters?: BabelNodeTSTypeParameterDeclaration, _extends?: Array<BabelNodeTSExpressionWithTypeArguments>, body: BabelNodeTSInterfaceBody, declare?: boolean): BabelNodeTSInterfaceDeclaration;
+  declare function tsInterfaceBody(body: Array<BabelNodeTSTypeElement>): BabelNodeTSInterfaceBody;
+  declare function tsTypeAliasDeclaration(id: BabelNodeIdentifier, typeParameters?: BabelNodeTSTypeParameterDeclaration, typeAnnotation: BabelNodeTSType, declare?: boolean): BabelNodeTSTypeAliasDeclaration;
+  declare function tsAsExpression(expression: BabelNodeExpression, typeAnnotation: BabelNodeTSType): BabelNodeTSAsExpression;
+  declare function tsTypeAssertion(typeAnnotation: BabelNodeTSType, expression: BabelNodeExpression): BabelNodeTSTypeAssertion;
+  declare function tsEnumDeclaration(id: BabelNodeIdentifier, members: Array<BabelNodeTSEnumMember>, _const?: boolean, declare?: boolean, initializer?: BabelNodeExpression): BabelNodeTSEnumDeclaration;
+  declare function tsEnumMember(id: BabelNodeIdentifier | BabelNodeStringLiteral, initializer?: BabelNodeExpression): BabelNodeTSEnumMember;
+  declare function tsModuleDeclaration(id: BabelNodeIdentifier | BabelNodeStringLiteral, body: BabelNodeTSModuleBlock | BabelNodeTSModuleDeclaration, declare?: boolean, global?: boolean): BabelNodeTSModuleDeclaration;
+  declare function tsModuleBlock(body: Array<BabelNodeStatement>): BabelNodeTSModuleBlock;
+  declare function tsImportEqualsDeclaration(id: BabelNodeIdentifier, moduleReference: BabelNodeTSEntityName | BabelNodeTSExternalModuleReference, isExport?: boolean): BabelNodeTSImportEqualsDeclaration;
+  declare function tsExternalModuleReference(expression: BabelNodeStringLiteral): BabelNodeTSExternalModuleReference;
+  declare function tsNonNullExpression(expression: BabelNodeExpression): BabelNodeTSNonNullExpression;
+  declare function tsExportAssignment(expression: BabelNodeExpression): BabelNodeTSExportAssignment;
+  declare function tsNamespaceExportDeclaration(id: BabelNodeIdentifier): BabelNodeTSNamespaceExportDeclaration;
+  declare function tsTypeAnnotation(typeAnnotation: BabelNodeTSType): BabelNodeTSTypeAnnotation;
+  declare function tsTypeParameterInstantiation(params: Array<BabelNodeTSType>): BabelNodeTSTypeParameterInstantiation;
+  declare function tsTypeParameterDeclaration(params: Array<BabelNodeTSTypeParameter>): BabelNodeTSTypeParameterDeclaration;
+  declare function tsTypeParameter(constraint?: BabelNodeTSType, _default?: BabelNodeTSType, name?: string): BabelNodeTSTypeParameter;
+  declare function isArrayExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeArrayExpression)
+  declare function isAssignmentExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeAssignmentExpression)
+  declare function isBinaryExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBinaryExpression)
+  declare function isDirective(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDirective)
+  declare function isDirectiveLiteral(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDirectiveLiteral)
+  declare function isBlockStatement(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBlockStatement)
+  declare function isBreakStatement(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBreakStatement)
+  declare function isCallExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeCallExpression)
+  declare function isCatchClause(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeCatchClause)
+  declare function isConditionalExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeConditionalExpression)
+  declare function isContinueStatement(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeContinueStatement)
+  declare function isDebuggerStatement(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDebuggerStatement)
+  declare function isDoWhileStatement(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDoWhileStatement)
+  declare function isEmptyStatement(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEmptyStatement)
+  declare function isExpressionStatement(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExpressionStatement)
+  declare function isFile(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeFile)
+  declare function isForInStatement(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeForInStatement)
+  declare function isForStatement(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeForStatement)
+  declare function isFunctionDeclaration(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeFunctionDeclaration)
+  declare function isFunctionExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeFunctionExpression)
+  declare function isIdentifier(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeIdentifier)
+  declare function isIfStatement(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeIfStatement)
+  declare function isLabeledStatement(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeLabeledStatement)
+  declare function isStringLiteral(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeStringLiteral)
+  declare function isNumericLiteral(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNumericLiteral)
+  declare function isNullLiteral(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNullLiteral)
+  declare function isBooleanLiteral(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBooleanLiteral)
+  declare function isRegExpLiteral(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeRegExpLiteral)
+  declare function isLogicalExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeLogicalExpression)
+  declare function isMemberExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeMemberExpression)
+  declare function isNewExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNewExpression)
+  declare function isProgram(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeProgram)
+  declare function isObjectExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectExpression)
+  declare function isObjectMethod(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectMethod)
+  declare function isObjectProperty(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectProperty)
+  declare function isRestElement(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeRestElement)
+  declare function isReturnStatement(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeReturnStatement)
+  declare function isSequenceExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeSequenceExpression)
+  declare function isSwitchCase(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeSwitchCase)
+  declare function isSwitchStatement(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeSwitchStatement)
+  declare function isThisExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeThisExpression)
+  declare function isThrowStatement(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeThrowStatement)
+  declare function isTryStatement(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTryStatement)
+  declare function isUnaryExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeUnaryExpression)
+  declare function isUpdateExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeUpdateExpression)
+  declare function isVariableDeclaration(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeVariableDeclaration)
+  declare function isVariableDeclarator(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeVariableDeclarator)
+  declare function isWhileStatement(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeWhileStatement)
+  declare function isWithStatement(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeWithStatement)
+  declare function isAssignmentPattern(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeAssignmentPattern)
+  declare function isArrayPattern(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeArrayPattern)
+  declare function isArrowFunctionExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeArrowFunctionExpression)
+  declare function isClassBody(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassBody)
+  declare function isClassDeclaration(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassDeclaration)
+  declare function isClassExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassExpression)
+  declare function isExportAllDeclaration(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExportAllDeclaration)
+  declare function isExportDefaultDeclaration(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExportDefaultDeclaration)
+  declare function isExportNamedDeclaration(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExportNamedDeclaration)
+  declare function isExportSpecifier(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExportSpecifier)
+  declare function isForOfStatement(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeForOfStatement)
+  declare function isImportDeclaration(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeImportDeclaration)
+  declare function isImportDefaultSpecifier(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeImportDefaultSpecifier)
+  declare function isImportNamespaceSpecifier(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeImportNamespaceSpecifier)
+  declare function isImportSpecifier(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeImportSpecifier)
+  declare function isMetaProperty(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeMetaProperty)
+  declare function isClassMethod(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassMethod)
+  declare function isObjectPattern(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectPattern)
+  declare function isSpreadElement(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeSpreadElement)
+  declare function isSuper(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeSuper)
+  declare function isTaggedTemplateExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTaggedTemplateExpression)
+  declare function isTemplateElement(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTemplateElement)
+  declare function isTemplateLiteral(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTemplateLiteral)
+  declare function isYieldExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeYieldExpression)
+  declare function isAnyTypeAnnotation(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeAnyTypeAnnotation)
+  declare function isArrayTypeAnnotation(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeArrayTypeAnnotation)
+  declare function isBooleanTypeAnnotation(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBooleanTypeAnnotation)
+  declare function isBooleanLiteralTypeAnnotation(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBooleanLiteralTypeAnnotation)
+  declare function isNullLiteralTypeAnnotation(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNullLiteralTypeAnnotation)
+  declare function isClassImplements(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassImplements)
+  declare function isDeclareClass(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareClass)
+  declare function isDeclareFunction(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareFunction)
+  declare function isDeclareInterface(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareInterface)
+  declare function isDeclareModule(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareModule)
+  declare function isDeclareModuleExports(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareModuleExports)
+  declare function isDeclareTypeAlias(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareTypeAlias)
+  declare function isDeclareOpaqueType(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareOpaqueType)
+  declare function isDeclareVariable(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareVariable)
+  declare function isDeclareExportDeclaration(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareExportDeclaration)
+  declare function isDeclareExportAllDeclaration(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareExportAllDeclaration)
+  declare function isDeclaredPredicate(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclaredPredicate)
+  declare function isExistsTypeAnnotation(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExistsTypeAnnotation)
+  declare function isFunctionTypeAnnotation(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeFunctionTypeAnnotation)
+  declare function isFunctionTypeParam(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeFunctionTypeParam)
+  declare function isGenericTypeAnnotation(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeGenericTypeAnnotation)
+  declare function isInferredPredicate(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeInferredPredicate)
+  declare function isInterfaceExtends(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeInterfaceExtends)
+  declare function isInterfaceDeclaration(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeInterfaceDeclaration)
+  declare function isIntersectionTypeAnnotation(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeIntersectionTypeAnnotation)
+  declare function isMixedTypeAnnotation(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeMixedTypeAnnotation)
+  declare function isEmptyTypeAnnotation(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEmptyTypeAnnotation)
+  declare function isNullableTypeAnnotation(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNullableTypeAnnotation)
+  declare function isNumberLiteralTypeAnnotation(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNumberLiteralTypeAnnotation)
+  declare function isNumberTypeAnnotation(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNumberTypeAnnotation)
+  declare function isObjectTypeAnnotation(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectTypeAnnotation)
+  declare function isObjectTypeCallProperty(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectTypeCallProperty)
+  declare function isObjectTypeIndexer(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectTypeIndexer)
+  declare function isObjectTypeProperty(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectTypeProperty)
+  declare function isObjectTypeSpreadProperty(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectTypeSpreadProperty)
+  declare function isOpaqueType(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeOpaqueType)
+  declare function isQualifiedTypeIdentifier(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeQualifiedTypeIdentifier)
+  declare function isStringLiteralTypeAnnotation(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeStringLiteralTypeAnnotation)
+  declare function isStringTypeAnnotation(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeStringTypeAnnotation)
+  declare function isThisTypeAnnotation(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeThisTypeAnnotation)
+  declare function isTupleTypeAnnotation(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTupleTypeAnnotation)
+  declare function isTypeofTypeAnnotation(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeofTypeAnnotation)
+  declare function isTypeAlias(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeAlias)
+  declare function isTypeAnnotation(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeAnnotation)
+  declare function isTypeCastExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeCastExpression)
+  declare function isTypeParameter(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeParameter)
+  declare function isTypeParameterDeclaration(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeParameterDeclaration)
+  declare function isTypeParameterInstantiation(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeParameterInstantiation)
+  declare function isUnionTypeAnnotation(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeUnionTypeAnnotation)
+  declare function isVariance(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeVariance)
+  declare function isVoidTypeAnnotation(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeVoidTypeAnnotation)
+  declare function isJSXAttribute(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXAttribute)
+  declare function isJSXClosingElement(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXClosingElement)
+  declare function isJSXElement(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXElement)
+  declare function isJSXEmptyExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXEmptyExpression)
+  declare function isJSXExpressionContainer(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXExpressionContainer)
+  declare function isJSXSpreadChild(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXSpreadChild)
+  declare function isJSXIdentifier(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXIdentifier)
+  declare function isJSXMemberExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXMemberExpression)
+  declare function isJSXNamespacedName(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXNamespacedName)
+  declare function isJSXOpeningElement(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXOpeningElement)
+  declare function isJSXSpreadAttribute(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXSpreadAttribute)
+  declare function isJSXText(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXText)
+  declare function isJSXFragment(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXFragment)
+  declare function isJSXOpeningFragment(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXOpeningFragment)
+  declare function isJSXClosingFragment(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXClosingFragment)
+  declare function isNoop(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNoop)
+  declare function isParenthesizedExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeParenthesizedExpression)
+  declare function isAwaitExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeAwaitExpression)
+  declare function isBindExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBindExpression)
+  declare function isClassProperty(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassProperty)
+  declare function isOptionalMemberExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeOptionalMemberExpression)
+  declare function isOptionalCallExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeOptionalCallExpression)
+  declare function isClassPrivateProperty(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassPrivateProperty)
+  declare function isImport(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeImport)
+  declare function isDecorator(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDecorator)
+  declare function isDoExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDoExpression)
+  declare function isExportDefaultSpecifier(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExportDefaultSpecifier)
+  declare function isExportNamespaceSpecifier(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExportNamespaceSpecifier)
+  declare function isPrivateName(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodePrivateName)
+  declare function isTSParameterProperty(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSParameterProperty)
+  declare function isTSDeclareFunction(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSDeclareFunction)
+  declare function isTSDeclareMethod(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSDeclareMethod)
+  declare function isTSQualifiedName(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSQualifiedName)
+  declare function isTSCallSignatureDeclaration(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSCallSignatureDeclaration)
+  declare function isTSConstructSignatureDeclaration(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSConstructSignatureDeclaration)
+  declare function isTSPropertySignature(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSPropertySignature)
+  declare function isTSMethodSignature(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSMethodSignature)
+  declare function isTSIndexSignature(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSIndexSignature)
+  declare function isTSAnyKeyword(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSAnyKeyword)
+  declare function isTSNumberKeyword(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSNumberKeyword)
+  declare function isTSObjectKeyword(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSObjectKeyword)
+  declare function isTSBooleanKeyword(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSBooleanKeyword)
+  declare function isTSStringKeyword(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSStringKeyword)
+  declare function isTSSymbolKeyword(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSSymbolKeyword)
+  declare function isTSVoidKeyword(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSVoidKeyword)
+  declare function isTSUndefinedKeyword(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSUndefinedKeyword)
+  declare function isTSNullKeyword(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSNullKeyword)
+  declare function isTSNeverKeyword(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSNeverKeyword)
+  declare function isTSThisType(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSThisType)
+  declare function isTSFunctionType(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSFunctionType)
+  declare function isTSConstructorType(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSConstructorType)
+  declare function isTSTypeReference(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeReference)
+  declare function isTSTypePredicate(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypePredicate)
+  declare function isTSTypeQuery(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeQuery)
+  declare function isTSTypeLiteral(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeLiteral)
+  declare function isTSArrayType(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSArrayType)
+  declare function isTSTupleType(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTupleType)
+  declare function isTSUnionType(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSUnionType)
+  declare function isTSIntersectionType(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSIntersectionType)
+  declare function isTSConditionalType(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSConditionalType)
+  declare function isTSInferType(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSInferType)
+  declare function isTSParenthesizedType(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSParenthesizedType)
+  declare function isTSTypeOperator(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeOperator)
+  declare function isTSIndexedAccessType(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSIndexedAccessType)
+  declare function isTSMappedType(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSMappedType)
+  declare function isTSLiteralType(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSLiteralType)
+  declare function isTSExpressionWithTypeArguments(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSExpressionWithTypeArguments)
+  declare function isTSInterfaceDeclaration(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSInterfaceDeclaration)
+  declare function isTSInterfaceBody(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSInterfaceBody)
+  declare function isTSTypeAliasDeclaration(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeAliasDeclaration)
+  declare function isTSAsExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSAsExpression)
+  declare function isTSTypeAssertion(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeAssertion)
+  declare function isTSEnumDeclaration(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSEnumDeclaration)
+  declare function isTSEnumMember(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSEnumMember)
+  declare function isTSModuleDeclaration(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSModuleDeclaration)
+  declare function isTSModuleBlock(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSModuleBlock)
+  declare function isTSImportEqualsDeclaration(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSImportEqualsDeclaration)
+  declare function isTSExternalModuleReference(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSExternalModuleReference)
+  declare function isTSNonNullExpression(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSNonNullExpression)
+  declare function isTSExportAssignment(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSExportAssignment)
+  declare function isTSNamespaceExportDeclaration(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSNamespaceExportDeclaration)
+  declare function isTSTypeAnnotation(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeAnnotation)
+  declare function isTSTypeParameterInstantiation(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeParameterInstantiation)
+  declare function isTSTypeParameterDeclaration(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeParameterDeclaration)
+  declare function isTSTypeParameter(node: Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeParameter)
+  declare function isExpression(node: Object, opts?: ?Object): boolean
+  declare function isBinary(node: Object, opts?: ?Object): boolean
+  declare function isScopable(node: Object, opts?: ?Object): boolean
+  declare function isBlockParent(node: Object, opts?: ?Object): boolean
+  declare function isBlock(node: Object, opts?: ?Object): boolean
+  declare function isStatement(node: Object, opts?: ?Object): boolean
+  declare function isTerminatorless(node: Object, opts?: ?Object): boolean
+  declare function isCompletionStatement(node: Object, opts?: ?Object): boolean
+  declare function isConditional(node: Object, opts?: ?Object): boolean
+  declare function isLoop(node: Object, opts?: ?Object): boolean
+  declare function isWhile(node: Object, opts?: ?Object): boolean
+  declare function isExpressionWrapper(node: Object, opts?: ?Object): boolean
+  declare function isFor(node: Object, opts?: ?Object): boolean
+  declare function isForXStatement(node: Object, opts?: ?Object): boolean
+  declare function isFunction(node: Object, opts?: ?Object): boolean
+  declare function isFunctionParent(node: Object, opts?: ?Object): boolean
+  declare function isPureish(node: Object, opts?: ?Object): boolean
+  declare function isDeclaration(node: Object, opts?: ?Object): boolean
+  declare function isPatternLike(node: Object, opts?: ?Object): boolean
+  declare function isLVal(node: Object, opts?: ?Object): boolean
+  declare function isTSEntityName(node: Object, opts?: ?Object): boolean
+  declare function isLiteral(node: Object, opts?: ?Object): boolean
+  declare function isImmutable(node: Object, opts?: ?Object): boolean
+  declare function isUserWhitespacable(node: Object, opts?: ?Object): boolean
+  declare function isMethod(node: Object, opts?: ?Object): boolean
+  declare function isObjectMember(node: Object, opts?: ?Object): boolean
+  declare function isProperty(node: Object, opts?: ?Object): boolean
+  declare function isUnaryLike(node: Object, opts?: ?Object): boolean
+  declare function isPattern(node: Object, opts?: ?Object): boolean
+  declare function isClass(node: Object, opts?: ?Object): boolean
+  declare function isModuleDeclaration(node: Object, opts?: ?Object): boolean
+  declare function isExportDeclaration(node: Object, opts?: ?Object): boolean
+  declare function isModuleSpecifier(node: Object, opts?: ?Object): boolean
+  declare function isFlow(node: Object, opts?: ?Object): boolean
+  declare function isFlowType(node: Object, opts?: ?Object): boolean
+  declare function isFlowBaseAnnotation(node: Object, opts?: ?Object): boolean
+  declare function isFlowDeclaration(node: Object, opts?: ?Object): boolean
+  declare function isFlowPredicate(node: Object, opts?: ?Object): boolean
+  declare function isJSX(node: Object, opts?: ?Object): boolean
+  declare function isPrivate(node: Object, opts?: ?Object): boolean
+  declare function isTSTypeElement(node: Object, opts?: ?Object): boolean
+  declare function isTSType(node: Object, opts?: ?Object): boolean
+  declare function isNumberLiteral(node: Object, opts?: ?Object): boolean
+  declare function isRegexLiteral(node: Object, opts?: ?Object): boolean
+  declare function isRestProperty(node: Object, opts?: ?Object): boolean
+  declare function isSpreadProperty(node: Object, opts?: ?Object): boolean
+  declare function validate(n: BabelNode, key: string, value: mixed): void;
+  declare function clone<T>(n: T): T;
+  declare function cloneDeep<T>(n: T): T;
+  declare function removeProperties<T>(n: T, opts: ?{}): void;
+  declare function removePropertiesDeep<T>(n: T, opts: ?{}): T;
+  declare type TraversalAncestors = Array<{
+    node: BabelNode,
+    key: string,
+    index?: number,
+  }>;
+  declare type TraversalHandler<T> = (BabelNode, TraversalAncestors, T) => void;
+  declare type TraversalHandlers<T> = {
+    enter?: TraversalHandler<T>,
+    exit?: TraversalHandler<T>,
+  };
+  declare function traverse<T>(n: BabelNode, TraversalHandler<T> | TraversalHandlers<T>, state?: T): void;
+}
diff --git a/node_modules/@babel/types/lib/modifications/appendToMemberExpression.js b/node_modules/@babel/types/lib/modifications/appendToMemberExpression.js
new file mode 100644
index 00000000..6a0ac93c
--- /dev/null
+++ b/node_modules/@babel/types/lib/modifications/appendToMemberExpression.js
@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = appendToMemberExpression;
+
+var _generated = require("../builders/generated");
+
+function appendToMemberExpression(member, append, computed = false) {
+  member.object = (0, _generated.memberExpression)(member.object, member.property, member.computed);
+  member.property = append;
+  member.computed = !!computed;
+  return member;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js b/node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js
new file mode 100644
index 00000000..089179e2
--- /dev/null
+++ b/node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js
@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = removeTypeDuplicates;
+
+var _generated = require("../../validators/generated");
+
+function removeTypeDuplicates(nodes) {
+  const generics = {};
+  const bases = {};
+  const typeGroups = [];
+  const types = [];
+
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    if (!node) continue;
+
+    if (types.indexOf(node) >= 0) {
+      continue;
+    }
+
+    if ((0, _generated.isAnyTypeAnnotation)(node)) {
+      return [node];
+    }
+
+    if ((0, _generated.isFlowBaseAnnotation)(node)) {
+      bases[node.type] = node;
+      continue;
+    }
+
+    if ((0, _generated.isUnionTypeAnnotation)(node)) {
+      if (typeGroups.indexOf(node.types) < 0) {
+        nodes = nodes.concat(node.types);
+        typeGroups.push(node.types);
+      }
+
+      continue;
+    }
+
+    if ((0, _generated.isGenericTypeAnnotation)(node)) {
+      const name = node.id.name;
+
+      if (generics[name]) {
+        let existing = generics[name];
+
+        if (existing.typeParameters) {
+          if (node.typeParameters) {
+            existing.typeParameters.params = removeTypeDuplicates(existing.typeParameters.params.concat(node.typeParameters.params));
+          }
+        } else {
+          existing = node.typeParameters;
+        }
+      } else {
+        generics[name] = node;
+      }
+
+      continue;
+    }
+
+    types.push(node);
+  }
+
+  for (const type in bases) {
+    types.push(bases[type]);
+  }
+
+  for (const name in generics) {
+    types.push(generics[name]);
+  }
+
+  return types;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/modifications/inherits.js b/node_modules/@babel/types/lib/modifications/inherits.js
new file mode 100644
index 00000000..e406a1af
--- /dev/null
+++ b/node_modules/@babel/types/lib/modifications/inherits.js
@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = inherits;
+
+var _constants = require("../constants");
+
+var _inheritsComments = _interopRequireDefault(require("../comments/inheritsComments"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function inherits(child, parent) {
+  if (!child || !parent) return child;
+  var _arr = _constants.INHERIT_KEYS.optional;
+
+  for (var _i = 0; _i < _arr.length; _i++) {
+    const key = _arr[_i];
+
+    if (child[key] == null) {
+      child[key] = parent[key];
+    }
+  }
+
+  for (const key in parent) {
+    if (key[0] === "_" && key !== "__clone") child[key] = parent[key];
+  }
+
+  var _arr2 = _constants.INHERIT_KEYS.force;
+
+  for (var _i2 = 0; _i2 < _arr2.length; _i2++) {
+    const key = _arr2[_i2];
+    child[key] = parent[key];
+  }
+
+  (0, _inheritsComments.default)(child, parent);
+  return child;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/modifications/prependToMemberExpression.js b/node_modules/@babel/types/lib/modifications/prependToMemberExpression.js
new file mode 100644
index 00000000..ee6de0ec
--- /dev/null
+++ b/node_modules/@babel/types/lib/modifications/prependToMemberExpression.js
@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = prependToMemberExpression;
+
+var _generated = require("../builders/generated");
+
+function prependToMemberExpression(member, prepend) {
+  member.object = (0, _generated.memberExpression)(prepend, member.object);
+  return member;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/modifications/removeProperties.js b/node_modules/@babel/types/lib/modifications/removeProperties.js
new file mode 100644
index 00000000..ac22480b
--- /dev/null
+++ b/node_modules/@babel/types/lib/modifications/removeProperties.js
@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = removeProperties;
+
+var _constants = require("../constants");
+
+const CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"];
+
+const CLEAR_KEYS_PLUS_COMMENTS = _constants.COMMENT_KEYS.concat(["comments"]).concat(CLEAR_KEYS);
+
+function removeProperties(node, opts = {}) {
+  const map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS;
+
+  for (var _iterator = map, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref;
+
+    if (_isArray) {
+      if (_i >= _iterator.length) break;
+      _ref = _iterator[_i++];
+    } else {
+      _i = _iterator.next();
+      if (_i.done) break;
+      _ref = _i.value;
+    }
+
+    const key = _ref;
+    if (node[key] != null) node[key] = undefined;
+  }
+
+  for (const key in node) {
+    if (key[0] === "_" && node[key] != null) node[key] = undefined;
+  }
+
+  const symbols = Object.getOwnPropertySymbols(node);
+
+  for (var _iterator2 = symbols, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+    var _ref2;
+
+    if (_isArray2) {
+      if (_i2 >= _iterator2.length) break;
+      _ref2 = _iterator2[_i2++];
+    } else {
+      _i2 = _iterator2.next();
+      if (_i2.done) break;
+      _ref2 = _i2.value;
+    }
+
+    const sym = _ref2;
+    node[sym] = null;
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/modifications/removePropertiesDeep.js b/node_modules/@babel/types/lib/modifications/removePropertiesDeep.js
new file mode 100644
index 00000000..d11a84a8
--- /dev/null
+++ b/node_modules/@babel/types/lib/modifications/removePropertiesDeep.js
@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = removePropertiesDeep;
+
+var _traverseFast = _interopRequireDefault(require("../traverse/traverseFast"));
+
+var _removeProperties = _interopRequireDefault(require("./removeProperties"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function removePropertiesDeep(tree, opts) {
+  (0, _traverseFast.default)(tree, _removeProperties.default, opts);
+  return tree;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/retrievers/getBindingIdentifiers.js b/node_modules/@babel/types/lib/retrievers/getBindingIdentifiers.js
new file mode 100644
index 00000000..cbba3634
--- /dev/null
+++ b/node_modules/@babel/types/lib/retrievers/getBindingIdentifiers.js
@@ -0,0 +1,100 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getBindingIdentifiers;
+
+var _generated = require("../validators/generated");
+
+function getBindingIdentifiers(node, duplicates, outerOnly) {
+  let search = [].concat(node);
+  const ids = Object.create(null);
+
+  while (search.length) {
+    const id = search.shift();
+    if (!id) continue;
+    const keys = getBindingIdentifiers.keys[id.type];
+
+    if ((0, _generated.isIdentifier)(id)) {
+      if (duplicates) {
+        const _ids = ids[id.name] = ids[id.name] || [];
+
+        _ids.push(id);
+      } else {
+        ids[id.name] = id;
+      }
+
+      continue;
+    }
+
+    if ((0, _generated.isExportDeclaration)(id)) {
+      if ((0, _generated.isDeclaration)(id.declaration)) {
+        search.push(id.declaration);
+      }
+
+      continue;
+    }
+
+    if (outerOnly) {
+      if ((0, _generated.isFunctionDeclaration)(id)) {
+        search.push(id.id);
+        continue;
+      }
+
+      if ((0, _generated.isFunctionExpression)(id)) {
+        continue;
+      }
+    }
+
+    if (keys) {
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+
+        if (id[key]) {
+          search = search.concat(id[key]);
+        }
+      }
+    }
+  }
+
+  return ids;
+}
+
+getBindingIdentifiers.keys = {
+  DeclareClass: ["id"],
+  DeclareFunction: ["id"],
+  DeclareModule: ["id"],
+  DeclareVariable: ["id"],
+  InterfaceDeclaration: ["id"],
+  TypeAlias: ["id"],
+  OpaqueType: ["id"],
+  CatchClause: ["param"],
+  LabeledStatement: ["label"],
+  UnaryExpression: ["argument"],
+  AssignmentExpression: ["left"],
+  ImportSpecifier: ["local"],
+  ImportNamespaceSpecifier: ["local"],
+  ImportDefaultSpecifier: ["local"],
+  ImportDeclaration: ["specifiers"],
+  ExportSpecifier: ["exported"],
+  ExportNamespaceSpecifier: ["exported"],
+  ExportDefaultSpecifier: ["exported"],
+  FunctionDeclaration: ["id", "params"],
+  FunctionExpression: ["id", "params"],
+  ArrowFunctionExpression: ["params"],
+  ObjectMethod: ["params"],
+  ClassMethod: ["params"],
+  ForInStatement: ["left"],
+  ForOfStatement: ["left"],
+  ClassDeclaration: ["id"],
+  ClassExpression: ["id"],
+  RestElement: ["argument"],
+  UpdateExpression: ["argument"],
+  ObjectProperty: ["value"],
+  AssignmentPattern: ["left"],
+  ArrayPattern: ["elements"],
+  ObjectPattern: ["properties"],
+  VariableDeclaration: ["declarations"],
+  VariableDeclarator: ["id"]
+};
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/retrievers/getOuterBindingIdentifiers.js b/node_modules/@babel/types/lib/retrievers/getOuterBindingIdentifiers.js
new file mode 100644
index 00000000..8e1e3cb2
--- /dev/null
+++ b/node_modules/@babel/types/lib/retrievers/getOuterBindingIdentifiers.js
@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getOuterBindingIdentifiers;
+
+var _getBindingIdentifiers = _interopRequireDefault(require("./getBindingIdentifiers"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function getOuterBindingIdentifiers(node, duplicates) {
+  return (0, _getBindingIdentifiers.default)(node, duplicates, true);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/traverse/traverse.js b/node_modules/@babel/types/lib/traverse/traverse.js
new file mode 100644
index 00000000..0df36ca5
--- /dev/null
+++ b/node_modules/@babel/types/lib/traverse/traverse.js
@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = traverse;
+
+var _definitions = require("../definitions");
+
+function traverse(node, handlers, state) {
+  if (typeof handlers === "function") {
+    handlers = {
+      enter: handlers
+    };
+  }
+
+  const _ref = handlers,
+        enter = _ref.enter,
+        exit = _ref.exit;
+  traverseSimpleImpl(node, enter, exit, state, []);
+}
+
+function traverseSimpleImpl(node, enter, exit, state, ancestors) {
+  const keys = _definitions.VISITOR_KEYS[node.type];
+  if (!keys) return;
+  if (enter) enter(node, ancestors, state);
+
+  for (var _iterator = keys, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref2;
+
+    if (_isArray) {
+      if (_i >= _iterator.length) break;
+      _ref2 = _iterator[_i++];
+    } else {
+      _i = _iterator.next();
+      if (_i.done) break;
+      _ref2 = _i.value;
+    }
+
+    const key = _ref2;
+    const subNode = node[key];
+
+    if (Array.isArray(subNode)) {
+      for (let i = 0; i < subNode.length; i++) {
+        const child = subNode[i];
+        if (!child) continue;
+        ancestors.push({
+          node,
+          key,
+          index: i
+        });
+        traverseSimpleImpl(child, enter, exit, state, ancestors);
+        ancestors.pop();
+      }
+    } else if (subNode) {
+      ancestors.push({
+        node,
+        key
+      });
+      traverseSimpleImpl(subNode, enter, exit, state, ancestors);
+      ancestors.pop();
+    }
+  }
+
+  if (exit) exit(node, ancestors, state);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/traverse/traverseFast.js b/node_modules/@babel/types/lib/traverse/traverseFast.js
new file mode 100644
index 00000000..35deadfc
--- /dev/null
+++ b/node_modules/@babel/types/lib/traverse/traverseFast.js
@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = traverseFast;
+
+var _definitions = require("../definitions");
+
+function traverseFast(node, enter, opts) {
+  if (!node) return;
+  const keys = _definitions.VISITOR_KEYS[node.type];
+  if (!keys) return;
+  opts = opts || {};
+  enter(node, opts);
+
+  for (var _iterator = keys, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref;
+
+    if (_isArray) {
+      if (_i >= _iterator.length) break;
+      _ref = _iterator[_i++];
+    } else {
+      _i = _iterator.next();
+      if (_i.done) break;
+      _ref = _i.value;
+    }
+
+    const key = _ref;
+    const subNode = node[key];
+
+    if (Array.isArray(subNode)) {
+      for (var _iterator2 = subNode, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+        var _ref2;
+
+        if (_isArray2) {
+          if (_i2 >= _iterator2.length) break;
+          _ref2 = _iterator2[_i2++];
+        } else {
+          _i2 = _iterator2.next();
+          if (_i2.done) break;
+          _ref2 = _i2.value;
+        }
+
+        const node = _ref2;
+        traverseFast(node, enter, opts);
+      }
+    } else {
+      traverseFast(subNode, enter, opts);
+    }
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/utils/inherit.js b/node_modules/@babel/types/lib/utils/inherit.js
new file mode 100644
index 00000000..20568946
--- /dev/null
+++ b/node_modules/@babel/types/lib/utils/inherit.js
@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = inherit;
+
+function _uniq() {
+  const data = _interopRequireDefault(require("lodash/uniq"));
+
+  _uniq = function _uniq() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function inherit(key, child, parent) {
+  if (child && parent) {
+    child[key] = (0, _uniq().default)([].concat(child[key], parent[key]).filter(Boolean));
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/utils/react/cleanJSXElementLiteralChild.js b/node_modules/@babel/types/lib/utils/react/cleanJSXElementLiteralChild.js
new file mode 100644
index 00000000..f0ca1336
--- /dev/null
+++ b/node_modules/@babel/types/lib/utils/react/cleanJSXElementLiteralChild.js
@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = cleanJSXElementLiteralChild;
+
+var _generated = require("../../builders/generated");
+
+function cleanJSXElementLiteralChild(child, args) {
+  const lines = child.value.split(/\r\n|\n|\r/);
+  let lastNonEmptyLine = 0;
+
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].match(/[^ \t]/)) {
+      lastNonEmptyLine = i;
+    }
+  }
+
+  let str = "";
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const isFirstLine = i === 0;
+    const isLastLine = i === lines.length - 1;
+    const isLastNonEmptyLine = i === lastNonEmptyLine;
+    let trimmedLine = line.replace(/\t/g, " ");
+
+    if (!isFirstLine) {
+      trimmedLine = trimmedLine.replace(/^[ ]+/, "");
+    }
+
+    if (!isLastLine) {
+      trimmedLine = trimmedLine.replace(/[ ]+$/, "");
+    }
+
+    if (trimmedLine) {
+      if (!isLastNonEmptyLine) {
+        trimmedLine += " ";
+      }
+
+      str += trimmedLine;
+    }
+  }
+
+  if (str) args.push((0, _generated.stringLiteral)(str));
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/utils/shallowEqual.js b/node_modules/@babel/types/lib/utils/shallowEqual.js
new file mode 100644
index 00000000..d35bd0c7
--- /dev/null
+++ b/node_modules/@babel/types/lib/utils/shallowEqual.js
@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = shallowEqual;
+
+function shallowEqual(actual, expected) {
+  const keys = Object.keys(expected);
+  var _arr = keys;
+
+  for (var _i = 0; _i < _arr.length; _i++) {
+    const key = _arr[_i];
+
+    if (actual[key] !== expected[key]) {
+      return false;
+    }
+  }
+
+  return true;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/validators/buildMatchMemberExpression.js b/node_modules/@babel/types/lib/validators/buildMatchMemberExpression.js
new file mode 100644
index 00000000..0faa29c5
--- /dev/null
+++ b/node_modules/@babel/types/lib/validators/buildMatchMemberExpression.js
@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = buildMatchMemberExpression;
+
+var _matchesPattern = _interopRequireDefault(require("./matchesPattern"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function buildMatchMemberExpression(match, allowPartial) {
+  const parts = match.split(".");
+  return member => (0, _matchesPattern.default)(member, parts, allowPartial);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/validators/generated/index.js b/node_modules/@babel/types/lib/validators/generated/index.js
new file mode 100644
index 00000000..a398dfa4
--- /dev/null
+++ b/node_modules/@babel/types/lib/validators/generated/index.js
@@ -0,0 +1,4093 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isArrayExpression = isArrayExpression;
+exports.isAssignmentExpression = isAssignmentExpression;
+exports.isBinaryExpression = isBinaryExpression;
+exports.isDirective = isDirective;
+exports.isDirectiveLiteral = isDirectiveLiteral;
+exports.isBlockStatement = isBlockStatement;
+exports.isBreakStatement = isBreakStatement;
+exports.isCallExpression = isCallExpression;
+exports.isCatchClause = isCatchClause;
+exports.isConditionalExpression = isConditionalExpression;
+exports.isContinueStatement = isContinueStatement;
+exports.isDebuggerStatement = isDebuggerStatement;
+exports.isDoWhileStatement = isDoWhileStatement;
+exports.isEmptyStatement = isEmptyStatement;
+exports.isExpressionStatement = isExpressionStatement;
+exports.isFile = isFile;
+exports.isForInStatement = isForInStatement;
+exports.isForStatement = isForStatement;
+exports.isFunctionDeclaration = isFunctionDeclaration;
+exports.isFunctionExpression = isFunctionExpression;
+exports.isIdentifier = isIdentifier;
+exports.isIfStatement = isIfStatement;
+exports.isLabeledStatement = isLabeledStatement;
+exports.isStringLiteral = isStringLiteral;
+exports.isNumericLiteral = isNumericLiteral;
+exports.isNullLiteral = isNullLiteral;
+exports.isBooleanLiteral = isBooleanLiteral;
+exports.isRegExpLiteral = isRegExpLiteral;
+exports.isLogicalExpression = isLogicalExpression;
+exports.isMemberExpression = isMemberExpression;
+exports.isNewExpression = isNewExpression;
+exports.isProgram = isProgram;
+exports.isObjectExpression = isObjectExpression;
+exports.isObjectMethod = isObjectMethod;
+exports.isObjectProperty = isObjectProperty;
+exports.isRestElement = isRestElement;
+exports.isReturnStatement = isReturnStatement;
+exports.isSequenceExpression = isSequenceExpression;
+exports.isSwitchCase = isSwitchCase;
+exports.isSwitchStatement = isSwitchStatement;
+exports.isThisExpression = isThisExpression;
+exports.isThrowStatement = isThrowStatement;
+exports.isTryStatement = isTryStatement;
+exports.isUnaryExpression = isUnaryExpression;
+exports.isUpdateExpression = isUpdateExpression;
+exports.isVariableDeclaration = isVariableDeclaration;
+exports.isVariableDeclarator = isVariableDeclarator;
+exports.isWhileStatement = isWhileStatement;
+exports.isWithStatement = isWithStatement;
+exports.isAssignmentPattern = isAssignmentPattern;
+exports.isArrayPattern = isArrayPattern;
+exports.isArrowFunctionExpression = isArrowFunctionExpression;
+exports.isClassBody = isClassBody;
+exports.isClassDeclaration = isClassDeclaration;
+exports.isClassExpression = isClassExpression;
+exports.isExportAllDeclaration = isExportAllDeclaration;
+exports.isExportDefaultDeclaration = isExportDefaultDeclaration;
+exports.isExportNamedDeclaration = isExportNamedDeclaration;
+exports.isExportSpecifier = isExportSpecifier;
+exports.isForOfStatement = isForOfStatement;
+exports.isImportDeclaration = isImportDeclaration;
+exports.isImportDefaultSpecifier = isImportDefaultSpecifier;
+exports.isImportNamespaceSpecifier = isImportNamespaceSpecifier;
+exports.isImportSpecifier = isImportSpecifier;
+exports.isMetaProperty = isMetaProperty;
+exports.isClassMethod = isClassMethod;
+exports.isObjectPattern = isObjectPattern;
+exports.isSpreadElement = isSpreadElement;
+exports.isSuper = isSuper;
+exports.isTaggedTemplateExpression = isTaggedTemplateExpression;
+exports.isTemplateElement = isTemplateElement;
+exports.isTemplateLiteral = isTemplateLiteral;
+exports.isYieldExpression = isYieldExpression;
+exports.isAnyTypeAnnotation = isAnyTypeAnnotation;
+exports.isArrayTypeAnnotation = isArrayTypeAnnotation;
+exports.isBooleanTypeAnnotation = isBooleanTypeAnnotation;
+exports.isBooleanLiteralTypeAnnotation = isBooleanLiteralTypeAnnotation;
+exports.isNullLiteralTypeAnnotation = isNullLiteralTypeAnnotation;
+exports.isClassImplements = isClassImplements;
+exports.isDeclareClass = isDeclareClass;
+exports.isDeclareFunction = isDeclareFunction;
+exports.isDeclareInterface = isDeclareInterface;
+exports.isDeclareModule = isDeclareModule;
+exports.isDeclareModuleExports = isDeclareModuleExports;
+exports.isDeclareTypeAlias = isDeclareTypeAlias;
+exports.isDeclareOpaqueType = isDeclareOpaqueType;
+exports.isDeclareVariable = isDeclareVariable;
+exports.isDeclareExportDeclaration = isDeclareExportDeclaration;
+exports.isDeclareExportAllDeclaration = isDeclareExportAllDeclaration;
+exports.isDeclaredPredicate = isDeclaredPredicate;
+exports.isExistsTypeAnnotation = isExistsTypeAnnotation;
+exports.isFunctionTypeAnnotation = isFunctionTypeAnnotation;
+exports.isFunctionTypeParam = isFunctionTypeParam;
+exports.isGenericTypeAnnotation = isGenericTypeAnnotation;
+exports.isInferredPredicate = isInferredPredicate;
+exports.isInterfaceExtends = isInterfaceExtends;
+exports.isInterfaceDeclaration = isInterfaceDeclaration;
+exports.isIntersectionTypeAnnotation = isIntersectionTypeAnnotation;
+exports.isMixedTypeAnnotation = isMixedTypeAnnotation;
+exports.isEmptyTypeAnnotation = isEmptyTypeAnnotation;
+exports.isNullableTypeAnnotation = isNullableTypeAnnotation;
+exports.isNumberLiteralTypeAnnotation = isNumberLiteralTypeAnnotation;
+exports.isNumberTypeAnnotation = isNumberTypeAnnotation;
+exports.isObjectTypeAnnotation = isObjectTypeAnnotation;
+exports.isObjectTypeCallProperty = isObjectTypeCallProperty;
+exports.isObjectTypeIndexer = isObjectTypeIndexer;
+exports.isObjectTypeProperty = isObjectTypeProperty;
+exports.isObjectTypeSpreadProperty = isObjectTypeSpreadProperty;
+exports.isOpaqueType = isOpaqueType;
+exports.isQualifiedTypeIdentifier = isQualifiedTypeIdentifier;
+exports.isStringLiteralTypeAnnotation = isStringLiteralTypeAnnotation;
+exports.isStringTypeAnnotation = isStringTypeAnnotation;
+exports.isThisTypeAnnotation = isThisTypeAnnotation;
+exports.isTupleTypeAnnotation = isTupleTypeAnnotation;
+exports.isTypeofTypeAnnotation = isTypeofTypeAnnotation;
+exports.isTypeAlias = isTypeAlias;
+exports.isTypeAnnotation = isTypeAnnotation;
+exports.isTypeCastExpression = isTypeCastExpression;
+exports.isTypeParameter = isTypeParameter;
+exports.isTypeParameterDeclaration = isTypeParameterDeclaration;
+exports.isTypeParameterInstantiation = isTypeParameterInstantiation;
+exports.isUnionTypeAnnotation = isUnionTypeAnnotation;
+exports.isVariance = isVariance;
+exports.isVoidTypeAnnotation = isVoidTypeAnnotation;
+exports.isJSXAttribute = isJSXAttribute;
+exports.isJSXClosingElement = isJSXClosingElement;
+exports.isJSXElement = isJSXElement;
+exports.isJSXEmptyExpression = isJSXEmptyExpression;
+exports.isJSXExpressionContainer = isJSXExpressionContainer;
+exports.isJSXSpreadChild = isJSXSpreadChild;
+exports.isJSXIdentifier = isJSXIdentifier;
+exports.isJSXMemberExpression = isJSXMemberExpression;
+exports.isJSXNamespacedName = isJSXNamespacedName;
+exports.isJSXOpeningElement = isJSXOpeningElement;
+exports.isJSXSpreadAttribute = isJSXSpreadAttribute;
+exports.isJSXText = isJSXText;
+exports.isJSXFragment = isJSXFragment;
+exports.isJSXOpeningFragment = isJSXOpeningFragment;
+exports.isJSXClosingFragment = isJSXClosingFragment;
+exports.isNoop = isNoop;
+exports.isParenthesizedExpression = isParenthesizedExpression;
+exports.isAwaitExpression = isAwaitExpression;
+exports.isBindExpression = isBindExpression;
+exports.isClassProperty = isClassProperty;
+exports.isOptionalMemberExpression = isOptionalMemberExpression;
+exports.isOptionalCallExpression = isOptionalCallExpression;
+exports.isClassPrivateProperty = isClassPrivateProperty;
+exports.isImport = isImport;
+exports.isDecorator = isDecorator;
+exports.isDoExpression = isDoExpression;
+exports.isExportDefaultSpecifier = isExportDefaultSpecifier;
+exports.isExportNamespaceSpecifier = isExportNamespaceSpecifier;
+exports.isPrivateName = isPrivateName;
+exports.isTSParameterProperty = isTSParameterProperty;
+exports.isTSDeclareFunction = isTSDeclareFunction;
+exports.isTSDeclareMethod = isTSDeclareMethod;
+exports.isTSQualifiedName = isTSQualifiedName;
+exports.isTSCallSignatureDeclaration = isTSCallSignatureDeclaration;
+exports.isTSConstructSignatureDeclaration = isTSConstructSignatureDeclaration;
+exports.isTSPropertySignature = isTSPropertySignature;
+exports.isTSMethodSignature = isTSMethodSignature;
+exports.isTSIndexSignature = isTSIndexSignature;
+exports.isTSAnyKeyword = isTSAnyKeyword;
+exports.isTSNumberKeyword = isTSNumberKeyword;
+exports.isTSObjectKeyword = isTSObjectKeyword;
+exports.isTSBooleanKeyword = isTSBooleanKeyword;
+exports.isTSStringKeyword = isTSStringKeyword;
+exports.isTSSymbolKeyword = isTSSymbolKeyword;
+exports.isTSVoidKeyword = isTSVoidKeyword;
+exports.isTSUndefinedKeyword = isTSUndefinedKeyword;
+exports.isTSNullKeyword = isTSNullKeyword;
+exports.isTSNeverKeyword = isTSNeverKeyword;
+exports.isTSThisType = isTSThisType;
+exports.isTSFunctionType = isTSFunctionType;
+exports.isTSConstructorType = isTSConstructorType;
+exports.isTSTypeReference = isTSTypeReference;
+exports.isTSTypePredicate = isTSTypePredicate;
+exports.isTSTypeQuery = isTSTypeQuery;
+exports.isTSTypeLiteral = isTSTypeLiteral;
+exports.isTSArrayType = isTSArrayType;
+exports.isTSTupleType = isTSTupleType;
+exports.isTSUnionType = isTSUnionType;
+exports.isTSIntersectionType = isTSIntersectionType;
+exports.isTSConditionalType = isTSConditionalType;
+exports.isTSInferType = isTSInferType;
+exports.isTSParenthesizedType = isTSParenthesizedType;
+exports.isTSTypeOperator = isTSTypeOperator;
+exports.isTSIndexedAccessType = isTSIndexedAccessType;
+exports.isTSMappedType = isTSMappedType;
+exports.isTSLiteralType = isTSLiteralType;
+exports.isTSExpressionWithTypeArguments = isTSExpressionWithTypeArguments;
+exports.isTSInterfaceDeclaration = isTSInterfaceDeclaration;
+exports.isTSInterfaceBody = isTSInterfaceBody;
+exports.isTSTypeAliasDeclaration = isTSTypeAliasDeclaration;
+exports.isTSAsExpression = isTSAsExpression;
+exports.isTSTypeAssertion = isTSTypeAssertion;
+exports.isTSEnumDeclaration = isTSEnumDeclaration;
+exports.isTSEnumMember = isTSEnumMember;
+exports.isTSModuleDeclaration = isTSModuleDeclaration;
+exports.isTSModuleBlock = isTSModuleBlock;
+exports.isTSImportEqualsDeclaration = isTSImportEqualsDeclaration;
+exports.isTSExternalModuleReference = isTSExternalModuleReference;
+exports.isTSNonNullExpression = isTSNonNullExpression;
+exports.isTSExportAssignment = isTSExportAssignment;
+exports.isTSNamespaceExportDeclaration = isTSNamespaceExportDeclaration;
+exports.isTSTypeAnnotation = isTSTypeAnnotation;
+exports.isTSTypeParameterInstantiation = isTSTypeParameterInstantiation;
+exports.isTSTypeParameterDeclaration = isTSTypeParameterDeclaration;
+exports.isTSTypeParameter = isTSTypeParameter;
+exports.isExpression = isExpression;
+exports.isBinary = isBinary;
+exports.isScopable = isScopable;
+exports.isBlockParent = isBlockParent;
+exports.isBlock = isBlock;
+exports.isStatement = isStatement;
+exports.isTerminatorless = isTerminatorless;
+exports.isCompletionStatement = isCompletionStatement;
+exports.isConditional = isConditional;
+exports.isLoop = isLoop;
+exports.isWhile = isWhile;
+exports.isExpressionWrapper = isExpressionWrapper;
+exports.isFor = isFor;
+exports.isForXStatement = isForXStatement;
+exports.isFunction = isFunction;
+exports.isFunctionParent = isFunctionParent;
+exports.isPureish = isPureish;
+exports.isDeclaration = isDeclaration;
+exports.isPatternLike = isPatternLike;
+exports.isLVal = isLVal;
+exports.isTSEntityName = isTSEntityName;
+exports.isLiteral = isLiteral;
+exports.isImmutable = isImmutable;
+exports.isUserWhitespacable = isUserWhitespacable;
+exports.isMethod = isMethod;
+exports.isObjectMember = isObjectMember;
+exports.isProperty = isProperty;
+exports.isUnaryLike = isUnaryLike;
+exports.isPattern = isPattern;
+exports.isClass = isClass;
+exports.isModuleDeclaration = isModuleDeclaration;
+exports.isExportDeclaration = isExportDeclaration;
+exports.isModuleSpecifier = isModuleSpecifier;
+exports.isFlow = isFlow;
+exports.isFlowType = isFlowType;
+exports.isFlowBaseAnnotation = isFlowBaseAnnotation;
+exports.isFlowDeclaration = isFlowDeclaration;
+exports.isFlowPredicate = isFlowPredicate;
+exports.isJSX = isJSX;
+exports.isPrivate = isPrivate;
+exports.isTSTypeElement = isTSTypeElement;
+exports.isTSType = isTSType;
+exports.isNumberLiteral = isNumberLiteral;
+exports.isRegexLiteral = isRegexLiteral;
+exports.isRestProperty = isRestProperty;
+exports.isSpreadProperty = isSpreadProperty;
+
+var _shallowEqual = _interopRequireDefault(require("../../utils/shallowEqual"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function isArrayExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ArrayExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isAssignmentExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "AssignmentExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isBinaryExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "BinaryExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isDirective(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Directive") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isDirectiveLiteral(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "DirectiveLiteral") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isBlockStatement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "BlockStatement") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isBreakStatement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "BreakStatement") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isCallExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "CallExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isCatchClause(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "CatchClause") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isConditionalExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ConditionalExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isContinueStatement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ContinueStatement") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isDebuggerStatement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "DebuggerStatement") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isDoWhileStatement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "DoWhileStatement") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isEmptyStatement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "EmptyStatement") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isExpressionStatement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ExpressionStatement") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isFile(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "File") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isForInStatement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ForInStatement") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isForStatement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ForStatement") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isFunctionDeclaration(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "FunctionDeclaration") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isFunctionExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "FunctionExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isIdentifier(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Identifier") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isIfStatement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "IfStatement") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isLabeledStatement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "LabeledStatement") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isStringLiteral(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "StringLiteral") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isNumericLiteral(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "NumericLiteral") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isNullLiteral(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "NullLiteral") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isBooleanLiteral(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "BooleanLiteral") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isRegExpLiteral(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "RegExpLiteral") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isLogicalExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "LogicalExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isMemberExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "MemberExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isNewExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "NewExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isProgram(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Program") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isObjectExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ObjectExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isObjectMethod(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ObjectMethod") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isObjectProperty(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ObjectProperty") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isRestElement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "RestElement") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isReturnStatement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ReturnStatement") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isSequenceExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "SequenceExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isSwitchCase(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "SwitchCase") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isSwitchStatement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "SwitchStatement") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isThisExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ThisExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isThrowStatement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ThrowStatement") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTryStatement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TryStatement") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isUnaryExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "UnaryExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isUpdateExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "UpdateExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isVariableDeclaration(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "VariableDeclaration") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isVariableDeclarator(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "VariableDeclarator") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isWhileStatement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "WhileStatement") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isWithStatement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "WithStatement") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isAssignmentPattern(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "AssignmentPattern") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isArrayPattern(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ArrayPattern") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isArrowFunctionExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ArrowFunctionExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isClassBody(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ClassBody") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isClassDeclaration(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ClassDeclaration") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isClassExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ClassExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isExportAllDeclaration(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ExportAllDeclaration") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isExportDefaultDeclaration(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ExportDefaultDeclaration") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isExportNamedDeclaration(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ExportNamedDeclaration") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isExportSpecifier(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ExportSpecifier") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isForOfStatement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ForOfStatement") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isImportDeclaration(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ImportDeclaration") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isImportDefaultSpecifier(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ImportDefaultSpecifier") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isImportNamespaceSpecifier(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ImportNamespaceSpecifier") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isImportSpecifier(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ImportSpecifier") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isMetaProperty(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "MetaProperty") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isClassMethod(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ClassMethod") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isObjectPattern(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ObjectPattern") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isSpreadElement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "SpreadElement") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isSuper(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Super") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTaggedTemplateExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TaggedTemplateExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTemplateElement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TemplateElement") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTemplateLiteral(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TemplateLiteral") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isYieldExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "YieldExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isAnyTypeAnnotation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "AnyTypeAnnotation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isArrayTypeAnnotation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ArrayTypeAnnotation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isBooleanTypeAnnotation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "BooleanTypeAnnotation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isBooleanLiteralTypeAnnotation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "BooleanLiteralTypeAnnotation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isNullLiteralTypeAnnotation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "NullLiteralTypeAnnotation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isClassImplements(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ClassImplements") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isDeclareClass(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "DeclareClass") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isDeclareFunction(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "DeclareFunction") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isDeclareInterface(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "DeclareInterface") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isDeclareModule(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "DeclareModule") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isDeclareModuleExports(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "DeclareModuleExports") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isDeclareTypeAlias(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "DeclareTypeAlias") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isDeclareOpaqueType(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "DeclareOpaqueType") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isDeclareVariable(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "DeclareVariable") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isDeclareExportDeclaration(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "DeclareExportDeclaration") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isDeclareExportAllDeclaration(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "DeclareExportAllDeclaration") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isDeclaredPredicate(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "DeclaredPredicate") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isExistsTypeAnnotation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ExistsTypeAnnotation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isFunctionTypeAnnotation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "FunctionTypeAnnotation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isFunctionTypeParam(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "FunctionTypeParam") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isGenericTypeAnnotation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "GenericTypeAnnotation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isInferredPredicate(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "InferredPredicate") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isInterfaceExtends(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "InterfaceExtends") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isInterfaceDeclaration(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "InterfaceDeclaration") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isIntersectionTypeAnnotation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "IntersectionTypeAnnotation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isMixedTypeAnnotation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "MixedTypeAnnotation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isEmptyTypeAnnotation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "EmptyTypeAnnotation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isNullableTypeAnnotation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "NullableTypeAnnotation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isNumberLiteralTypeAnnotation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "NumberLiteralTypeAnnotation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isNumberTypeAnnotation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "NumberTypeAnnotation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isObjectTypeAnnotation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ObjectTypeAnnotation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isObjectTypeCallProperty(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ObjectTypeCallProperty") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isObjectTypeIndexer(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ObjectTypeIndexer") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isObjectTypeProperty(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ObjectTypeProperty") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isObjectTypeSpreadProperty(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ObjectTypeSpreadProperty") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isOpaqueType(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "OpaqueType") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isQualifiedTypeIdentifier(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "QualifiedTypeIdentifier") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isStringLiteralTypeAnnotation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "StringLiteralTypeAnnotation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isStringTypeAnnotation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "StringTypeAnnotation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isThisTypeAnnotation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ThisTypeAnnotation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTupleTypeAnnotation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TupleTypeAnnotation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTypeofTypeAnnotation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TypeofTypeAnnotation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTypeAlias(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TypeAlias") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTypeAnnotation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TypeAnnotation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTypeCastExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TypeCastExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTypeParameter(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TypeParameter") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTypeParameterDeclaration(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TypeParameterDeclaration") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTypeParameterInstantiation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TypeParameterInstantiation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isUnionTypeAnnotation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "UnionTypeAnnotation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isVariance(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Variance") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isVoidTypeAnnotation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "VoidTypeAnnotation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isJSXAttribute(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "JSXAttribute") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isJSXClosingElement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "JSXClosingElement") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isJSXElement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "JSXElement") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isJSXEmptyExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "JSXEmptyExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isJSXExpressionContainer(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "JSXExpressionContainer") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isJSXSpreadChild(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "JSXSpreadChild") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isJSXIdentifier(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "JSXIdentifier") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isJSXMemberExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "JSXMemberExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isJSXNamespacedName(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "JSXNamespacedName") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isJSXOpeningElement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "JSXOpeningElement") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isJSXSpreadAttribute(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "JSXSpreadAttribute") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isJSXText(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "JSXText") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isJSXFragment(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "JSXFragment") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isJSXOpeningFragment(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "JSXOpeningFragment") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isJSXClosingFragment(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "JSXClosingFragment") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isNoop(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Noop") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isParenthesizedExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ParenthesizedExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isAwaitExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "AwaitExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isBindExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "BindExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isClassProperty(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ClassProperty") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isOptionalMemberExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "OptionalMemberExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isOptionalCallExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "OptionalCallExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isClassPrivateProperty(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ClassPrivateProperty") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isImport(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Import") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isDecorator(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Decorator") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isDoExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "DoExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isExportDefaultSpecifier(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ExportDefaultSpecifier") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isExportNamespaceSpecifier(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ExportNamespaceSpecifier") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isPrivateName(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "PrivateName") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSParameterProperty(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSParameterProperty") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSDeclareFunction(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSDeclareFunction") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSDeclareMethod(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSDeclareMethod") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSQualifiedName(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSQualifiedName") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSCallSignatureDeclaration(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSCallSignatureDeclaration") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSConstructSignatureDeclaration(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSConstructSignatureDeclaration") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSPropertySignature(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSPropertySignature") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSMethodSignature(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSMethodSignature") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSIndexSignature(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSIndexSignature") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSAnyKeyword(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSAnyKeyword") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSNumberKeyword(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSNumberKeyword") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSObjectKeyword(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSObjectKeyword") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSBooleanKeyword(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSBooleanKeyword") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSStringKeyword(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSStringKeyword") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSSymbolKeyword(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSSymbolKeyword") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSVoidKeyword(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSVoidKeyword") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSUndefinedKeyword(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSUndefinedKeyword") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSNullKeyword(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSNullKeyword") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSNeverKeyword(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSNeverKeyword") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSThisType(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSThisType") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSFunctionType(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSFunctionType") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSConstructorType(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSConstructorType") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSTypeReference(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSTypeReference") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSTypePredicate(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSTypePredicate") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSTypeQuery(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSTypeQuery") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSTypeLiteral(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSTypeLiteral") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSArrayType(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSArrayType") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSTupleType(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSTupleType") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSUnionType(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSUnionType") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSIntersectionType(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSIntersectionType") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSConditionalType(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSConditionalType") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSInferType(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSInferType") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSParenthesizedType(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSParenthesizedType") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSTypeOperator(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSTypeOperator") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSIndexedAccessType(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSIndexedAccessType") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSMappedType(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSMappedType") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSLiteralType(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSLiteralType") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSExpressionWithTypeArguments(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSExpressionWithTypeArguments") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSInterfaceDeclaration(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSInterfaceDeclaration") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSInterfaceBody(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSInterfaceBody") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSTypeAliasDeclaration(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSTypeAliasDeclaration") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSAsExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSAsExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSTypeAssertion(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSTypeAssertion") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSEnumDeclaration(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSEnumDeclaration") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSEnumMember(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSEnumMember") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSModuleDeclaration(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSModuleDeclaration") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSModuleBlock(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSModuleBlock") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSImportEqualsDeclaration(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSImportEqualsDeclaration") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSExternalModuleReference(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSExternalModuleReference") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSNonNullExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSNonNullExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSExportAssignment(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSExportAssignment") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSNamespaceExportDeclaration(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSNamespaceExportDeclaration") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSTypeAnnotation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSTypeAnnotation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSTypeParameterInstantiation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSTypeParameterInstantiation") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSTypeParameterDeclaration(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSTypeParameterDeclaration") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSTypeParameter(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSTypeParameter") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isExpression(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Expression" || "ArrayExpression" === nodeType || "AssignmentExpression" === nodeType || "BinaryExpression" === nodeType || "CallExpression" === nodeType || "ConditionalExpression" === nodeType || "FunctionExpression" === nodeType || "Identifier" === nodeType || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "LogicalExpression" === nodeType || "MemberExpression" === nodeType || "NewExpression" === nodeType || "ObjectExpression" === nodeType || "SequenceExpression" === nodeType || "ThisExpression" === nodeType || "UnaryExpression" === nodeType || "UpdateExpression" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassExpression" === nodeType || "MetaProperty" === nodeType || "Super" === nodeType || "TaggedTemplateExpression" === nodeType || "TemplateLiteral" === nodeType || "YieldExpression" === nodeType || "TypeCastExpression" === nodeType || "JSXElement" === nodeType || "JSXFragment" === nodeType || "ParenthesizedExpression" === nodeType || "AwaitExpression" === nodeType || "BindExpression" === nodeType || "OptionalMemberExpression" === nodeType || "OptionalCallExpression" === nodeType || "Import" === nodeType || "DoExpression" === nodeType || "TSAsExpression" === nodeType || "TSTypeAssertion" === nodeType || "TSNonNullExpression" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isBinary(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Binary" || "BinaryExpression" === nodeType || "LogicalExpression" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isScopable(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Scopable" || "BlockStatement" === nodeType || "CatchClause" === nodeType || "DoWhileStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "Program" === nodeType || "ObjectMethod" === nodeType || "SwitchStatement" === nodeType || "WhileStatement" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassDeclaration" === nodeType || "ClassExpression" === nodeType || "ForOfStatement" === nodeType || "ClassMethod" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isBlockParent(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "BlockParent" || "BlockStatement" === nodeType || "CatchClause" === nodeType || "DoWhileStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "Program" === nodeType || "ObjectMethod" === nodeType || "SwitchStatement" === nodeType || "WhileStatement" === nodeType || "ArrowFunctionExpression" === nodeType || "ForOfStatement" === nodeType || "ClassMethod" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isBlock(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Block" || "BlockStatement" === nodeType || "Program" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isStatement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Statement" || "BlockStatement" === nodeType || "BreakStatement" === nodeType || "ContinueStatement" === nodeType || "DebuggerStatement" === nodeType || "DoWhileStatement" === nodeType || "EmptyStatement" === nodeType || "ExpressionStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "IfStatement" === nodeType || "LabeledStatement" === nodeType || "ReturnStatement" === nodeType || "SwitchStatement" === nodeType || "ThrowStatement" === nodeType || "TryStatement" === nodeType || "VariableDeclaration" === nodeType || "WhileStatement" === nodeType || "WithStatement" === nodeType || "ClassDeclaration" === nodeType || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ForOfStatement" === nodeType || "ImportDeclaration" === nodeType || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "InterfaceDeclaration" === nodeType || "OpaqueType" === nodeType || "TypeAlias" === nodeType || "TSDeclareFunction" === nodeType || "TSInterfaceDeclaration" === nodeType || "TSTypeAliasDeclaration" === nodeType || "TSEnumDeclaration" === nodeType || "TSModuleDeclaration" === nodeType || "TSImportEqualsDeclaration" === nodeType || "TSExportAssignment" === nodeType || "TSNamespaceExportDeclaration" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTerminatorless(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Terminatorless" || "BreakStatement" === nodeType || "ContinueStatement" === nodeType || "ReturnStatement" === nodeType || "ThrowStatement" === nodeType || "YieldExpression" === nodeType || "AwaitExpression" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isCompletionStatement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "CompletionStatement" || "BreakStatement" === nodeType || "ContinueStatement" === nodeType || "ReturnStatement" === nodeType || "ThrowStatement" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isConditional(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Conditional" || "ConditionalExpression" === nodeType || "IfStatement" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isLoop(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Loop" || "DoWhileStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "WhileStatement" === nodeType || "ForOfStatement" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isWhile(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "While" || "DoWhileStatement" === nodeType || "WhileStatement" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isExpressionWrapper(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ExpressionWrapper" || "ExpressionStatement" === nodeType || "TypeCastExpression" === nodeType || "ParenthesizedExpression" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isFor(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "For" || "ForInStatement" === nodeType || "ForStatement" === nodeType || "ForOfStatement" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isForXStatement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ForXStatement" || "ForInStatement" === nodeType || "ForOfStatement" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isFunction(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Function" || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "ObjectMethod" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassMethod" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isFunctionParent(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "FunctionParent" || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "ObjectMethod" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassMethod" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isPureish(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Pureish" || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassDeclaration" === nodeType || "ClassExpression" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isDeclaration(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Declaration" || "FunctionDeclaration" === nodeType || "VariableDeclaration" === nodeType || "ClassDeclaration" === nodeType || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ImportDeclaration" === nodeType || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "InterfaceDeclaration" === nodeType || "OpaqueType" === nodeType || "TypeAlias" === nodeType || "TSDeclareFunction" === nodeType || "TSInterfaceDeclaration" === nodeType || "TSTypeAliasDeclaration" === nodeType || "TSEnumDeclaration" === nodeType || "TSModuleDeclaration" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isPatternLike(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "PatternLike" || "Identifier" === nodeType || "RestElement" === nodeType || "AssignmentPattern" === nodeType || "ArrayPattern" === nodeType || "ObjectPattern" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isLVal(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "LVal" || "Identifier" === nodeType || "MemberExpression" === nodeType || "RestElement" === nodeType || "AssignmentPattern" === nodeType || "ArrayPattern" === nodeType || "ObjectPattern" === nodeType || "TSParameterProperty" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSEntityName(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSEntityName" || "Identifier" === nodeType || "TSQualifiedName" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isLiteral(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Literal" || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "TemplateLiteral" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isImmutable(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Immutable" || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "JSXAttribute" === nodeType || "JSXClosingElement" === nodeType || "JSXElement" === nodeType || "JSXExpressionContainer" === nodeType || "JSXSpreadChild" === nodeType || "JSXOpeningElement" === nodeType || "JSXText" === nodeType || "JSXFragment" === nodeType || "JSXOpeningFragment" === nodeType || "JSXClosingFragment" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isUserWhitespacable(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "UserWhitespacable" || "ObjectMethod" === nodeType || "ObjectProperty" === nodeType || "ObjectTypeCallProperty" === nodeType || "ObjectTypeIndexer" === nodeType || "ObjectTypeProperty" === nodeType || "ObjectTypeSpreadProperty" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isMethod(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Method" || "ObjectMethod" === nodeType || "ClassMethod" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isObjectMember(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ObjectMember" || "ObjectMethod" === nodeType || "ObjectProperty" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isProperty(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Property" || "ObjectProperty" === nodeType || "ClassProperty" === nodeType || "ClassPrivateProperty" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isUnaryLike(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "UnaryLike" || "UnaryExpression" === nodeType || "SpreadElement" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isPattern(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Pattern" || "AssignmentPattern" === nodeType || "ArrayPattern" === nodeType || "ObjectPattern" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isClass(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Class" || "ClassDeclaration" === nodeType || "ClassExpression" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isModuleDeclaration(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ModuleDeclaration" || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ImportDeclaration" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isExportDeclaration(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ExportDeclaration" || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isModuleSpecifier(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ModuleSpecifier" || "ExportSpecifier" === nodeType || "ImportDefaultSpecifier" === nodeType || "ImportNamespaceSpecifier" === nodeType || "ImportSpecifier" === nodeType || "ExportDefaultSpecifier" === nodeType || "ExportNamespaceSpecifier" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isFlow(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Flow" || "AnyTypeAnnotation" === nodeType || "ArrayTypeAnnotation" === nodeType || "BooleanTypeAnnotation" === nodeType || "BooleanLiteralTypeAnnotation" === nodeType || "NullLiteralTypeAnnotation" === nodeType || "ClassImplements" === nodeType || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "DeclaredPredicate" === nodeType || "ExistsTypeAnnotation" === nodeType || "FunctionTypeAnnotation" === nodeType || "FunctionTypeParam" === nodeType || "GenericTypeAnnotation" === nodeType || "InferredPredicate" === nodeType || "InterfaceExtends" === nodeType || "InterfaceDeclaration" === nodeType || "IntersectionTypeAnnotation" === nodeType || "MixedTypeAnnotation" === nodeType || "EmptyTypeAnnotation" === nodeType || "NullableTypeAnnotation" === nodeType || "NumberLiteralTypeAnnotation" === nodeType || "NumberTypeAnnotation" === nodeType || "ObjectTypeAnnotation" === nodeType || "ObjectTypeCallProperty" === nodeType || "ObjectTypeIndexer" === nodeType || "ObjectTypeProperty" === nodeType || "ObjectTypeSpreadProperty" === nodeType || "OpaqueType" === nodeType || "QualifiedTypeIdentifier" === nodeType || "StringLiteralTypeAnnotation" === nodeType || "StringTypeAnnotation" === nodeType || "ThisTypeAnnotation" === nodeType || "TupleTypeAnnotation" === nodeType || "TypeofTypeAnnotation" === nodeType || "TypeAlias" === nodeType || "TypeAnnotation" === nodeType || "TypeCastExpression" === nodeType || "TypeParameter" === nodeType || "TypeParameterDeclaration" === nodeType || "TypeParameterInstantiation" === nodeType || "UnionTypeAnnotation" === nodeType || "Variance" === nodeType || "VoidTypeAnnotation" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isFlowType(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "FlowType" || "AnyTypeAnnotation" === nodeType || "ArrayTypeAnnotation" === nodeType || "BooleanTypeAnnotation" === nodeType || "BooleanLiteralTypeAnnotation" === nodeType || "NullLiteralTypeAnnotation" === nodeType || "ExistsTypeAnnotation" === nodeType || "FunctionTypeAnnotation" === nodeType || "GenericTypeAnnotation" === nodeType || "IntersectionTypeAnnotation" === nodeType || "MixedTypeAnnotation" === nodeType || "EmptyTypeAnnotation" === nodeType || "NullableTypeAnnotation" === nodeType || "NumberLiteralTypeAnnotation" === nodeType || "NumberTypeAnnotation" === nodeType || "ObjectTypeAnnotation" === nodeType || "StringLiteralTypeAnnotation" === nodeType || "StringTypeAnnotation" === nodeType || "ThisTypeAnnotation" === nodeType || "TupleTypeAnnotation" === nodeType || "TypeofTypeAnnotation" === nodeType || "UnionTypeAnnotation" === nodeType || "VoidTypeAnnotation" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isFlowBaseAnnotation(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "FlowBaseAnnotation" || "AnyTypeAnnotation" === nodeType || "BooleanTypeAnnotation" === nodeType || "NullLiteralTypeAnnotation" === nodeType || "MixedTypeAnnotation" === nodeType || "EmptyTypeAnnotation" === nodeType || "NumberTypeAnnotation" === nodeType || "StringTypeAnnotation" === nodeType || "ThisTypeAnnotation" === nodeType || "VoidTypeAnnotation" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isFlowDeclaration(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "FlowDeclaration" || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "InterfaceDeclaration" === nodeType || "OpaqueType" === nodeType || "TypeAlias" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isFlowPredicate(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "FlowPredicate" || "DeclaredPredicate" === nodeType || "InferredPredicate" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isJSX(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "JSX" || "JSXAttribute" === nodeType || "JSXClosingElement" === nodeType || "JSXElement" === nodeType || "JSXEmptyExpression" === nodeType || "JSXExpressionContainer" === nodeType || "JSXSpreadChild" === nodeType || "JSXIdentifier" === nodeType || "JSXMemberExpression" === nodeType || "JSXNamespacedName" === nodeType || "JSXOpeningElement" === nodeType || "JSXSpreadAttribute" === nodeType || "JSXText" === nodeType || "JSXFragment" === nodeType || "JSXOpeningFragment" === nodeType || "JSXClosingFragment" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isPrivate(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Private" || "ClassPrivateProperty" === nodeType || "PrivateName" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSTypeElement(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSTypeElement" || "TSCallSignatureDeclaration" === nodeType || "TSConstructSignatureDeclaration" === nodeType || "TSPropertySignature" === nodeType || "TSMethodSignature" === nodeType || "TSIndexSignature" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isTSType(node, opts) {
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSType" || "TSAnyKeyword" === nodeType || "TSNumberKeyword" === nodeType || "TSObjectKeyword" === nodeType || "TSBooleanKeyword" === nodeType || "TSStringKeyword" === nodeType || "TSSymbolKeyword" === nodeType || "TSVoidKeyword" === nodeType || "TSUndefinedKeyword" === nodeType || "TSNullKeyword" === nodeType || "TSNeverKeyword" === nodeType || "TSThisType" === nodeType || "TSFunctionType" === nodeType || "TSConstructorType" === nodeType || "TSTypeReference" === nodeType || "TSTypePredicate" === nodeType || "TSTypeQuery" === nodeType || "TSTypeLiteral" === nodeType || "TSArrayType" === nodeType || "TSTupleType" === nodeType || "TSUnionType" === nodeType || "TSIntersectionType" === nodeType || "TSConditionalType" === nodeType || "TSInferType" === nodeType || "TSParenthesizedType" === nodeType || "TSTypeOperator" === nodeType || "TSIndexedAccessType" === nodeType || "TSMappedType" === nodeType || "TSLiteralType" === nodeType || "TSExpressionWithTypeArguments" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isNumberLiteral(node, opts) {
+  console.trace("The node type NumberLiteral has been renamed to NumericLiteral");
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "NumberLiteral") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isRegexLiteral(node, opts) {
+  console.trace("The node type RegexLiteral has been renamed to RegExpLiteral");
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "RegexLiteral") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isRestProperty(node, opts) {
+  console.trace("The node type RestProperty has been renamed to RestElement");
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "RestProperty") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
+
+function isSpreadProperty(node, opts) {
+  console.trace("The node type SpreadProperty has been renamed to SpreadElement");
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "SpreadProperty") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/validators/is.js b/node_modules/@babel/types/lib/validators/is.js
new file mode 100644
index 00000000..5aa809d2
--- /dev/null
+++ b/node_modules/@babel/types/lib/validators/is.js
@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = is;
+
+var _shallowEqual = _interopRequireDefault(require("../utils/shallowEqual"));
+
+var _isType = _interopRequireDefault(require("./isType"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function is(type, node, opts) {
+  if (!node) return false;
+  const matches = (0, _isType.default)(node.type, type);
+  if (!matches) return false;
+
+  if (typeof opts === "undefined") {
+    return true;
+  } else {
+    return (0, _shallowEqual.default)(node, opts);
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/validators/isBinding.js b/node_modules/@babel/types/lib/validators/isBinding.js
new file mode 100644
index 00000000..24d781bf
--- /dev/null
+++ b/node_modules/@babel/types/lib/validators/isBinding.js
@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isBinding;
+
+var _getBindingIdentifiers = _interopRequireDefault(require("../retrievers/getBindingIdentifiers"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function isBinding(node, parent) {
+  const keys = _getBindingIdentifiers.default.keys[parent.type];
+
+  if (keys) {
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const val = parent[key];
+
+      if (Array.isArray(val)) {
+        if (val.indexOf(node) >= 0) return true;
+      } else {
+        if (val === node) return true;
+      }
+    }
+  }
+
+  return false;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/validators/isBlockScoped.js b/node_modules/@babel/types/lib/validators/isBlockScoped.js
new file mode 100644
index 00000000..7e6549e0
--- /dev/null
+++ b/node_modules/@babel/types/lib/validators/isBlockScoped.js
@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isBlockScoped;
+
+var _generated = require("./generated");
+
+var _isLet = _interopRequireDefault(require("./isLet"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function isBlockScoped(node) {
+  return (0, _generated.isFunctionDeclaration)(node) || (0, _generated.isClassDeclaration)(node) || (0, _isLet.default)(node);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/validators/isImmutable.js b/node_modules/@babel/types/lib/validators/isImmutable.js
new file mode 100644
index 00000000..b00b23d4
--- /dev/null
+++ b/node_modules/@babel/types/lib/validators/isImmutable.js
@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isImmutable;
+
+var _isType = _interopRequireDefault(require("./isType"));
+
+var _generated = require("./generated");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function isImmutable(node) {
+  if ((0, _isType.default)(node.type, "Immutable")) return true;
+
+  if ((0, _generated.isIdentifier)(node)) {
+    if (node.name === "undefined") {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  return false;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/validators/isLet.js b/node_modules/@babel/types/lib/validators/isLet.js
new file mode 100644
index 00000000..93d75628
--- /dev/null
+++ b/node_modules/@babel/types/lib/validators/isLet.js
@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isLet;
+
+var _generated = require("./generated");
+
+var _constants = require("../constants");
+
+function isLet(node) {
+  return (0, _generated.isVariableDeclaration)(node) && (node.kind !== "var" || node[_constants.BLOCK_SCOPED_SYMBOL]);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/validators/isNode.js b/node_modules/@babel/types/lib/validators/isNode.js
new file mode 100644
index 00000000..e88a47aa
--- /dev/null
+++ b/node_modules/@babel/types/lib/validators/isNode.js
@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isNode;
+
+var _definitions = require("../definitions");
+
+function isNode(node) {
+  return !!(node && _definitions.VISITOR_KEYS[node.type]);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/validators/isNodesEquivalent.js b/node_modules/@babel/types/lib/validators/isNodesEquivalent.js
new file mode 100644
index 00000000..6055405d
--- /dev/null
+++ b/node_modules/@babel/types/lib/validators/isNodesEquivalent.js
@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isNodesEquivalent;
+
+var _definitions = require("../definitions");
+
+function isNodesEquivalent(a, b) {
+  if (typeof a !== "object" || typeof b !== "object" || a == null || b == null) {
+    return a === b;
+  }
+
+  if (a.type !== b.type) {
+    return false;
+  }
+
+  const fields = Object.keys(_definitions.NODE_FIELDS[a.type] || a.type);
+
+  for (var _i = 0; _i < fields.length; _i++) {
+    const field = fields[_i];
+
+    if (typeof a[field] !== typeof b[field]) {
+      return false;
+    }
+
+    if (Array.isArray(a[field])) {
+      if (!Array.isArray(b[field])) {
+        return false;
+      }
+
+      if (a[field].length !== b[field].length) {
+        return false;
+      }
+
+      for (let i = 0; i < a[field].length; i++) {
+        if (!isNodesEquivalent(a[field][i], b[field][i])) {
+          return false;
+        }
+      }
+
+      continue;
+    }
+
+    if (!isNodesEquivalent(a[field], b[field])) {
+      return false;
+    }
+  }
+
+  return true;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/validators/isReferenced.js b/node_modules/@babel/types/lib/validators/isReferenced.js
new file mode 100644
index 00000000..827b840f
--- /dev/null
+++ b/node_modules/@babel/types/lib/validators/isReferenced.js
@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isReferenced;
+
+function isReferenced(node, parent) {
+  switch (parent.type) {
+    case "MemberExpression":
+    case "JSXMemberExpression":
+    case "OptionalMemberExpression":
+      if (parent.property === node) {
+        return !!parent.computed;
+      }
+
+      return parent.object === node;
+
+    case "VariableDeclarator":
+      return parent.init === node;
+
+    case "ArrowFunctionExpression":
+      return parent.body === node;
+
+    case "ExportSpecifier":
+      if (parent.source) {
+        return false;
+      }
+
+      return parent.local === node;
+
+    case "ObjectProperty":
+    case "ClassProperty":
+    case "ClassPrivateProperty":
+    case "ClassMethod":
+    case "ObjectMethod":
+      if (parent.key === node) {
+        return !!parent.computed;
+      }
+
+      return parent.value === node;
+
+    case "ClassDeclaration":
+    case "ClassExpression":
+      return parent.superClass === node;
+
+    case "AssignmentExpression":
+      return parent.right === node;
+
+    case "AssignmentPattern":
+      return parent.right === node;
+
+    case "LabeledStatement":
+      return false;
+
+    case "CatchClause":
+      return false;
+
+    case "RestElement":
+      return false;
+
+    case "FunctionDeclaration":
+    case "FunctionExpression":
+      return false;
+
+    case "ExportNamespaceSpecifier":
+    case "ExportDefaultSpecifier":
+      return false;
+
+    case "ImportDefaultSpecifier":
+    case "ImportNamespaceSpecifier":
+    case "ImportSpecifier":
+      return false;
+
+    case "JSXAttribute":
+      return false;
+
+    case "ObjectPattern":
+    case "ArrayPattern":
+      return false;
+
+    case "MetaProperty":
+      return false;
+  }
+
+  return true;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/validators/isScope.js b/node_modules/@babel/types/lib/validators/isScope.js
new file mode 100644
index 00000000..c808631f
--- /dev/null
+++ b/node_modules/@babel/types/lib/validators/isScope.js
@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isScope;
+
+var _generated = require("./generated");
+
+function isScope(node, parent) {
+  if ((0, _generated.isBlockStatement)(node) && (0, _generated.isFunction)(parent, {
+    body: node
+  })) {
+    return false;
+  }
+
+  if ((0, _generated.isBlockStatement)(node) && (0, _generated.isCatchClause)(parent, {
+    body: node
+  })) {
+    return false;
+  }
+
+  return (0, _generated.isScopable)(node);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/validators/isSpecifierDefault.js b/node_modules/@babel/types/lib/validators/isSpecifierDefault.js
new file mode 100644
index 00000000..25431cc2
--- /dev/null
+++ b/node_modules/@babel/types/lib/validators/isSpecifierDefault.js
@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isSpecifierDefault;
+
+var _generated = require("./generated");
+
+function isSpecifierDefault(specifier) {
+  return (0, _generated.isImportDefaultSpecifier)(specifier) || (0, _generated.isIdentifier)(specifier.imported || specifier.exported, {
+    name: "default"
+  });
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/validators/isType.js b/node_modules/@babel/types/lib/validators/isType.js
new file mode 100644
index 00000000..56cf16a8
--- /dev/null
+++ b/node_modules/@babel/types/lib/validators/isType.js
@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isType;
+
+var _definitions = require("../definitions");
+
+function isType(nodeType, targetType) {
+  if (nodeType === targetType) return true;
+  if (_definitions.ALIAS_KEYS[targetType]) return false;
+  const aliases = _definitions.FLIPPED_ALIAS_KEYS[targetType];
+
+  if (aliases) {
+    if (aliases[0] === nodeType) return true;
+
+    for (var _iterator = aliases, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i >= _iterator.length) break;
+        _ref = _iterator[_i++];
+      } else {
+        _i = _iterator.next();
+        if (_i.done) break;
+        _ref = _i.value;
+      }
+
+      const alias = _ref;
+      if (nodeType === alias) return true;
+    }
+  }
+
+  return false;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/validators/isValidES3Identifier.js b/node_modules/@babel/types/lib/validators/isValidES3Identifier.js
new file mode 100644
index 00000000..8455cab2
--- /dev/null
+++ b/node_modules/@babel/types/lib/validators/isValidES3Identifier.js
@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isValidES3Identifier;
+
+var _isValidIdentifier = _interopRequireDefault(require("./isValidIdentifier"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const RESERVED_WORDS_ES3_ONLY = new Set(["abstract", "boolean", "byte", "char", "double", "enum", "final", "float", "goto", "implements", "int", "interface", "long", "native", "package", "private", "protected", "public", "short", "static", "synchronized", "throws", "transient", "volatile"]);
+
+function isValidES3Identifier(name) {
+  return (0, _isValidIdentifier.default)(name) && !RESERVED_WORDS_ES3_ONLY.has(name);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/validators/isValidIdentifier.js b/node_modules/@babel/types/lib/validators/isValidIdentifier.js
new file mode 100644
index 00000000..14f61893
--- /dev/null
+++ b/node_modules/@babel/types/lib/validators/isValidIdentifier.js
@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isValidIdentifier;
+
+function _esutils() {
+  const data = _interopRequireDefault(require("esutils"));
+
+  _esutils = function _esutils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function isValidIdentifier(name) {
+  if (typeof name !== "string" || _esutils().default.keyword.isReservedWordES6(name, true)) {
+    return false;
+  } else if (name === "await") {
+    return false;
+  } else {
+    return _esutils().default.keyword.isIdentifierNameES6(name);
+  }
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/validators/isVar.js b/node_modules/@babel/types/lib/validators/isVar.js
new file mode 100644
index 00000000..a34801d1
--- /dev/null
+++ b/node_modules/@babel/types/lib/validators/isVar.js
@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isVar;
+
+var _generated = require("./generated");
+
+var _constants = require("../constants");
+
+function isVar(node) {
+  return (0, _generated.isVariableDeclaration)(node, {
+    kind: "var"
+  }) && !node[_constants.BLOCK_SCOPED_SYMBOL];
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/validators/matchesPattern.js b/node_modules/@babel/types/lib/validators/matchesPattern.js
new file mode 100644
index 00000000..538e011f
--- /dev/null
+++ b/node_modules/@babel/types/lib/validators/matchesPattern.js
@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = matchesPattern;
+
+var _generated = require("./generated");
+
+function matchesPattern(member, match, allowPartial) {
+  if (!(0, _generated.isMemberExpression)(member)) return false;
+  const parts = Array.isArray(match) ? match : match.split(".");
+  const nodes = [];
+  let node;
+
+  for (node = member; (0, _generated.isMemberExpression)(node); node = node.object) {
+    nodes.push(node.property);
+  }
+
+  nodes.push(node);
+  if (nodes.length < parts.length) return false;
+  if (!allowPartial && nodes.length > parts.length) return false;
+
+  for (let i = 0, j = nodes.length - 1; i < parts.length; i++, j--) {
+    const node = nodes[j];
+    let value;
+
+    if ((0, _generated.isIdentifier)(node)) {
+      value = node.name;
+    } else if ((0, _generated.isStringLiteral)(node)) {
+      value = node.value;
+    } else {
+      return false;
+    }
+
+    if (parts[i] !== value) return false;
+  }
+
+  return true;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/validators/react/isCompatTag.js b/node_modules/@babel/types/lib/validators/react/isCompatTag.js
new file mode 100644
index 00000000..57761c2b
--- /dev/null
+++ b/node_modules/@babel/types/lib/validators/react/isCompatTag.js
@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isCompatTag;
+
+function isCompatTag(tagName) {
+  return !!tagName && /^[a-z]/.test(tagName);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/validators/react/isReactComponent.js b/node_modules/@babel/types/lib/validators/react/isReactComponent.js
new file mode 100644
index 00000000..33b30d71
--- /dev/null
+++ b/node_modules/@babel/types/lib/validators/react/isReactComponent.js
@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _buildMatchMemberExpression = _interopRequireDefault(require("../buildMatchMemberExpression"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const isReactComponent = (0, _buildMatchMemberExpression.default)("React.Component");
+var _default = isReactComponent;
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/types/lib/validators/validate.js b/node_modules/@babel/types/lib/validators/validate.js
new file mode 100644
index 00000000..1fe1c1c9
--- /dev/null
+++ b/node_modules/@babel/types/lib/validators/validate.js
@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = validate;
+
+var _definitions = require("../definitions");
+
+function validate(node, key, val) {
+  if (!node) return;
+  const fields = _definitions.NODE_FIELDS[node.type];
+  if (!fields) return;
+  const field = fields[key];
+  if (!field || !field.validate) return;
+  if (field.optional && val == null) return;
+  field.validate(node, key, val);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/types/package.json b/node_modules/@babel/types/package.json
new file mode 100644
index 00000000..2b3689df
--- /dev/null
+++ b/node_modules/@babel/types/package.json
@@ -0,0 +1,20 @@
+{
+  "name": "@babel/types",
+  "version": "7.0.0-beta.47",
+  "description": "Babel Types is a Lodash-esque utility library for AST nodes",
+  "author": "Sebastian McKenzie <sebmck@gmail.com>",
+  "homepage": "https://babeljs.io/",
+  "license": "MIT",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-types",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "dependencies": {
+    "esutils": "^2.0.2",
+    "lodash": "^4.17.5",
+    "to-fast-properties": "^2.0.0"
+  },
+  "devDependencies": {
+    "@babel/generator": "7.0.0-beta.47",
+    "babylon": "7.0.0-beta.47"
+  }
+}
diff --git a/node_modules/@babel/types/scripts/generateTypeHelpers.js b/node_modules/@babel/types/scripts/generateTypeHelpers.js
new file mode 100644
index 00000000..e122145c
--- /dev/null
+++ b/node_modules/@babel/types/scripts/generateTypeHelpers.js
@@ -0,0 +1,31 @@
+"use strict";
+const fs = require("fs");
+const path = require("path");
+const generateBuilders = require("./generators/generateBuilders");
+const generateValidators = require("./generators/generateValidators");
+const generateAsserts = require("./generators/generateAsserts");
+const generateConstants = require("./generators/generateConstants");
+const format = require("./utils/formatCode");
+
+const baseDir = path.join(__dirname, "../src");
+
+function writeFile(content, location) {
+  const file = path.join(baseDir, location);
+
+  try {
+    fs.mkdirSync(path.dirname(file));
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+  }
+
+  fs.writeFileSync(file, format(content, file));
+}
+
+console.log("Generating @babel/types dynamic functions");
+
+writeFile(generateBuilders(), "builders/generated/index.js");
+writeFile(generateValidators(), "validators/generated/index.js");
+writeFile(generateAsserts(), "asserts/generated/index.js");
+writeFile(generateConstants(), "constants/generated/index.js");
diff --git a/node_modules/@babel/types/scripts/generators/generateAsserts.js b/node_modules/@babel/types/scripts/generators/generateAsserts.js
new file mode 100644
index 00000000..150e8557
--- /dev/null
+++ b/node_modules/@babel/types/scripts/generators/generateAsserts.js
@@ -0,0 +1,43 @@
+"use strict";
+const definitions = require("../../lib/definitions");
+
+function addAssertHelper(type) {
+  return `export function assert${type}(node: Object, opts?: Object = {}): void {
+    assert("${type}", node, opts) }
+  `;
+}
+
+module.exports = function generateAsserts() {
+  let output = `// @flow
+/*
+ * This file is auto-generated! Do not modify it directly.
+ * To re-generate run 'make build'
+ */
+import is from "../../validators/is";
+
+function assert(type: string, node: Object, opts?: Object): void {
+  if (!is(type, node, opts)) {
+    throw new Error(
+      \`Expected type "\${type}" with option \${JSON.stringify(opts)}, but instead got "\${node.type}".\`,
+    );
+  }
+}\n\n`;
+
+  Object.keys(definitions.VISITOR_KEYS).forEach(type => {
+    output += addAssertHelper(type);
+  });
+
+  Object.keys(definitions.FLIPPED_ALIAS_KEYS).forEach(type => {
+    output += addAssertHelper(type);
+  });
+
+  Object.keys(definitions.DEPRECATED_KEYS).forEach(type => {
+    const newType = definitions.DEPRECATED_KEYS[type];
+    output += `export function assert${type}(node: Object, opts: Object): void {
+  console.trace("The node type ${type} has been renamed to ${newType}");
+  assert("${type}", node, opts);
+}\n`;
+  });
+
+  return output;
+};
diff --git a/node_modules/@babel/types/scripts/generators/generateBuilders.js b/node_modules/@babel/types/scripts/generators/generateBuilders.js
new file mode 100644
index 00000000..08a5b6fc
--- /dev/null
+++ b/node_modules/@babel/types/scripts/generators/generateBuilders.js
@@ -0,0 +1,43 @@
+"use strict";
+const definitions = require("../../lib/definitions");
+const formatBuilderName = require("../utils/formatBuilderName");
+const lowerFirst = require("../utils/lowerFirst");
+
+module.exports = function generateBuilders() {
+  let output = `// @flow
+/*
+ * This file is auto-generated! Do not modify it directly.
+ * To re-generate run 'make build'
+ */
+import builder from "../builder";\n\n`;
+
+  Object.keys(definitions.BUILDER_KEYS).forEach(type => {
+    output += `export function ${type}(...args: Array<any>): Object { return builder("${type}", ...args); }
+export { ${type} as ${formatBuilderName(type)} };\n`;
+
+    // This is needed for backwards compatibility.
+    // It should be removed in the next major version.
+    // JSXIdentifier -> jSXIdentifier
+    if (/^[A-Z]{2}/.test(type)) {
+      output += `export { ${type} as ${lowerFirst(type)} }\n`;
+    }
+  });
+
+  Object.keys(definitions.DEPRECATED_KEYS).forEach(type => {
+    const newType = definitions.DEPRECATED_KEYS[type];
+    output += `export function ${type}(...args: Array<any>): Object {
+  console.trace("The node type ${type} has been renamed to ${newType}");
+  return ${type}("${type}", ...args);
+}
+export { ${type} as ${formatBuilderName(type)} };\n`;
+
+    // This is needed for backwards compatibility.
+    // It should be removed in the next major version.
+    // JSXIdentifier -> jSXIdentifier
+    if (/^[A-Z]{2}/.test(type)) {
+      output += `export { ${type} as ${lowerFirst(type)} }\n`;
+    }
+  });
+
+  return output;
+};
diff --git a/node_modules/@babel/types/scripts/generators/generateConstants.js b/node_modules/@babel/types/scripts/generators/generateConstants.js
new file mode 100644
index 00000000..1e4d2cab
--- /dev/null
+++ b/node_modules/@babel/types/scripts/generators/generateConstants.js
@@ -0,0 +1,17 @@
+"use strict";
+const definitions = require("../../lib/definitions");
+
+module.exports = function generateConstants() {
+  let output = `// @flow
+/*
+ * This file is auto-generated! Do not modify it directly.
+ * To re-generate run 'make build'
+ */
+import { FLIPPED_ALIAS_KEYS } from "../../definitions";\n\n`;
+
+  Object.keys(definitions.FLIPPED_ALIAS_KEYS).forEach(type => {
+    output += `export const ${type.toUpperCase()}_TYPES = FLIPPED_ALIAS_KEYS["${type}"];\n`;
+  });
+
+  return output;
+};
diff --git a/node_modules/@babel/types/scripts/generators/generateValidators.js b/node_modules/@babel/types/scripts/generators/generateValidators.js
new file mode 100644
index 00000000..0f02f0c5
--- /dev/null
+++ b/node_modules/@babel/types/scripts/generators/generateValidators.js
@@ -0,0 +1,55 @@
+"use strict";
+const definitions = require("../../lib/definitions");
+
+function addIsHelper(type, aliasKeys, deprecated) {
+  const targetType = JSON.stringify(type);
+  let aliasSource = "";
+  if (aliasKeys) {
+    aliasSource =
+      " || " +
+      aliasKeys.map(JSON.stringify).join(" === nodeType || ") +
+      " === nodeType";
+  }
+
+  return `export function is${type}(node: Object, opts?: Object): boolean {
+    ${deprecated || ""}
+    if (!node) return false;
+
+    const nodeType = node.type;
+    if (nodeType === ${targetType}${aliasSource}) {
+      if (typeof opts === "undefined") {
+        return true;
+      } else {
+        return shallowEqual(node, opts);
+      }
+    }
+
+    return false;
+  }
+  `;
+}
+
+module.exports = function generateValidators() {
+  let output = `// @flow
+/*
+ * This file is auto-generated! Do not modify it directly.
+ * To re-generate run 'make build'
+ */
+import shallowEqual from "../../utils/shallowEqual";\n\n`;
+
+  Object.keys(definitions.VISITOR_KEYS).forEach(type => {
+    output += addIsHelper(type);
+  });
+
+  Object.keys(definitions.FLIPPED_ALIAS_KEYS).forEach(type => {
+    output += addIsHelper(type, definitions.FLIPPED_ALIAS_KEYS[type]);
+  });
+
+  Object.keys(definitions.DEPRECATED_KEYS).forEach(type => {
+    const newType = definitions.DEPRECATED_KEYS[type];
+    const deprecated = `console.trace("The node type ${type} has been renamed to ${newType}");`;
+    output += addIsHelper(type, null, deprecated);
+  });
+
+  return output;
+};
diff --git a/node_modules/@babel/types/scripts/utils/formatBuilderName.js b/node_modules/@babel/types/scripts/utils/formatBuilderName.js
new file mode 100644
index 00000000..1b543a9b
--- /dev/null
+++ b/node_modules/@babel/types/scripts/utils/formatBuilderName.js
@@ -0,0 +1,9 @@
+"use strict";
+
+const toLowerCase = Function.call.bind("".toLowerCase);
+
+module.exports = function formatBuilderName(type) {
+  // FunctionExpression -> functionExpression
+  // JSXIdentifier -> jsxIdentifier
+  return type.replace(/^([A-Z](?=[a-z])|[A-Z]+(?=[A-Z]))/, toLowerCase);
+};
diff --git a/node_modules/@babel/types/scripts/utils/formatCode.js b/node_modules/@babel/types/scripts/utils/formatCode.js
new file mode 100644
index 00000000..9d279e6e
--- /dev/null
+++ b/node_modules/@babel/types/scripts/utils/formatCode.js
@@ -0,0 +1,9 @@
+"use strict";
+const prettier = require("prettier");
+
+module.exports = function formatCode(code, filename) {
+  filename = filename || __filename;
+  const prettierConfig = prettier.resolveConfig.sync(filename);
+
+  return prettier.format(code, prettierConfig);
+};
diff --git a/node_modules/@babel/types/scripts/utils/lowerFirst.js b/node_modules/@babel/types/scripts/utils/lowerFirst.js
new file mode 100644
index 00000000..9e7b0cee
--- /dev/null
+++ b/node_modules/@babel/types/scripts/utils/lowerFirst.js
@@ -0,0 +1,4 @@
+"use strict";
+module.exports = function lowerFirst(string) {
+  return string[0].toLowerCase() + string.slice(1);
+};