+ Babel CLI
+
+ You can pass these options from the Babel CLI like so:
+
+
+ babel --name=value
+
+
+
+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 0000000..792ecd9
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/caching.js
@@ -0,0 +1,223 @@
+"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) {
+ var 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;
+ }
+
+ var _ref3 = _ref2;
+ var _value = _ref3.value,
+ _valid = _ref3.valid;
+ if (_valid(data)) return _value;
+ }
+ }
+
+ var cache = new CacheConfigurator(data);
+ var value = handler(arg, cache);
+ if (!cache.configured()) cache.forever();
+ cache.deactivate();
+
+ switch (cache.mode()) {
+ case "forever":
+ cachedValue = [{
+ value: value,
+ valid: function valid() {
+ return true;
+ }
+ }];
+ callCache.set(arg, cachedValue);
+ break;
+
+ case "invalidate":
+ cachedValue = [{
+ value: value,
+ valid: cache.validator()
+ }];
+ callCache.set(arg, cachedValue);
+ break;
+
+ case "valid":
+ if (cachedValue) {
+ cachedValue.push({
+ value: value,
+ valid: cache.validator()
+ });
+ } else {
+ cachedValue = [{
+ value: value,
+ valid: cache.validator()
+ }];
+ callCache.set(arg, cachedValue);
+ }
+
+ }
+
+ return value;
+ };
+}
+
+var CacheConfigurator = function () {
+ function CacheConfigurator(data) {
+ this._active = true;
+ this._never = false;
+ this._forever = false;
+ this._invalidate = false;
+ this._configured = false;
+ this._pairs = [];
+ this._data = data;
+ }
+
+ var _proto = CacheConfigurator.prototype;
+
+ _proto.simple = function simple() {
+ return makeSimpleConfigurator(this);
+ };
+
+ _proto.mode = function mode() {
+ if (this._never) return "never";
+ if (this._forever) return "forever";
+ if (this._invalidate) return "invalidate";
+ return "valid";
+ };
+
+ _proto.forever = function 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;
+ };
+
+ _proto.never = function 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;
+ };
+
+ _proto.using = function 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;
+ var key = handler(this._data);
+
+ this._pairs.push([key, handler]);
+
+ return key;
+ };
+
+ _proto.invalidate = function 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;
+ var key = handler(this._data);
+
+ this._pairs.push([key, handler]);
+
+ return key;
+ };
+
+ _proto.validator = function validator() {
+ var pairs = this._pairs;
+ return function (data) {
+ return pairs.every(function (_ref4) {
+ var key = _ref4[0],
+ fn = _ref4[1];
+ return key === fn(data);
+ });
+ };
+ };
+
+ _proto.deactivate = function deactivate() {
+ this._active = false;
+ };
+
+ _proto.configured = function configured() {
+ return this._configured;
+ };
+
+ return CacheConfigurator;
+}();
+
+function makeSimpleConfigurator(cache) {
+ function cacheFn(val) {
+ if (typeof val === "boolean") {
+ if (val) cache.forever();else cache.never();
+ return;
+ }
+
+ return cache.using(val);
+ }
+
+ cacheFn.forever = function () {
+ return cache.forever();
+ };
+
+ cacheFn.never = function () {
+ return cache.never();
+ };
+
+ cacheFn.using = function (cb) {
+ return cache.using(function () {
+ return cb();
+ });
+ };
+
+ cacheFn.invalidate = function (cb) {
+ return cache.invalidate(function () {
+ return 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 0000000..712bb3e
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/config-chain.js
@@ -0,0 +1,558 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.buildRootChain = buildRootChain;
+exports.buildPresetChain = void 0;
+
+function _path() {
+ var data = _interopRequireDefault(require("path"));
+
+ _path = function _path() {
+ return data;
+ };
+
+ return data;
+}
+
+function _micromatch() {
+ var data = _interopRequireDefault(require("micromatch"));
+
+ _micromatch = function _micromatch() {
+ return data;
+ };
+
+ return data;
+}
+
+function _debug() {
+ var 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 }; }
+
+var debug = (0, _debug().default)("babel:config:config-chain");
+var buildPresetChain = makeChainWalker({
+ init: function init(arg) {
+ return arg;
+ },
+ root: function root(preset) {
+ return loadPresetDescriptors(preset);
+ },
+ env: function env(preset, envName) {
+ return loadPresetEnvDescriptors(preset)(envName);
+ },
+ overrides: function overrides(preset, index) {
+ return loadPresetOverridesDescriptors(preset)(index);
+ },
+ overridesEnv: function overridesEnv(preset, index, envName) {
+ return loadPresetOverridesEnvDescriptors(preset)(index)(envName);
+ }
+});
+exports.buildPresetChain = buildPresetChain;
+var loadPresetDescriptors = (0, _caching.makeWeakCache)(function (preset) {
+ return buildRootDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors);
+});
+var loadPresetEnvDescriptors = (0, _caching.makeWeakCache)(function (preset) {
+ return (0, _caching.makeStrongCache)(function (envName) {
+ return buildEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, envName);
+ });
+});
+var loadPresetOverridesDescriptors = (0, _caching.makeWeakCache)(function (preset) {
+ return (0, _caching.makeStrongCache)(function (index) {
+ return buildOverrideDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index);
+ });
+});
+var loadPresetOverridesEnvDescriptors = (0, _caching.makeWeakCache)(function (preset) {
+ return (0, _caching.makeStrongCache)(function (index) {
+ return (0, _caching.makeStrongCache)(function (envName) {
+ return buildOverrideEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index, envName);
+ });
+ });
+});
+
+function buildRootChain(opts, context) {
+ var programmaticChain = loadProgrammaticChain({
+ options: opts,
+ dirname: context.cwd
+ }, context);
+ if (!programmaticChain) return null;
+ var _opts$root = opts.root,
+ rootDir = _opts$root === void 0 ? "." : _opts$root,
+ _opts$babelrc = opts.babelrc,
+ babelrc = _opts$babelrc === void 0 ? true : _opts$babelrc,
+ babelrcRoots = opts.babelrcRoots,
+ _opts$configFile = opts.configFile,
+ configFileName = _opts$configFile === void 0 ? true : _opts$configFile;
+
+ var absoluteRoot = _path().default.resolve(context.cwd, rootDir);
+
+ var 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);
+ }
+
+ var configFileChain = emptyChain();
+
+ if (configFile) {
+ var result = loadFileChain(configFile, context);
+ if (!result) return null;
+ mergeChain(configFileChain, result);
+ }
+
+ var pkgData = typeof context.filename === "string" ? (0, _files.findPackageData)(context.filename) : null;
+ var ignoreFile, babelrcFile;
+ var fileChain = emptyChain();
+
+ if (babelrc && 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) {
+ var _result = loadFileChain(babelrcFile, context);
+
+ if (!_result) return null;
+ mergeChain(fileChain, _result);
+ }
+ }
+
+ var chain = mergeChain(mergeChain(mergeChain(emptyChain(), configFileChain), fileChain), programmaticChain);
+ return {
+ plugins: dedupDescriptors(chain.plugins),
+ presets: dedupDescriptors(chain.presets),
+ options: chain.options.map(function (o) {
+ return 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;
+ }
+
+ var babelrcPatterns = babelrcRoots;
+ if (!Array.isArray(babelrcPatterns)) babelrcPatterns = [babelrcPatterns];
+ babelrcPatterns = babelrcPatterns.map(function (pat) {
+ return _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;
+}
+
+var loadProgrammaticChain = makeChainWalker({
+ init: function init(arg) {
+ return arg;
+ },
+ root: function root(input) {
+ return buildRootDescriptors(input, "base", _configDescriptors.createCachedDescriptors);
+ },
+ env: function env(input, envName) {
+ return buildEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, envName);
+ },
+ overrides: function overrides(input, index) {
+ return buildOverrideDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index);
+ },
+ overridesEnv: function overridesEnv(input, index, envName) {
+ return buildOverrideEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index, envName);
+ }
+});
+var loadFileChain = makeChainWalker({
+ init: function init(input) {
+ return validateFile(input);
+ },
+ root: function root(file) {
+ return loadFileDescriptors(file);
+ },
+ env: function env(file, envName) {
+ return loadFileEnvDescriptors(file)(envName);
+ },
+ overrides: function overrides(file, index) {
+ return loadFileOverridesDescriptors(file)(index);
+ },
+ overridesEnv: function overridesEnv(file, index, envName) {
+ return loadFileOverridesEnvDescriptors(file)(index)(envName);
+ }
+});
+var validateFile = (0, _caching.makeWeakCache)(function (file) {
+ return {
+ filepath: file.filepath,
+ dirname: file.dirname,
+ options: (0, _options.validate)("file", file.options)
+ };
+});
+var loadFileDescriptors = (0, _caching.makeWeakCache)(function (file) {
+ return buildRootDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors);
+});
+var loadFileEnvDescriptors = (0, _caching.makeWeakCache)(function (file) {
+ return (0, _caching.makeStrongCache)(function (envName) {
+ return buildEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, envName);
+ });
+});
+var loadFileOverridesDescriptors = (0, _caching.makeWeakCache)(function (file) {
+ return (0, _caching.makeStrongCache)(function (index) {
+ return buildOverrideDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index);
+ });
+});
+var loadFileOverridesEnvDescriptors = (0, _caching.makeWeakCache)(function (file) {
+ return (0, _caching.makeStrongCache)(function (index) {
+ return (0, _caching.makeStrongCache)(function (envName) {
+ return buildOverrideEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index, envName);
+ });
+ });
+});
+
+function buildRootDescriptors(_ref, alias, descriptors) {
+ var dirname = _ref.dirname,
+ options = _ref.options;
+ return descriptors(dirname, options, alias);
+}
+
+function buildEnvDescriptors(_ref2, alias, descriptors, envName) {
+ var dirname = _ref2.dirname,
+ options = _ref2.options;
+ var opts = options.env && options.env[envName];
+ return opts ? descriptors(dirname, opts, alias + ".env[\"" + envName + "\"]") : null;
+}
+
+function buildOverrideDescriptors(_ref3, alias, descriptors, index) {
+ var dirname = _ref3.dirname,
+ options = _ref3.options;
+ var opts = options.overrides && options.overrides[index];
+ if (!opts) throw new Error("Assertion failure - missing override");
+ return descriptors(dirname, opts, alias + ".overrides[" + index + "]");
+}
+
+function buildOverrideEnvDescriptors(_ref4, alias, descriptors, index, envName) {
+ var dirname = _ref4.dirname,
+ options = _ref4.options;
+ var override = options.overrides && options.overrides[index];
+ if (!override) throw new Error("Assertion failure - missing override");
+ var opts = override.env && override.env[envName];
+ return opts ? descriptors(dirname, opts, alias + ".overrides[" + index + "].env[\"" + envName + "\"]") : null;
+}
+
+function makeChainWalker(_ref5) {
+ var init = _ref5.init,
+ root = _ref5.root,
+ env = _ref5.env,
+ overrides = _ref5.overrides,
+ overridesEnv = _ref5.overridesEnv;
+ return function (arg, context, files) {
+ if (files === void 0) {
+ files = new Set();
+ }
+
+ var input = init(arg);
+ var dirname = input.dirname;
+ var flattenedConfigs = [];
+ var rootOpts = root(input);
+
+ if (configIsApplicable(rootOpts, dirname, context)) {
+ flattenedConfigs.push(rootOpts);
+ var envOpts = env(input, context.envName);
+
+ if (envOpts && configIsApplicable(envOpts, dirname, context)) {
+ flattenedConfigs.push(envOpts);
+ }
+
+ (rootOpts.options.overrides || []).forEach(function (_, index) {
+ var overrideOps = overrides(input, index);
+
+ if (configIsApplicable(overrideOps, dirname, context)) {
+ flattenedConfigs.push(overrideOps);
+ var overrideEnvOpts = overridesEnv(input, index, context.envName);
+
+ if (overrideEnvOpts && configIsApplicable(overrideEnvOpts, dirname, context)) {
+ flattenedConfigs.push(overrideEnvOpts);
+ }
+ }
+ });
+ }
+
+ if (flattenedConfigs.some(function (_ref6) {
+ var _ref6$options = _ref6.options,
+ ignore = _ref6$options.ignore,
+ only = _ref6$options.only;
+ return shouldIgnore(context, ignore, only, dirname);
+ })) {
+ return null;
+ }
+
+ var chain = emptyChain();
+
+ for (var _i = 0; _i < flattenedConfigs.length; _i++) {
+ var 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;
+ var 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, function (file) {
+ return " - " + file.filepath;
+ }).join("\n"));
+ }
+
+ files.add(file);
+ var fileChain = loadFileChain(file, context, files);
+ files.delete(file);
+ if (!fileChain) return false;
+ mergeChain(chain, fileChain);
+ return true;
+}
+
+function mergeChain(target, source) {
+ var _target$options, _target$plugins, _target$presets;
+
+ (_target$options = target.options).push.apply(_target$options, source.options);
+
+ (_target$plugins = target.plugins).push.apply(_target$plugins, source.plugins);
+
+ (_target$presets = target.presets).push.apply(_target$presets, source.presets);
+
+ return target;
+}
+
+function mergeChainOpts(target, _ref7) {
+ var _target$plugins2, _target$presets2;
+
+ var options = _ref7.options,
+ plugins = _ref7.plugins,
+ presets = _ref7.presets;
+ target.options.push(options);
+
+ (_target$plugins2 = target.plugins).push.apply(_target$plugins2, plugins());
+
+ (_target$presets2 = target.presets).push.apply(_target$presets2, presets());
+
+ return target;
+}
+
+function emptyChain() {
+ return {
+ options: [],
+ presets: [],
+ plugins: []
+ };
+}
+
+function normalizeOptions(opts) {
+ var 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) {
+ var map = new Map();
+ var descriptors = [];
+
+ for (var _iterator = items, _isArray = Array.isArray(_iterator), _i2 = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+ var _ref8;
+
+ if (_isArray) {
+ if (_i2 >= _iterator.length) break;
+ _ref8 = _iterator[_i2++];
+ } else {
+ _i2 = _iterator.next();
+ if (_i2.done) break;
+ _ref8 = _i2.value;
+ }
+
+ var item = _ref8;
+
+ if (typeof item.value === "function") {
+ var fnKey = item.value;
+ var nameMap = map.get(fnKey);
+
+ if (!nameMap) {
+ nameMap = new Map();
+ map.set(fnKey, nameMap);
+ }
+
+ var 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(function (acc, desc) {
+ if (desc.value) acc.push(desc.value);
+ return acc;
+ }, []);
+}
+
+function configIsApplicable(_ref9, dirname, context) {
+ var options = _ref9.options;
+ 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");
+ }
+
+ var ctx = context;
+ var 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");
+ }
+
+ var 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");
+ }
+
+ var _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) {
+ if (allowNegation === void 0) {
+ allowNegation = true;
+ }
+
+ var res = [];
+ var strings = [];
+ var fns = [];
+ patterns.forEach(function (pattern) {
+ if (typeof pattern === "string") strings.push(pattern);else if (typeof pattern === "function") fns.push(pattern);else res.push(pattern);
+ });
+ var filename = context.filename;
+ if (res.some(function (re) {
+ return re.test(context.filename);
+ })) return true;
+ if (fns.some(function (fn) {
+ return fn(filename);
+ })) return true;
+
+ if (strings.length > 0) {
+ var possibleDirs = getPossibleDirs(context);
+ var absolutePatterns = strings.map(function (pattern) {
+ var 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;
+}
+
+var getPossibleDirs = (0, _caching.makeWeakCache)(function (context) {
+ var current = context.filename;
+ if (current === null) return [];
+ var possibleDirs = [current];
+
+ while (true) {
+ var 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 0000000..303e0ec
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/config-descriptors.js
@@ -0,0 +1,225 @@
+"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) {
+ var plugins = options.plugins,
+ presets = options.presets,
+ passPerPreset = options.passPerPreset;
+ return {
+ options: options,
+ plugins: plugins ? function () {
+ return createCachedPluginDescriptors(plugins, dirname)(alias);
+ } : function () {
+ return [];
+ },
+ presets: presets ? function () {
+ return createCachedPresetDescriptors(presets, dirname)(alias)(!!passPerPreset);
+ } : function () {
+ return [];
+ }
+ };
+}
+
+function createUncachedDescriptors(dirname, options, alias) {
+ var plugins;
+ var presets;
+ return {
+ options: options,
+ plugins: function (_plugins) {
+ function plugins() {
+ return _plugins.apply(this, arguments);
+ }
+
+ plugins.toString = function () {
+ return _plugins.toString();
+ };
+
+ return plugins;
+ }(function () {
+ 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;
+ }(function () {
+ if (!presets) {
+ presets = createPresetDescriptors(options.presets || [], dirname, alias, !!options.passPerPreset);
+ }
+
+ return presets;
+ })
+ };
+}
+
+var createCachedPresetDescriptors = (0, _caching.makeWeakCache)(function (items, cache) {
+ var dirname = cache.using(function (dir) {
+ return dir;
+ });
+ return (0, _caching.makeStrongCache)(function (alias) {
+ return (0, _caching.makeStrongCache)(function (passPerPreset) {
+ return createPresetDescriptors(items, dirname, alias, passPerPreset);
+ });
+ });
+});
+var createCachedPluginDescriptors = (0, _caching.makeWeakCache)(function (items, cache) {
+ var dirname = cache.using(function (dir) {
+ return dir;
+ });
+ return (0, _caching.makeStrongCache)(function (alias) {
+ return 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) {
+ var descriptors = items.map(function (item, index) {
+ return createDescriptor(item, dirname, {
+ type: type,
+ alias: alias + "$" + index,
+ ownPass: !!ownPass
+ });
+ });
+ assertNoDuplicates(descriptors);
+ return descriptors;
+}
+
+function createDescriptor(pair, dirname, _ref) {
+ var type = _ref.type,
+ alias = _ref.alias,
+ ownPass = _ref.ownPass;
+ var desc = (0, _item.getItemDescriptor)(pair);
+
+ if (desc) {
+ return desc;
+ }
+
+ var name;
+ var options;
+ var 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];
+ }
+ }
+
+ var file = undefined;
+ var 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");
+ }
+
+ var resolver = type === "plugin" ? _files.loadPlugin : _files.loadPreset;
+ var _request = value;
+
+ var _resolver = resolver(value, dirname);
+
+ filepath = _resolver.filepath;
+ value = _resolver.value;
+ file = {
+ request: _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: name,
+ alias: filepath || alias,
+ value: value,
+ options: options,
+ dirname: dirname,
+ ownPass: ownPass,
+ file: file
+ };
+}
+
+function assertNoDuplicates(items) {
+ var map = new Map();
+
+ for (var _iterator = items, _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;
+ }
+
+ var item = _ref2;
+ if (typeof item.value !== "function") continue;
+ var 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 0000000..657068c
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/files/configuration.js
@@ -0,0 +1,283 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.findRelativeConfig = findRelativeConfig;
+exports.findRootConfig = findRootConfig;
+exports.loadConfig = loadConfig;
+
+function _debug() {
+ var data = _interopRequireDefault(require("debug"));
+
+ _debug = function _debug() {
+ return data;
+ };
+
+ return data;
+}
+
+function _path() {
+ var data = _interopRequireDefault(require("path"));
+
+ _path = function _path() {
+ return data;
+ };
+
+ return data;
+}
+
+function _fs() {
+ var data = _interopRequireDefault(require("fs"));
+
+ _fs = function _fs() {
+ return data;
+ };
+
+ return data;
+}
+
+function _json() {
+ var data = _interopRequireDefault(require("json5"));
+
+ _json = function _json() {
+ return data;
+ };
+
+ return data;
+}
+
+function _resolve() {
+ var 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 }; }
+
+var debug = (0, _debug().default)("babel:config:loading:files:configuration");
+var BABEL_CONFIG_JS_FILENAME = "babel.config.js";
+var BABELRC_FILENAME = ".babelrc";
+var BABELRC_JS_FILENAME = ".babelrc.js";
+var BABELIGNORE_FILENAME = ".babelignore";
+
+function findRelativeConfig(packageData, envName) {
+ var config = null;
+ var ignore = null;
+
+ var dirname = _path().default.dirname(packageData.filepath);
+
+ var _loop = function _loop() {
+ if (_isArray) {
+ if (_i >= _iterator.length) return "break";
+ _ref = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) return "break";
+ _ref = _i.value;
+ }
+
+ var loc = _ref;
+
+ if (!config) {
+ config = [BABELRC_FILENAME, BABELRC_JS_FILENAME].reduce(function (previousConfig, name) {
+ var filepath = _path().default.join(loc, name);
+
+ var 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);
+ var 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) {
+ var ignoreLoc = _path().default.join(loc, BABELIGNORE_FILENAME);
+
+ ignore = readIgnoreConfig(ignoreLoc);
+
+ if (ignore) {
+ debug("Found ignore %o from %o.", ignore.filepath, dirname);
+ }
+ }
+ };
+
+ for (var _iterator = packageData.directories, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+ var _ref;
+
+ var _ret = _loop();
+
+ if (_ret === "break") break;
+ }
+
+ return {
+ config: config,
+ ignore: ignore
+ };
+}
+
+function findRootConfig(dirname, envName) {
+ var filepath = _path().default.resolve(dirname, BABEL_CONFIG_JS_FILENAME);
+
+ var 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) {
+ var filepath = _resolve().default.sync(name, {
+ basedir: dirname
+ });
+
+ var 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: envName
+ }) : readConfigJSON5(filepath);
+}
+
+var LOADING_CONFIGS = new Set();
+var readConfigJS = (0, _caching.makeStrongCache)(function (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: filepath,
+ dirname: _path().default.dirname(filepath),
+ options: {}
+ };
+ }
+
+ var options;
+
+ try {
+ LOADING_CONFIGS.add(filepath);
+
+ var 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: filepath,
+ dirname: _path().default.dirname(filepath),
+ options: options
+ };
+});
+var packageToBabelConfig = (0, _caching.makeWeakCache)(function (file) {
+ if (typeof file.options.babel === "undefined") return null;
+ var 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
+ };
+});
+var readConfigJSON5 = (0, _utils.makeStaticFileCache)(function (filepath, content) {
+ var 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: filepath,
+ dirname: _path().default.dirname(filepath),
+ options: options
+ };
+});
+var readIgnoreConfig = (0, _utils.makeStaticFileCache)(function (filepath, content) {
+ var ignore = content.split("\n").map(function (line) {
+ return line.replace(/#(.*?)$/, "").trim();
+ }).filter(function (line) {
+ return !!line;
+ });
+ return {
+ filepath: filepath,
+ dirname: _path().default.dirname(filepath),
+ ignore: ignore
+ };
+});
+
+function throwConfigError() {
+ throw new Error("Caching was left unconfigured. Babel's plugins, presets, and .babelrc.js files can be configured\nfor various types of caching, using the first param of their handler functions:\n\nmodule.exports = function(api) {\n // The API exposes the following:\n\n // Cache the returned value forever and don't call this function again.\n api.cache(true);\n\n // Don't cache at all. Not recommended because it will be very slow.\n api.cache(false);\n\n // Cached based on the value of some function. If this function returns a value different from\n // a previously-encountered value, the plugins will re-evaluate.\n var env = api.cache(() => process.env.NODE_ENV);\n\n // If testing for a specific env, we recommend specifics to avoid instantiating a plugin for\n // any possible NODE_ENV value that might come up during plugin execution.\n var isProd = api.cache(() => process.env.NODE_ENV === \"production\");\n\n // .cache(fn) will perform a linear search though instances to find the matching plugin based\n // based on previous instantiated plugins. If you want to recreate the plugin and discard the\n // previous instance whenever something changes, you may use:\n var isProd = api.cache.invalidate(() => process.env.NODE_ENV === \"production\");\n\n // Note, we also expose the following more-verbose versions of the above examples:\n api.cache.forever(); // api.cache(true)\n api.cache.never(); // api.cache(false)\n api.cache.using(fn); // api.cache(fn)\n\n // Return the value that will be cached.\n return { };\n};");
+}
\ 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 0000000..fc5e333
--- /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: 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 0000000..25c3008
--- /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 0000000..8ebf43a
--- /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() {
+ var 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 }; }
+
+var PACKAGE_FILENAME = "package.json";
+
+function findPackageData(filepath) {
+ var pkg = null;
+ var directories = [];
+ var isPackage = true;
+
+ var dirname = _path().default.dirname(filepath);
+
+ while (!pkg && _path().default.basename(dirname) !== "node_modules") {
+ directories.push(dirname);
+ pkg = readConfigPackage(_path().default.join(dirname, PACKAGE_FILENAME));
+
+ var nextLoc = _path().default.dirname(dirname);
+
+ if (dirname === nextLoc) {
+ isPackage = false;
+ break;
+ }
+
+ dirname = nextLoc;
+ }
+
+ return {
+ filepath: filepath,
+ directories: directories,
+ pkg: pkg,
+ isPackage: isPackage
+ };
+}
+
+var readConfigPackage = (0, _utils.makeStaticFileCache)(function (filepath, content) {
+ var 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: filepath,
+ dirname: _path().default.dirname(filepath),
+ options: 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 0000000..b567cbc
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/files/plugins.js
@@ -0,0 +1,172 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.resolvePlugin = resolvePlugin;
+exports.resolvePreset = resolvePreset;
+exports.loadPlugin = loadPlugin;
+exports.loadPreset = loadPreset;
+
+function _debug() {
+ var data = _interopRequireDefault(require("debug"));
+
+ _debug = function _debug() {
+ return data;
+ };
+
+ return data;
+}
+
+function _resolve() {
+ var data = _interopRequireDefault(require("resolve"));
+
+ _resolve = function _resolve() {
+ return data;
+ };
+
+ return data;
+}
+
+function _path() {
+ var data = _interopRequireDefault(require("path"));
+
+ _path = function _path() {
+ return data;
+ };
+
+ return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var debug = (0, _debug().default)("babel:config:loading:files:plugins");
+var EXACT_RE = /^module:/;
+var BABEL_PLUGIN_PREFIX_RE = /^(?!@|module:|[^/]+\/|babel-plugin-)/;
+var BABEL_PRESET_PREFIX_RE = /^(?!@|module:|[^/]+\/|babel-preset-)/;
+var BABEL_PLUGIN_ORG_RE = /^(@babel\/)(?!plugin-|[^/]+\/)/;
+var BABEL_PRESET_ORG_RE = /^(@babel\/)(?!preset-|[^/]+\/)/;
+var OTHER_PLUGIN_ORG_RE = /^(@(?!babel\/)[^/]+\/)(?!babel-plugin-|[^/]+\/)/;
+var 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) {
+ var filepath = resolvePlugin(name, dirname);
+
+ if (!filepath) {
+ throw new Error("Plugin " + name + " not found relative to " + dirname);
+ }
+
+ var value = requireModule("plugin", filepath);
+ debug("Loaded plugin %o from %o.", name, dirname);
+ return {
+ filepath: filepath,
+ value: value
+ };
+}
+
+function loadPreset(name, dirname) {
+ var filepath = resolvePreset(name, dirname);
+
+ if (!filepath) {
+ throw new Error("Preset " + name + " not found relative to " + dirname);
+ }
+
+ var value = requireModule("preset", filepath);
+ debug("Loaded preset %o from %o.", name, dirname);
+ return {
+ filepath: filepath,
+ value: value
+ };
+}
+
+function standardizeName(type, name) {
+ if (_path().default.isAbsolute(name)) return name;
+ var 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) {
+ if (dirname === void 0) {
+ dirname = process.cwd();
+ }
+
+ var 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) {
+ var 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 + "\"";
+ }
+ }
+
+ var 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 + "\"?";
+ }
+
+ var resolvedOppositeType = false;
+ var 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;
+ }
+}
+
+var 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 0000000..9a390c3
--- /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 0000000..7fc8903
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/files/utils.js
@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.makeStaticFileCache = makeStaticFileCache;
+
+function _fs() {
+ var 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)(function (filepath, cache) {
+ if (cache.invalidate(function () {
+ return 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 0000000..00749f2
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/full.js
@@ -0,0 +1,281 @@
+"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() {
+ var 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) {
+ var result = (0, _partial.default)(inputOpts);
+
+ if (!result) {
+ return null;
+ }
+
+ var options = result.options,
+ context = result.context;
+ var optionDefaults = {};
+ var passes = [[]];
+
+ try {
+ var plugins = options.plugins,
+ presets = options.presets;
+
+ if (!plugins || !presets) {
+ throw new Error("Assertion failure - plugins and presets exist");
+ }
+
+ var ignored = function recurseDescriptors(config, pass) {
+ var plugins = config.plugins.map(function (descriptor) {
+ return loadPluginDescriptor(descriptor, context);
+ });
+ var presets = config.presets.map(function (descriptor) {
+ return {
+ preset: loadPresetDescriptor(descriptor, context),
+ pass: descriptor.ownPass ? [] : pass
+ };
+ });
+
+ if (presets.length > 0) {
+ passes.splice.apply(passes, [1, 0].concat(presets.map(function (o) {
+ return o.pass;
+ }).filter(function (p) {
+ return 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;
+ }
+
+ var _ref3 = _ref2;
+ var preset = _ref3.preset,
+ _pass = _ref3.pass;
+ if (!preset) return true;
+
+ var _ignored = recurseDescriptors({
+ plugins: preset.plugins,
+ presets: preset.presets
+ }, _pass);
+
+ if (_ignored) return true;
+ preset.options.forEach(function (opts) {
+ (0, _util.mergeOptions)(optionDefaults, opts);
+ });
+ }
+ }
+
+ if (plugins.length > 0) {
+ pass.unshift.apply(pass, plugins);
+ }
+ }({
+ plugins: plugins.map(function (item) {
+ var desc = (0, _item.getItemDescriptor)(item);
+
+ if (!desc) {
+ throw new Error("Assertion failure - must be config item");
+ }
+
+ return desc;
+ }),
+ presets: presets.map(function (item) {
+ var 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;
+ }
+
+ var opts = optionDefaults;
+ (0, _util.mergeOptions)(opts, options);
+ opts.plugins = passes[0];
+ opts.presets = passes.slice(1).filter(function (plugins) {
+ return plugins.length > 0;
+ }).map(function (plugins) {
+ return {
+ plugins: plugins
+ };
+ });
+ opts.passPerPreset = opts.presets.length > 0;
+ return {
+ options: opts,
+ passes: passes
+ };
+}
+
+var loadDescriptor = (0, _caching.makeWeakCache)(function (_ref4, cache) {
+ var value = _ref4.value,
+ options = _ref4.options,
+ dirname = _ref4.dirname,
+ alias = _ref4.alias;
+ if (options === false) throw new Error("Assertion failure");
+ options = options || {};
+ var item = value;
+
+ if (typeof value === "function") {
+ var 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: options,
+ dirname: dirname,
+ alias: 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);
+}
+
+var instantiatePlugin = (0, _caching.makeWeakCache)(function (_ref5, cache) {
+ var value = _ref5.value,
+ options = _ref5.options,
+ dirname = _ref5.dirname,
+ alias = _ref5.alias;
+ var pluginObj = (0, _plugins.validatePluginObject)(value);
+ var plugin = Object.assign({}, pluginObj);
+
+ if (plugin.visitor) {
+ plugin.visitor = _traverse().default.explode(Object.assign({}, plugin.visitor));
+ }
+
+ if (plugin.inherits) {
+ var inheritsDescriptor = {
+ name: undefined,
+ alias: alias + "$inherits",
+ value: plugin.inherits,
+ options: options,
+ dirname: dirname
+ };
+ var inherits = cache.invalidate(function (data) {
+ return 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);
+});
+
+var loadPresetDescriptor = function loadPresetDescriptor(descriptor, context) {
+ return (0, _configChain.buildPresetChain)(instantiatePreset(loadDescriptor(descriptor, context)), context);
+};
+
+var instantiatePreset = (0, _caching.makeWeakCache)(function (_ref6) {
+ var value = _ref6.value,
+ dirname = _ref6.dirname,
+ alias = _ref6.alias;
+ return {
+ options: (0, _options.validate)("preset", value),
+ alias: alias,
+ dirname: dirname
+ };
+});
+
+function chain(a, b) {
+ var fns = [a, b].filter(Boolean);
+ if (fns.length <= 1) return fns[0];
+ return function () {
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ for (var _iterator2 = fns, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+ var _ref7;
+
+ if (_isArray2) {
+ if (_i2 >= _iterator2.length) break;
+ _ref7 = _iterator2[_i2++];
+ } else {
+ _i2 = _iterator2.next();
+ if (_i2.done) break;
+ _ref7 = _i2.value;
+ }
+
+ var fn = _ref7;
+ 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 0000000..22a4b00
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/helpers/config-api.js
@@ -0,0 +1,80 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = makeAPI;
+
+function _semver() {
+ var 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) {
+ var env = function env(value) {
+ return cache.using(function (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(function (entry) {
+ if (typeof entry !== "string") {
+ throw new Error("Unexpected non-string value");
+ }
+
+ return entry === data.envName;
+ });
+ });
+ };
+
+ return {
+ version: _.version,
+ cache: cache.simple(),
+ env: env,
+ async: function async() {
+ return false;
+ },
+ assertVersion: 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;
+ var limit = Error.stackTraceLimit;
+
+ if (typeof limit === "number" && limit < 25) {
+ Error.stackTraceLimit = 25;
+ }
+
+ var 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: 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 0000000..fa186d3
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/helpers/environment.js
@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.getEnv = getEnv;
+
+function getEnv(defaultValue) {
+ if (defaultValue === void 0) {
+ 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 0000000..0f42c9c
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/index.js
@@ -0,0 +1,44 @@
+"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) {
+ var config = (0, _full.default)(opts);
+ return config ? config.options : null;
+}
+
+var OptionManager = function () {
+ function OptionManager() {}
+
+ var _proto = OptionManager.prototype;
+
+ _proto.init = function init(opts) {
+ return loadOptions(opts);
+ };
+
+ return OptionManager;
+}();
+
+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 0000000..59f1e5c
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/item.js
@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.createItemFromDescriptor = createItemFromDescriptor;
+exports.createConfigItem = createConfigItem;
+exports.getItemDescriptor = getItemDescriptor;
+
+function _path() {
+ var 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, _temp) {
+ var _ref = _temp === void 0 ? {} : _temp,
+ _ref$dirname = _ref.dirname,
+ dirname = _ref$dirname === void 0 ? "." : _ref$dirname,
+ type = _ref.type;
+
+ var descriptor = (0, _configDescriptors.createDescriptor)(value, _path().default.resolve(dirname), {
+ type: type,
+ alias: "programmatic item"
+ });
+ return createItemFromDescriptor(descriptor);
+}
+
+function getItemDescriptor(item) {
+ if (item instanceof ConfigItem) {
+ return item._descriptor;
+ }
+
+ return undefined;
+}
+
+var ConfigItem = function ConfigItem(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 0000000..5133ca6
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/partial.js
@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = loadPrivatePartialConfig;
+exports.loadPartialConfig = loadPartialConfig;
+
+function _path() {
+ var 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");
+ }
+
+ var args = inputOpts ? (0, _options.validate)("arguments", inputOpts) : {};
+ var _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;
+
+ var absoluteCwd = _path().default.resolve(cwd);
+
+ var context = {
+ filename: args.filename ? _path().default.resolve(cwd, args.filename) : null,
+ cwd: absoluteCwd,
+ envName: envName
+ };
+ var configChain = (0, _configChain.buildRootChain)(args, context);
+ if (!configChain) return null;
+ var options = {};
+ configChain.options.forEach(function (opts) {
+ (0, _util.mergeOptions)(options, opts);
+ });
+ options.babelrc = false;
+ options.envName = envName;
+ options.cwd = absoluteCwd;
+ options.passPerPreset = false;
+ options.plugins = configChain.plugins.map(function (descriptor) {
+ return (0, _item.createItemFromDescriptor)(descriptor);
+ });
+ options.presets = configChain.presets.map(function (descriptor) {
+ return (0, _item.createItemFromDescriptor)(descriptor);
+ });
+ return {
+ options: options,
+ context: context,
+ ignore: configChain.ignore,
+ babelrc: configChain.babelrc,
+ config: configChain.config
+ };
+}
+
+function loadPartialConfig(inputOpts) {
+ var result = loadPrivatePartialConfig(inputOpts);
+ if (!result) return null;
+ var options = result.options,
+ babelrc = result.babelrc,
+ ignore = result.ignore,
+ config = result.config;
+ (options.plugins || []).forEach(function (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);
+}
+
+var PartialConfig = function () {
+ function PartialConfig(options, babelrc, ignore, config) {
+ this.options = options;
+ this.babelignore = ignore;
+ this.babelrc = babelrc;
+ this.config = config;
+ Object.freeze(this);
+ }
+
+ var _proto = PartialConfig.prototype;
+
+ _proto.hasFilesystemConfig = function hasFilesystemConfig() {
+ return this.babelrc !== undefined || this.config !== undefined;
+ };
+
+ return PartialConfig;
+}();
+
+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 0000000..6f0d0ad
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/plugin.js
@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+
+var Plugin = function Plugin(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 0000000..966be40
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/util.js
@@ -0,0 +1,39 @@
+"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++) {
+ var k = _arr[_i];
+
+ if (k === "parserOpts" && source.parserOpts) {
+ var parserOpts = source.parserOpts;
+ var targetObj = target.parserOpts = target.parserOpts || {};
+ mergeDefaultFields(targetObj, parserOpts);
+ } else if (k === "generatorOpts" && source.generatorOpts) {
+ var generatorOpts = source.generatorOpts;
+
+ var _targetObj = target.generatorOpts = target.generatorOpts || {};
+
+ mergeDefaultFields(_targetObj, generatorOpts);
+ } else {
+ var 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++) {
+ var k = _arr2[_i2];
+ var 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 0000000..4bed019
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/validation/option-assertions.js
@@ -0,0 +1,209 @@
+"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) {
+ var arr = assertArray(key, value);
+
+ if (arr) {
+ arr.forEach(function (item, i) {
+ return 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(function (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(function (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) {
+ var arr = assertArray(key, value);
+
+ if (arr) {
+ arr.forEach(function (item, i) {
+ return 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) {
+ var 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) {
+ var 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 0000000..d3b59ed
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/validation/options.js
@@ -0,0 +1,163 @@
+"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 }; }
+
+var ROOT_VALIDATORS = {
+ cwd: _optionAssertions.assertString,
+ root: _optionAssertions.assertString,
+ configFile: _optionAssertions.assertConfigFileSearch,
+ filename: _optionAssertions.assertString,
+ filenameRelative: _optionAssertions.assertString,
+ babelrc: _optionAssertions.assertBoolean,
+ babelrcRoots: _optionAssertions.assertBabelrcSearch,
+ code: _optionAssertions.assertBoolean,
+ ast: _optionAssertions.assertBoolean,
+ envName: _optionAssertions.assertString
+};
+var NONPRESET_VALIDATORS = {
+ extends: _optionAssertions.assertString,
+ env: assertEnvSet,
+ ignore: _optionAssertions.assertIgnoreList,
+ only: _optionAssertions.assertIgnoreList,
+ overrides: assertOverridesList,
+ test: _optionAssertions.assertConfigApplicableTest,
+ include: _optionAssertions.assertConfigApplicableTest,
+ exclude: _optionAssertions.assertConfigApplicableTest
+};
+var 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(function (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 === "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");
+ }
+
+ var validator = COMMON_VALIDATORS[key] || NONPRESET_VALIDATORS[key] || ROOT_VALIDATORS[key];
+ if (validator) validator(key, opts[key]);else throw buildUnknownError(key);
+ });
+ return opts;
+}
+
+function buildUnknownError(key) {
+ if (_removed.default[key]) {
+ var _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 {
+ var 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) {
+ var obj = (0, _optionAssertions.assertObject)(key, value);
+
+ if (obj) {
+ var _arr = Object.keys(obj);
+
+ for (var _i = 0; _i < _arr.length; _i++) {
+ var _key = _arr[_i];
+
+ var _env = (0, _optionAssertions.assertObject)(_key, obj[_key]);
+
+ if (_env) validate("env", _env);
+ }
+ }
+
+ return obj;
+}
+
+function assertOverridesList(key, value) {
+ var 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;
+ }
+
+ var _ref2 = _ref,
+ index = _ref2[0],
+ item = _ref2[1];
+
+ var _env2 = (0, _optionAssertions.assertObject)("" + index, item);
+
+ if (!_env2) throw new Error("." + key + "[" + index + "] must be an object");
+ validate("override", _env2);
+ }
+ }
+
+ 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 0000000..dac27c0
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/validation/plugins.js
@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.validatePluginObject = validatePluginObject;
+
+var _optionAssertions = require("./option-assertions");
+
+var 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) {
+ var obj = (0, _optionAssertions.assertObject)(key, value);
+
+ if (obj) {
+ Object.keys(obj).forEach(function (prop) {
+ return 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(function (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(function (key) {
+ var 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 0000000..f0fcd7d
--- /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 0000000..88b683d
--- /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() {
+ var 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() {
+ var data = _interopRequireDefault(require("@babel/traverse"));
+
+ _traverse = function _traverse() {
+ return data;
+ };
+
+ return data;
+}
+
+function _template() {
+ var 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.");
+}
+
+var 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 0000000..71b4b77
--- /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) {
+ var config = (0, _config.default)(opts);
+
+ if (config === null) {
+ return null;
+ }
+
+ var 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 0000000..d85daee
--- /dev/null
+++ b/node_modules/@babel/core/lib/tools/build-external-helpers.js
@@ -0,0 +1,142 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = _default;
+
+function helpers() {
+ var data = _interopRequireWildcard(require("@babel/helpers"));
+
+ helpers = function helpers() {
+ return data;
+ };
+
+ return data;
+}
+
+function _generator() {
+ var data = _interopRequireDefault(require("@babel/generator"));
+
+ _generator = function _generator() {
+ return data;
+ };
+
+ return data;
+}
+
+function _template() {
+ var data = _interopRequireDefault(require("@babel/template"));
+
+ _template = function _template() {
+ return data;
+ };
+
+ return data;
+}
+
+function t() {
+ var data = _interopRequireWildcard(require("@babel/types"));
+
+ t = function t() {
+ return data;
+ };
+
+ return data;
+}
+
+var _templateObject = _taggedTemplateLiteralLoose(["\n (function (root, factory) {\n if (typeof define === \"function\" && define.amd) {\n define(AMD_ARGUMENTS, factory);\n } else if (typeof exports === \"object\") {\n factory(COMMON_ARGUMENTS);\n } else {\n factory(BROWSER_ARGUMENTS);\n }\n })(UMD_ROOT, function (FACTORY_PARAMETERS) {\n FACTORY_BODY\n });\n "]);
+
+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 _taggedTemplateLiteralLoose(strings, raw) { if (!raw) { raw = strings.slice(0); } strings.raw = raw; return strings; }
+
+var buildUmdWrapper = function buildUmdWrapper(replacements) {
+ return (0, _template().default)(_templateObject)(replacements);
+};
+
+function buildGlobal(whitelist) {
+ var namespace = t().identifier("babelHelpers");
+ var body = [];
+ var container = t().functionExpression(null, [t().identifier("global")], t().blockStatement(body));
+ var 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) {
+ var body = [];
+ var refs = buildHelpers(body, null, whitelist);
+ body.unshift(t().exportNamedDeclaration(null, Object.keys(refs).map(function (name) {
+ return t().exportSpecifier(t().cloneNode(refs[name]), t().identifier(name));
+ })));
+ return t().program(body, [], "module");
+}
+
+function buildUmd(whitelist) {
+ var namespace = t().identifier("babelHelpers");
+ var 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) {
+ var namespace = t().identifier("babelHelpers");
+ var body = [];
+ body.push(t().variableDeclaration("var", [t().variableDeclarator(namespace, t().objectExpression([]))]));
+ var tree = t().program(body);
+ buildHelpers(body, namespace, whitelist);
+ body.push(t().expressionStatement(namespace));
+ return tree;
+}
+
+function buildHelpers(body, namespace, whitelist) {
+ var getHelperReference = function getHelperReference(name) {
+ return namespace ? t().memberExpression(namespace, t().identifier(name)) : t().identifier("_" + name);
+ };
+
+ var refs = {};
+ helpers().list.forEach(function (name) {
+ if (whitelist && whitelist.indexOf(name) < 0) return;
+ var ref = refs[name] = getHelperReference(name);
+
+ var _helpers$get = helpers().get(name, getHelperReference, ref),
+ nodes = _helpers$get.nodes;
+
+ body.push.apply(body, nodes);
+ });
+ return refs;
+}
+
+function _default(whitelist, outputType) {
+ if (outputType === void 0) {
+ outputType = "global";
+ }
+
+ var tree;
+ var 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 0000000..798d0cf
--- /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) {
+ var 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 0000000..be05fc7
--- /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);
+ var cb = callback;
+ process.nextTick(function () {
+ var 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 0000000..a2d0c72
--- /dev/null
+++ b/node_modules/@babel/core/lib/transform-file-browser.js
@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = transformFile;
+
+function transformFile(filename, opts, callback) {
+ if (opts === void 0) {
+ opts = {};
+ }
+
+ 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 0000000..3f5740d
--- /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 0000000..9a04ccc
--- /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() {
+ var 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) {
+ var options;
+
+ if (opts == null) {
+ options = {
+ filename: filename
+ };
+ } else if (opts && typeof opts === "object") {
+ options = Object.assign({}, opts, {
+ filename: filename
+ });
+ }
+
+ var 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 0000000..02f8006
--- /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() {
+ var 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) {
+ var options;
+
+ if (typeof opts === "function") {
+ callback = opts;
+ opts = undefined;
+ }
+
+ if (opts == null) {
+ options = {
+ filename: filename
+ };
+ } else if (opts && typeof opts === "object") {
+ options = Object.assign({}, opts, {
+ filename: filename
+ });
+ }
+
+ process.nextTick(function () {
+ var cfg;
+
+ try {
+ cfg = (0, _config.default)(options);
+ if (cfg === null) return callback(null, null);
+ } catch (err) {
+ return callback(err);
+ }
+
+ var 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 0000000..c5d1f8d
--- /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) {
+ var 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 0000000..8540cb4
--- /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);
+ var cb = callback;
+ process.nextTick(function () {
+ var 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 0000000..3bbf9b4
--- /dev/null
+++ b/node_modules/@babel/core/lib/transformation/block-hoist-plugin.js
@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = loadBlockHoistPlugin;
+
+function _sortBy() {
+ var 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 }; }
+
+var LOADED_PLUGIN;
+
+function loadBlockHoistPlugin() {
+ if (!LOADED_PLUGIN) {
+ var 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;
+}
+
+var blockHoistPlugin = {
+ name: "internal.blockHoist",
+ visitor: {
+ Block: {
+ exit: function exit(_ref) {
+ var node = _ref.node;
+ var hasChange = false;
+
+ for (var i = 0; i < node.body.length; i++) {
+ var bodyNode = node.body[i];
+
+ if (bodyNode && bodyNode._blockHoist != null) {
+ hasChange = true;
+ break;
+ }
+ }
+
+ if (!hasChange) return;
+ node.body = (0, _sortBy().default)(node.body, function (bodyNode) {
+ var 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 0000000..eba50b5
--- /dev/null
+++ b/node_modules/@babel/core/lib/transformation/file/file.js
@@ -0,0 +1,247 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+
+function helpers() {
+ var data = _interopRequireWildcard(require("@babel/helpers"));
+
+ helpers = function helpers() {
+ return data;
+ };
+
+ return data;
+}
+
+function _traverse() {
+ var data = _interopRequireWildcard(require("@babel/traverse"));
+
+ _traverse = function _traverse() {
+ return data;
+ };
+
+ return data;
+}
+
+function _codeFrame() {
+ var data = require("@babel/code-frame");
+
+ _codeFrame = function _codeFrame() {
+ return data;
+ };
+
+ return data;
+}
+
+function t() {
+ var 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; } }
+
+var errorVisitor = {
+ enter: function enter(path, state) {
+ var loc = path.node.loc;
+
+ if (loc) {
+ state.loc = loc;
+ path.stop();
+ }
+ }
+};
+
+var File = function () {
+ function File(options, _ref) {
+ var code = _ref.code,
+ ast = _ref.ast,
+ shebang = _ref.shebang,
+ inputMap = _ref.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;
+ }
+
+ var _proto = File.prototype;
+
+ _proto.set = function set(key, val) {
+ this._map.set(key, val);
+ };
+
+ _proto.get = function get(key) {
+ return this._map.get(key);
+ };
+
+ _proto.has = function has(key) {
+ return this._map.has(key);
+ };
+
+ _proto.getModuleName = function getModuleName() {
+ var _opts = this.opts,
+ filename = _opts.filename,
+ _opts$filenameRelativ = _opts.filenameRelative,
+ filenameRelative = _opts$filenameRelativ === void 0 ? filename : _opts$filenameRelativ,
+ moduleId = _opts.moduleId,
+ _opts$moduleIds = _opts.moduleIds,
+ moduleIds = _opts$moduleIds === void 0 ? !!moduleId : _opts$moduleIds,
+ getModuleId = _opts.getModuleId,
+ sourceRootTmp = _opts.sourceRoot,
+ _opts$moduleRoot = _opts.moduleRoot,
+ moduleRoot = _opts$moduleRoot === void 0 ? sourceRootTmp : _opts$moduleRoot,
+ _opts$sourceRoot = _opts.sourceRoot,
+ sourceRoot = _opts$sourceRoot === void 0 ? moduleRoot : _opts$sourceRoot;
+ if (!moduleIds) return null;
+
+ if (moduleId != null && !getModuleId) {
+ return moduleId;
+ }
+
+ var moduleName = moduleRoot != null ? moduleRoot + "/" : "";
+
+ if (filenameRelative) {
+ var 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;
+ }
+ };
+
+ _proto.resolveModuleSource = function resolveModuleSource(source) {
+ return source;
+ };
+
+ _proto.addImport = function 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'.");
+ };
+
+ _proto.addHelper = function addHelper(name) {
+ var _this = this;
+
+ var declar = this.declarations[name];
+ if (declar) return t().cloneNode(declar);
+ var generator = this.get("helperGenerator");
+ var runtime = this.get("helpersNamespace");
+
+ if (generator) {
+ var res = generator(name);
+ if (res) return res;
+ } else if (runtime) {
+ return t().memberExpression(t().cloneNode(runtime), t().identifier(name));
+ }
+
+ var uid = this.declarations[name] = this.scope.generateUidIdentifier(name);
+ var dependencies = {};
+
+ for (var _iterator = helpers().getDependencies(name), _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;
+ }
+
+ var dep = _ref2;
+ dependencies[dep] = this.addHelper(dep);
+ }
+
+ var _helpers$get = helpers().get(name, function (dep) {
+ return dependencies[dep];
+ }, uid, Object.keys(this.scope.getAllBindings())),
+ nodes = _helpers$get.nodes,
+ globals = _helpers$get.globals;
+
+ globals.forEach(function (name) {
+ if (_this.path.scope.hasBinding(name, true)) {
+ _this.path.scope.rename(name);
+ }
+ });
+ nodes.forEach(function (node) {
+ node._compact = true;
+ });
+ this.path.unshiftContainer("body", nodes);
+ this.path.get("body").forEach(function (path) {
+ if (nodes.indexOf(path.node) === -1) return;
+ if (path.isVariableDeclaration()) _this.scope.registerDeclaration(path);
+ });
+ return uid;
+ };
+
+ _proto.addTemplateObject = function addTemplateObject() {
+ throw new Error("This function has been moved into the template literal transform itself.");
+ };
+
+ _proto.buildCodeFrameError = function buildCodeFrameError(node, msg, Error) {
+ if (Error === void 0) {
+ Error = SyntaxError;
+ }
+
+ var loc = node && (node.loc || node._loc);
+ msg = this.opts.filename + ": " + msg;
+
+ if (!loc && node) {
+ var state = {
+ loc: null
+ };
+ (0, _traverse().default)(node, errorVisitor, this.scope, state);
+ loc = state.loc;
+ var txt = "This is an error on an internal node. Probably an internal error.";
+ if (loc) txt += " Location has been estimated.";
+ msg += " (" + txt + ")";
+ }
+
+ if (loc) {
+ var _opts$highlightCode = this.opts.highlightCode,
+ highlightCode = _opts$highlightCode === void 0 ? true : _opts$highlightCode;
+ msg += "\n" + (0, _codeFrame().codeFrameColumns)(this.code, {
+ start: {
+ line: loc.start.line,
+ column: loc.start.column + 1
+ }
+ }, {
+ highlightCode: highlightCode
+ });
+ }
+
+ return new Error(msg);
+ };
+
+ return File;
+}();
+
+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 0000000..216aa04
--- /dev/null
+++ b/node_modules/@babel/core/lib/transformation/file/generate.js
@@ -0,0 +1,155 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = generateCode;
+
+function _convertSourceMap() {
+ var data = _interopRequireDefault(require("convert-source-map"));
+
+ _convertSourceMap = function _convertSourceMap() {
+ return data;
+ };
+
+ return data;
+}
+
+function _sourceMap() {
+ var data = _interopRequireDefault(require("source-map"));
+
+ _sourceMap = function _sourceMap() {
+ return data;
+ };
+
+ return data;
+}
+
+function _generator() {
+ var data = _interopRequireDefault(require("@babel/generator"));
+
+ _generator = function _generator() {
+ return data;
+ };
+
+ return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function generateCode(pluginPasses, file) {
+ var opts = file.opts,
+ ast = file.ast,
+ shebang = file.shebang,
+ code = file.code,
+ inputMap = file.inputMap;
+ var 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;
+ }
+
+ var 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;
+ }
+
+ var plugin = _ref2;
+ var generatorOverride = plugin.generatorOverride;
+
+ if (generatorOverride) {
+ var _result2 = generatorOverride(ast, opts.generatorOpts, code, _generator().default);
+
+ if (_result2 !== undefined) results.push(_result2);
+ }
+ }
+ }
+
+ var 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.");
+ }
+
+ var _result = result,
+ outputCode = _result.code,
+ outputMap = _result.map;
+
+ if (shebang) {
+ outputCode = shebang + "\n" + outputCode;
+ }
+
+ if (outputMap && inputMap) {
+ outputMap = mergeSourceMap(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: outputCode,
+ outputMap: outputMap
+ };
+}
+
+function mergeSourceMap(inputMap, map) {
+ var inputMapConsumer = new (_sourceMap().default.SourceMapConsumer)(inputMap);
+ var outputMapConsumer = new (_sourceMap().default.SourceMapConsumer)(map);
+ var mergedGenerator = new (_sourceMap().default.SourceMapGenerator)({
+ file: inputMapConsumer.file,
+ sourceRoot: inputMapConsumer.sourceRoot
+ });
+ var source = outputMapConsumer.sources[0];
+ inputMapConsumer.eachMapping(function (mapping) {
+ var generatedPosition = outputMapConsumer.generatedPositionFor({
+ line: mapping.generatedLine,
+ column: mapping.generatedColumn,
+ source: source
+ });
+
+ if (generatedPosition.column != null) {
+ mergedGenerator.addMapping({
+ source: mapping.source,
+ original: mapping.source == null ? null : {
+ line: mapping.originalLine,
+ column: mapping.originalColumn
+ },
+ generated: generatedPosition,
+ name: mapping.name
+ });
+ }
+ });
+ var mergedMap = mergedGenerator.toJSON();
+ inputMap.mappings = mergedMap.mappings;
+ return inputMap;
+}
\ 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 0000000..02c8c66
--- /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() {
+ var 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) {
+ var result;
+
+ try {
+ result = runSync(config, code, ast);
+ } catch (err) {
+ return callback(err);
+ }
+
+ return callback(null, result);
+}
+
+function runSync(config, code, ast) {
+ var file = (0, _normalizeFile.default)(config.passes, (0, _normalizeOpts.default)(config), code, ast);
+ transformFile(file, config.passes);
+ var opts = file.opts;
+
+ var _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;
+ }
+
+ var pluginPairs = _ref2;
+ var passPairs = [];
+ var passes = [];
+ var 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;
+ }
+
+ var plugin = _ref3;
+ var 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++) {
+ var _passPairs$_i = passPairs[_i3],
+ _plugin = _passPairs$_i[0],
+ _pass = _passPairs$_i[1];
+ var fn = _plugin.pre;
+
+ if (fn) {
+ var 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.");
+ }
+ }
+ }
+
+ var 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++) {
+ var _passPairs$_i2 = passPairs[_i4],
+ _plugin2 = _passPairs$_i2[0],
+ _pass2 = _passPairs$_i2[1];
+ var _fn = _plugin2.post;
+
+ if (_fn) {
+ var _result = _fn.call(_pass2, 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 0000000..257089a
--- /dev/null
+++ b/node_modules/@babel/core/lib/transformation/normalize-file.js
@@ -0,0 +1,177 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = normalizeFile;
+
+function t() {
+ var data = _interopRequireWildcard(require("@babel/types"));
+
+ t = function t() {
+ return data;
+ };
+
+ return data;
+}
+
+function _convertSourceMap() {
+ var data = _interopRequireDefault(require("convert-source-map"));
+
+ _convertSourceMap = function _convertSourceMap() {
+ return data;
+ };
+
+ return data;
+}
+
+function _babylon() {
+ var data = require("babylon");
+
+ _babylon = function _babylon() {
+ return data;
+ };
+
+ return data;
+}
+
+function _codeFrame() {
+ var 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; } }
+
+var shebangRegex = /^#!.*/;
+
+function normalizeFile(pluginPasses, options, code, ast) {
+ code = "" + (code || "");
+ var shebang = null;
+ var 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);
+ }
+ }
+
+ var 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: code,
+ ast: ast,
+ shebang: shebang,
+ inputMap: inputMap
+ });
+}
+
+function parser(pluginPasses, options, code) {
+ try {
+ var 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;
+ }
+
+ var 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;
+ }
+
+ var plugin = _ref2;
+ var parserOverride = plugin.parserOverride;
+
+ if (parserOverride) {
+ var _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.";
+ }
+
+ var loc = err.loc,
+ missingPlugin = err.missingPlugin;
+
+ if (loc) {
+ var 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 0000000..b9b32e0
--- /dev/null
+++ b/node_modules/@babel/core/lib/transformation/normalize-opts.js
@@ -0,0 +1,96 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = normalizeOptions;
+
+function _path() {
+ var data = _interopRequireDefault(require("path"));
+
+ _path = function _path() {
+ return data;
+ };
+
+ return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function normalizeOptions(config) {
+ var _config$options = config.options,
+ filename = _config$options.filename,
+ _config$options$filen = _config$options.filenameRelative,
+ filenameRelative = _config$options$filen === void 0 ? 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 ? 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;
+ var opts = config.options;
+ var options = Object.assign({}, opts, {
+ parserOpts: Object.assign({
+ sourceType: _path().default.extname(filenameRelative) === ".mjs" ? "module" : sourceType,
+ sourceFileName: filename,
+ plugins: []
+ }, opts.parserOpts),
+ generatorOpts: Object.assign({
+ filename: filename,
+ auxiliaryCommentBefore: opts.auxiliaryCommentBefore,
+ auxiliaryCommentAfter: opts.auxiliaryCommentAfter,
+ retainLines: opts.retainLines,
+ comments: comments,
+ shouldPrintComment: opts.shouldPrintComment,
+ compact: compact,
+ minified: opts.minified,
+ sourceMaps: sourceMaps,
+ sourceRoot: sourceRoot,
+ sourceFileName: 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;
+ }
+
+ var 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;
+ }
+
+ var 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 0000000..d728858
--- /dev/null
+++ b/node_modules/@babel/core/lib/transformation/plugin-pass.js
@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+
+var PluginPass = function () {
+ function PluginPass(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;
+ }
+
+ var _proto = PluginPass.prototype;
+
+ _proto.set = function set(key, val) {
+ this._map.set(key, val);
+ };
+
+ _proto.get = function get(key) {
+ return this._map.get(key);
+ };
+
+ _proto.addHelper = function addHelper(name) {
+ return this.file.addHelper(name);
+ };
+
+ _proto.addImport = function addImport() {
+ return this.file.addImport();
+ };
+
+ _proto.getModuleName = function getModuleName() {
+ return this.file.getModuleName();
+ };
+
+ _proto.buildCodeFrameError = function buildCodeFrameError(node, msg, Error) {
+ return this.file.buildCodeFrameError(node, msg, Error);
+ };
+
+ return PluginPass;
+}();
+
+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 0000000..f66aecd
--- /dev/null
+++ b/node_modules/@babel/core/lib/transformation/util/missing-plugin-helper.js
@@ -0,0 +1,238 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = generateMissingPluginMessage;
+var 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"
+ }
+ }
+};
+
+var getNameURLCombination = function getNameURLCombination(_ref) {
+ var name = _ref.name,
+ url = _ref.url;
+ return name + " (" + url + ")";
+};
+
+function generateMissingPluginMessage(missingPluginName, loc, codeFrame) {
+ var helpMessage = "Support for the experimental syntax '" + missingPluginName + "' isn't currently enabled " + ("(" + loc.line + ":" + (loc.column + 1) + "):\n\n") + codeFrame;
+ var pluginInfo = pluginNameMap[missingPluginName];
+
+ if (pluginInfo) {
+ var syntaxPlugin = pluginInfo.syntax,
+ transformPlugin = pluginInfo.transform;
+
+ if (syntaxPlugin) {
+ if (transformPlugin) {
+ var transformPluginInfo = getNameURLCombination(transformPlugin);
+ helpMessage += "\n\nAdd " + transformPluginInfo + " to the 'plugins' section of your Babel config " + "to enable transformation.";
+ } else {
+ var 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 0000000..c2adc01
--- /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/babylon/CHANGELOG.md b/node_modules/@babel/core/node_modules/babylon/CHANGELOG.md
new file mode 100644
index 0000000..1e2bbac
--- /dev/null
+++ b/node_modules/@babel/core/node_modules/babylon/CHANGELOG.md
@@ -0,0 +1,1073 @@
+# Changelog
+
+> **Tags:**
+> - :boom: [Breaking Change]
+> - :eyeglasses: [Spec Compliancy]
+> - :rocket: [New Feature]
+> - :bug: [Bug Fix]
+> - :memo: [Documentation]
+> - :house: [Internal]
+> - :nail_care: [Polish]
+
+> Semver Policy: https://github.com/babel/babylon#semver
+
+_Note: Gaps between patch versions are faulty, broken or test releases._
+
+See the [Babel Changelog](https://github.com/babel/babel/blob/master/CHANGELOG.md) for the pre-6.8.0 version Changelog.
+
+## 6.17.1 (2017-05-10)
+
+### :bug: Bug Fix
+ * Fix typo in flow spread operator error (Brian Ng)
+ * Fixed invalid number literal parsing ([#473](https://github.com/babel/babylon/pull/473)) (Alex Kuzmenko)
+ * Fix number parser ([#433](https://github.com/babel/babylon/pull/433)) (Alex Kuzmenko)
+ * Ensure non pattern shorthand props are checked for reserved words ([#479](https://github.com/babel/babylon/pull/479)) (Brian Ng)
+ * Remove jsx context when parsing arrow functions ([#475](https://github.com/babel/babylon/pull/475)) (Brian Ng)
+ * Allow super in class properties ([#499](https://github.com/babel/babylon/pull/499)) (Brian Ng)
+ * Allow flow class field to be named constructor ([#510](https://github.com/babel/babylon/pull/510)) (Brian Ng)
+
+## 6.17.0 (2017-04-20)
+
+### :bug: Bug Fix
+ * Cherry-pick #418 to 6.x ([#476](https://github.com/babel/babylon/pull/476)) (Sebastian McKenzie)
+ * Add support for invalid escapes in tagged templates ([#274](https://github.com/babel/babylon/pull/274)) (Kevin Gibbons)
+ * Throw error if new.target is used outside of a function ([#402](https://github.com/babel/babylon/pull/402)) (Brian Ng)
+ * Fix parsing of class properties ([#351](https://github.com/babel/babylon/pull/351)) (Kevin Gibbons)
+ * Fix parsing yield with dynamicImport ([#383](https://github.com/babel/babylon/pull/383)) (Brian Ng)
+ * Ensure consistent start args for parseParenItem ([#386](https://github.com/babel/babylon/pull/386)) (Brian Ng)
+
+## 7.0.0-beta.8 (2017-04-04)
+
+### New Feature
+* Add support for flow type spread (#418) (Conrad Buck)
+* Allow statics in flow interfaces (#427) (Brian Ng)
+
+### Bug Fix
+* Fix predicate attachment to match flow parser (#428) (Brian Ng)
+* Add extra.raw back to JSXText and JSXAttribute (#344) (Alex Rattray)
+* Fix rest parameters with array and objects (#424) (Brian Ng)
+* Fix number parser (#433) (Alex Kuzmenko)
+
+### Docs
+* Fix CONTRIBUTING.md [skip ci] (#432) (Alex Kuzmenko)
+
+### Internal
+* Use babel-register script when running babel smoke tests (#442) (Brian Ng)
+
+## 7.0.0-beta.7 (2017-03-22)
+
+### Spec Compliancy
+* Remove babylon plugin for template revision since it's stage-4 (#426) (Henry Zhu)
+
+### Bug Fix
+
+* Fix push-pop logic in flow (#405) (Daniel Tschinder)
+
+## 7.0.0-beta.6 (2017-03-21)
+
+### New Feature
+* Add support for invalid escapes in tagged templates (#274) (Kevin Gibbons)
+
+### Polish
+* Improves error message when super is called outside of constructor (#408) (Arshabh Kumar Agarwal)
+
+### Docs
+
+* [7.0] Moved value field in spec from ObjectMember to ObjectProperty as ObjectMethod's don't have it (#415) [skip ci] (James Browning)
+
+## 7.0.0-beta.5 (2017-03-21)
+
+### Bug Fix
+* Throw error if new.target is used outside of a function (#402) (Brian Ng)
+* Fix parsing of class properties (#351) (Kevin Gibbons)
+
+### Other
+ * Test runner: Detect extra property in 'actual' but not in 'expected'. (#407) (Andy)
+ * Optimize travis builds (#419) (Daniel Tschinder)
+ * Update codecov to 2.0 (#412) (Daniel Tschinder)
+ * Fix spec for ClassMethod: It doesn't have a function, it *is* a function. (#406) [skip ci] (Andy)
+ * Changed Non-existent RestPattern to RestElement which is what is actually parsed (#409) [skip ci] (James Browning)
+ * Upgrade flow to 0.41 (Daniel Tschinder)
+ * Fix watch command (#403) (Brian Ng)
+ * Update yarn lock (Daniel Tschinder)
+ * Fix watch command (#403) (Brian Ng)
+ * chore(package): update flow-bin to version 0.41.0 (#395) (greenkeeper[bot])
+ * Add estree test for correct order of directives (Daniel Tschinder)
+ * Add DoExpression to spec (#364) (Alex Kuzmenko)
+ * Mention cloning of repository in CONTRIBUTING.md (#391) [skip ci] (Sumedh Nimkarde)
+ * Explain how to run only one test (#389) [skip ci] (Aaron Ang)
+
+ ## 7.0.0-beta.4 (2017-03-01)
+
+* Don't consume async when checking for async func decl (#377) (Brian Ng)
+* add `ranges` option [skip ci] (Henry Zhu)
+* Don't parse class properties without initializers when classProperties is disabled and Flow is enabled (#300) (Andrew Levine)
+
+## 7.0.0-beta.3 (2017-02-28)
+
+- [7.0] Change RestProperty/SpreadProperty to RestElement/SpreadElement (#384)
+- Merge changes from 6.x
+
+## 7.0.0-beta.2 (2017-02-20)
+
+- estree: correctly change literals in all cases (#368) (Daniel Tschinder)
+
+## 7.0.0-beta.1 (2017-02-20)
+
+- Fix negative number literal typeannotations (#366) (Daniel Tschinder)
+- Update contributing with more test info [skip ci] (#355) (Brian Ng)
+
+## 7.0.0-beta.0 (2017-02-15)
+
+- Reintroduce Variance node (#333) (Daniel Tschinder)
+- Rename NumericLiteralTypeAnnotation to NumberLiteralTypeAnnotation (#332) (Charles Pick)
+- [7.0] Remove ForAwaitStatement, add await flag to ForOfStatement (#349) (Brandon Dail)
+- chore(package): update ava to version 0.18.0 (#345) (greenkeeper[bot])
+- chore(package): update babel-plugin-istanbul to version 4.0.0 (#350) (greenkeeper[bot])
+- Change location of ObjectTypeIndexer to match flow (#228) (Daniel Tschinder)
+- Rename flow AST Type ExistentialTypeParam to ExistsTypeAnnotation (#322) (Toru Kobayashi)
+- Revert "Temporary rollback for erroring on trailing comma with spread (#154)" (#290) (Daniel Tschinder)
+- Remove classConstructorCall plugin (#291) (Brian Ng)
+- Update yarn.lock (Daniel Tschinder)
+- Update cross-env to 3.x (Daniel Tschinder)
+- [7.0] Remove node 0.10, 0.12 and 5 from Travis (#284) (Sergey Rubanov)
+- Remove `String.fromCodePoint` shim (#279) (Mathias Bynens)
+
+## 6.16.1 (2017-02-23)
+
+### :bug: Regression
+
+- Revert "Fix export default async function to be FunctionDeclaration" ([#375](https://github.com/babel/babylon/pull/375))
+
+Need to modify Babel for this AST node change, so moving to 7.0.
+
+- Revert "Don't parse class properties without initializers when classProperties plugin is disabled, and Flow is enabled" ([#376](https://github.com/babel/babylon/pull/376))
+
+[react-native](https://github.com/facebook/react-native/issues/12542) broke with this so we reverted.
+
+## 6.16.0 (2017-02-23)
+
+### :rocket: New Feature
+
+***ESTree*** compatibility as plugin ([#277](https://github.com/babel/babylon/pull/277)) (Daniel Tschinder)
+
+We finally introduce a new compatibility layer for ESTree. To put babylon into ESTree-compatible mode the new plugin `estree` can be enabled. In this mode the parser will output an AST that is compliant to the specs of [ESTree](https://github.com/estree/estree/)
+
+We highly recommend everyone who uses babylon outside of babel to use this plugin. This will make it much easier for users to switch between different ESTree-compatible parsers. We so far tested several projects with different parsers and exchanged their parser to babylon and in nearly all cases it worked out of the box. Some other estree-compatible parsers include `acorn`, `esprima`, `espree`, `flow-parser`, etc.
+
+To enable `estree` mode simply add the plugin in the config:
+```json
+{
+ "plugins": [ "estree" ]
+}
+```
+
+If you want to migrate your project from non-ESTree mode to ESTree, have a look at our [Readme](https://github.com/babel/babylon/#output), where all deviations are mentioned.
+
+Add a parseExpression public method ([#213](https://github.com/babel/babylon/pull/213)) (jeromew)
+
+Babylon exports a new function to parse a single expression
+
+```js
+import { parseExpression } from 'babylon';
+
+const ast = parseExpression('x || y && z', options);
+```
+
+The returned AST will only consist of the expression. The options are the same as for `parse()`
+
+Add startLine option ([#346](https://github.com/babel/babylon/pull/346)) (Raphael Mu)
+
+A new option was added to babylon allowing to change the intial linenumber for the first line which is usually `1`.
+Changing this for example to `100` will make line `1` of the input source to be marked as line `100`, line `2` as `101`, line `3` as `102`, ...
+
+Function predicate declaration ([#103](https://github.com/babel/babylon/pull/103)) (Panagiotis Vekris)
+
+Added support for function predicates which flow introduced in version 0.33.0
+
+```js
+declare function is_number(x: mixed): boolean %checks(typeof x === "number");
+```
+
+Allow imports in declare module ([#315](https://github.com/babel/babylon/pull/315)) (Daniel Tschinder)
+
+Added support for imports within module declarations which flow introduced in version 0.37.0
+
+```js
+declare module "C" {
+ import type { DT } from "D";
+ declare export type CT = { D: DT };
+}
+```
+
+### :eyeglasses: Spec Compliancy
+
+Forbid semicolons after decorators in classes ([#352](https://github.com/babel/babylon/pull/352)) (Kevin Gibbons)
+
+This example now correctly throws an error when there is a semicolon after the decorator:
+
+```js
+class A {
+@a;
+foo(){}
+}
+```
+
+Keywords are not allowed as local specifier ([#307](https://github.com/babel/babylon/pull/307)) (Daniel Tschinder)
+
+Using keywords in imports is not allowed anymore:
+
+```js
+import { default } from "foo";
+import { a as debugger } from "foo";
+```
+
+Do not allow overwritting of primitive types ([#314](https://github.com/babel/babylon/pull/314)) (Daniel Tschinder)
+
+In flow it is now forbidden to overwrite the primitve types `"any"`, `"mixed"`, `"empty"`, `"bool"`, `"boolean"`, `"number"`, `"string"`, `"void"` and `"null"` with your own type declaration.
+
+Disallow import type { type a } from … ([#305](https://github.com/babel/babylon/pull/305)) (Daniel Tschinder)
+
+The following code now correctly throws an error
+
+```js
+import type { type a } from "foo";
+```
+
+Don't parse class properties without initializers when classProperties is disabled and Flow is enabled ([#300](https://github.com/babel/babylon/pull/300)) (Andrew Levine)
+
+Ensure that you enable the `classProperties` plugin in order to enable correct parsing of class properties. Prior to this version it was possible to parse them by enabling the `flow` plugin but this was not intended the behaviour.
+
+If you enable the flow plugin you can only define the type of the class properties, but not initialize them.
+
+Fix export default async function to be FunctionDeclaration ([#324](https://github.com/babel/babylon/pull/324)) (Daniel Tschinder)
+
+Parsing the following code now returns a `FunctionDeclaration` AST node instead of `FunctionExpression`.
+
+```js
+export default async function bar() {};
+```
+
+### :nail_care: Polish
+
+Improve error message on attempt to destructure named import ([#288](https://github.com/babel/babylon/pull/288)) (Brian Ng)
+
+### :bug: Bug Fix
+
+Fix negative number literal typeannotations ([#366](https://github.com/babel/babylon/pull/366)) (Daniel Tschinder)
+
+Ensure takeDecorators is called on exported class ([#358](https://github.com/babel/babylon/pull/358)) (Brian Ng)
+
+ESTree: correctly change literals in all cases ([#368](https://github.com/babel/babylon/pull/368)) (Daniel Tschinder)
+
+Correctly convert RestProperty to Assignable ([#339](https://github.com/babel/babylon/pull/339)) (Daniel Tschinder)
+
+Fix #321 by allowing question marks in type params ([#338](https://github.com/babel/babylon/pull/338)) (Daniel Tschinder)
+
+Fix #336 by correctly setting arrow-param ([#337](https://github.com/babel/babylon/pull/337)) (Daniel Tschinder)
+
+Fix parse error when destructuring `set` with default value ([#317](https://github.com/babel/babylon/pull/317)) (Brian Ng)
+
+Fix ObjectTypeCallProperty static ([#298](https://github.com/babel/babylon/pull/298)) (Dan Harper)
+
+
+### :house: Internal
+
+Fix generator-method-with-computed-name spec ([#360](https://github.com/babel/babylon/pull/360)) (Alex Rattray)
+
+Fix flow type-parameter-declaration test with unintended semantic ([#361](https://github.com/babel/babylon/pull/361)) (Alex Rattray)
+
+Cleanup and splitup parser functions ([#295](https://github.com/babel/babylon/pull/295)) (Daniel Tschinder)
+
+chore(package): update flow-bin to version 0.38.0 ([#313](https://github.com/babel/babylon/pull/313)) (greenkeeper[bot])
+
+Call inner function instead of 1:1 copy to plugin ([#294](https://github.com/babel/babylon/pull/294)) (Daniel Tschinder)
+
+Update eslint-config-babel to the latest version 🚀 ([#299](https://github.com/babel/babylon/pull/299)) (greenkeeper[bot])
+
+Update eslint-config-babel to the latest version 🚀 ([#293](https://github.com/babel/babylon/pull/293)) (greenkeeper[bot])
+
+devDeps: remove eslint-plugin-babel ([#292](https://github.com/babel/babylon/pull/292)) (Kai Cataldo)
+
+Correct indent eslint rule config ([#276](https://github.com/babel/babylon/pull/276)) (Daniel Tschinder)
+
+Fail tests that have expected.json and throws-option ([#285](https://github.com/babel/babylon/pull/285)) (Daniel Tschinder)
+
+### :memo: Documentation
+
+Update contributing with more test info [skip ci] ([#355](https://github.com/babel/babylon/pull/355)) (Brian Ng)
+
+Update API documentation ([#330](https://github.com/babel/babylon/pull/330)) (Timothy Gu)
+
+Added keywords to package.json ([#323](https://github.com/babel/babylon/pull/323)) (Dmytro)
+
+AST spec: fix casing of `RegExpLiteral` ([#318](https://github.com/babel/babylon/pull/318)) (Mathias Bynens)
+
+## 6.15.0 (2017-01-10)
+
+### :eyeglasses: Spec Compliancy
+
+Add support for Flow shorthand import type ([#267](https://github.com/babel/babylon/pull/267)) (Jeff Morrison)
+
+This change implements flows new shorthand import syntax
+and where previously you had to write this code:
+
+```js
+import {someValue} from "blah";
+import type {someType} from "blah";
+import typeof {someOtherValue} from "blah";
+```
+
+you can now write it like this:
+
+```js
+import {
+ someValue,
+ type someType,
+ typeof someOtherValue,
+} from "blah";
+```
+
+For more information look at [this](https://github.com/facebook/flow/pull/2890) pull request.
+
+flow: allow leading pipes in all positions ([#256](https://github.com/babel/babylon/pull/256)) (Vladimir Kurchatkin)
+
+This change now allows a leading pipe everywhere types can be used:
+```js
+var f = (x): | 1 | 2 => 1;
+```
+
+Throw error when exporting non-declaration ([#241](https://github.com/babel/babylon/pull/241)) (Kai Cataldo)
+
+Previously babylon parsed the following exports, although they are not valid:
+```js
+export typeof foo;
+export new Foo();
+export function() {};
+export for (;;);
+export while(foo);
+```
+
+### :bug: Bug Fix
+
+Don't set inType flag when parsing property names ([#266](https://github.com/babel/babylon/pull/266)) (Vladimir Kurchatkin)
+
+This fixes parsing of this case:
+
+```js
+const map = {
+ [age <= 17] : 'Too young'
+};
+```
+
+Fix source location for JSXEmptyExpression nodes (fixes #248) ([#249](https://github.com/babel/babylon/pull/249)) (James Long)
+
+The following case produced an invalid AST
+```js
+