flow like the river

BACK_BACK/node_modules/parcel-bundler/lib/transforms/babel/astConverter.js

@@ -0,0 +1,101 @@
+"use strict";
+
+const traverse = require('@babel/traverse').default; // Convert between babel 7 and babel 6 AST
+// More info on the AST Changes: https://babeljs.io/docs/en/v7-migration-api#ast-changes
+
+
+function babel7toBabel6(ast) {
+  const visitor = {
+    ArrowFunctionExpression: node => {
+      node.expression = node.body.type !== 'BlockStatement';
+    },
+    ExistsTypeAnnotation: node => {
+      node.type = 'ExistentialTypeParam';
+    },
+    NumberLiteralTypeAnnotation: node => {
+      node.type = 'NumericLiteralTypeAnnotation';
+    },
+    ObjectTypeIndexer: node => {
+      node.end++;
+      node.loc.end.column++;
+    },
+    ForOfStatement: node => {
+      node.type = 'ForAwaitStatement';
+      delete node.await;
+    },
+    SpreadElement: (node, path) => {
+      if (path.parentPath.isObjectExpression() || path.parentPath.isArrayExpression()) {
+        node.type = 'SpreadProperty';
+      }
+    },
+    RestElement: (node, path) => {
+      if (path.parentPath.isObjectPattern() || path.parentPath.isArrayPattern()) {
+        node.type = 'RestProperty';
+      }
+    }
+  };
+  traverse(ast, {
+    enter(path) {
+      if (path.node.variance && path.node.variance.type === 'Variance') {
+        path.node.variance = path.node.variance.kind;
+      }
+
+      let visitorFunc = visitor[path.node.type];
+
+      if (visitorFunc) {
+        visitorFunc(path.node, path);
+      }
+    }
+
+  });
+  return ast;
+}
+
+function babel6toBabel7(ast) {
+  const visitor = {
+    ArrowFunctionExpression: node => {
+      delete node.expression;
+    },
+    ExistentialTypeParam: node => {
+      node.type = 'ExistsTypeAnnotation';
+    },
+    NumericLiteralTypeAnnotation: node => {
+      node.type = 'NumberLiteralTypeAnnotation';
+    },
+    ObjectTypeIndexer: node => {
+      node.end--;
+      node.loc.end.column--;
+    },
+    ForAwaitStatement: node => {
+      node.type = 'ForOfStatement';
+      node.await = true;
+    },
+    SpreadProperty: node => {
+      node.type = 'SpreadElement';
+    },
+    RestProperty: node => {
+      node.type = 'RestElement';
+    }
+  };
+  traverse(ast, {
+    enter(path) {
+      if (path.node.variance && typeof path.node.variance === 'string') {
+        path.node.variance = {
+          type: 'VarianceNode',
+          kind: path.node.variance
+        };
+      }
+
+      let visitorFunc = visitor[path.node.type];
+
+      if (visitorFunc) {
+        visitorFunc(path.node);
+      }
+    }
+
+  });
+  return ast;
+}
+
+exports.babel7toBabel6 = babel7toBabel6;
+exports.babel6toBabel7 = babel6toBabel7;

BACK_BACK/node_modules/parcel-bundler/lib/transforms/babel/babel6.js

@@ -0,0 +1,55 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+const localRequire = require('../../utils/localRequire');
+
+const _require = require('./astConverter'),
+      babel6toBabel7 = _require.babel6toBabel7;
+
+function babel6(_x, _x2) {
+  return _babel.apply(this, arguments);
+}
+
+function _babel() {
+  _babel = (0, _asyncToGenerator2.default)(function* (asset, options) {
+    let babel = yield localRequire('babel-core', asset.name);
+    let config = options.config;
+    config.code = false;
+    config.ast = true;
+    config.filename = asset.name;
+    config.babelrc = false;
+    config.parserOpts = Object.assign({}, config.parserOpts, {
+      allowReturnOutsideFunction: true,
+      allowHashBang: true,
+      ecmaVersion: Infinity,
+      strictMode: false,
+      sourceType: 'module',
+      locations: true
+    }); // Passing a list of plugins as part of parserOpts seems to override any custom
+    // syntax plugins a user might have added (e.g. decorators). We add dynamicImport
+    // using a plugin instead.
+
+    config.plugins = (config.plugins || []).concat(dynamicImport);
+    let res = babel.transform(asset.contents, config);
+
+    if (res.ast) {
+      asset.ast = babel6toBabel7(res.ast);
+      asset.isAstDirty = true;
+    }
+  });
+  return _babel.apply(this, arguments);
+}
+
+function dynamicImport() {
+  return {
+    manipulateOptions(opts, parserOpts) {
+      parserOpts.plugins.push('dynamicImport');
+    }
+
+  };
+}
+
+module.exports = babel6;

BACK_BACK/node_modules/parcel-bundler/lib/transforms/babel/babel7.js

@@ -0,0 +1,48 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+const localRequire = require('../../utils/localRequire');
+
+function babel7(_x, _x2) {
+  return _babel.apply(this, arguments);
+}
+
+function _babel() {
+  _babel = (0, _asyncToGenerator2.default)(function* (asset, options) {
+    let config = options.config; // If this is an internally generated config, use our internal @babel/core,
+    // otherwise require a local version from the package we're compiling.
+
+    let babel = options.internal ? require('@babel/core') : yield localRequire('@babel/core', asset.name);
+    let pkg = yield asset.getPackage();
+    config.code = false;
+    config.ast = true;
+    config.filename = asset.name;
+    config.cwd = pkg ? pkg.pkgdir : asset.options.rootDir;
+    config.babelrc = false;
+    config.configFile = false;
+    config.parserOpts = Object.assign({}, config.parserOpts, {
+      allowReturnOutsideFunction: true,
+      strictMode: false,
+      sourceType: 'module',
+      plugins: ['dynamicImport']
+    });
+    let res;
+
+    if (asset.ast) {
+      res = babel.transformFromAst(asset.ast, asset.contents, config);
+    } else {
+      res = babel.transformSync(asset.contents, config);
+    }
+
+    if (res.ast) {
+      asset.ast = res.ast;
+      asset.isAstDirty = true;
+    }
+  });
+  return _babel.apply(this, arguments);
+}
+
+module.exports = babel7;

BACK_BACK/node_modules/parcel-bundler/lib/transforms/babel/babelrc.js

@@ -0,0 +1,367 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+const semver = require('semver');
+
+const logger = require('@parcel/logger');
+
+const path = require('path');
+
+const localRequire = require('../../utils/localRequire');
+
+const installPackage = require('../../utils/installPackage');
+
+const fs = require('@parcel/fs');
+
+const micromatch = require('micromatch');
+
+function getBabelConfig(_x, _x2) {
+  return _getBabelConfig.apply(this, arguments);
+}
+
+function _getBabelConfig() {
+  _getBabelConfig = (0, _asyncToGenerator2.default)(function* (asset, isSource) {
+    let config = yield getBabelRc(asset, isSource);
+
+    if (!config) {
+      return null;
+    } // Ignore if the config is empty.
+
+
+    if ((!config.plugins || config.plugins.length === 0) && (!config.presets || config.presets.length === 0)) {
+      return null;
+    }
+
+    let plugins = yield installPlugins(asset, config);
+    let babelVersion = yield getBabelVersion(asset, plugins);
+    return {
+      babelVersion,
+      config
+    };
+  });
+  return _getBabelConfig.apply(this, arguments);
+}
+
+module.exports = getBabelConfig;
+/**
+ * Finds a .babelrc for an asset. By default, .babelrc files inside node_modules are not used.
+ * However, there are some exceptions:
+ *   - if `browserify.transforms` includes "babelify" in package.json (for legacy module compat)
+ *   - the `source` field in package.json is used by the resolver
+ */
+
+function getBabelRc(_x3, _x4) {
+  return _getBabelRc.apply(this, arguments);
+}
+
+function _getBabelRc() {
+  _getBabelRc = (0, _asyncToGenerator2.default)(function* (asset, isSource) {
+    // Support legacy browserify packages
+    let pkg = yield asset.getPackage();
+    let browserify = pkg && pkg.browserify;
+
+    if (browserify && Array.isArray(browserify.transform)) {
+      // Look for babelify in the browserify transform list
+      let babelify = browserify.transform.find(t => (Array.isArray(t) ? t[0] : t) === 'babelify'); // If specified as an array, override the config with the one specified
+
+      if (Array.isArray(babelify) && babelify[1]) {
+        return babelify[1];
+      } // Otherwise, return the .babelrc if babelify was found
+
+
+      return babelify ? findBabelRc(asset) : null;
+    } // If this asset is not in node_modules, always use the .babelrc
+
+
+    if (isSource) {
+      return findBabelRc(asset);
+    } // Otherwise, don't load .babelrc for node_modules.
+    // See https://github.com/parcel-bundler/parcel/issues/13.
+
+
+    return null;
+  });
+  return _getBabelRc.apply(this, arguments);
+}
+
+function findBabelRc(_x5) {
+  return _findBabelRc.apply(this, arguments);
+}
+
+function _findBabelRc() {
+  _findBabelRc = (0, _asyncToGenerator2.default)(function* (asset) {
+    // TODO: use the babel API to do this config resolution and support all of its features.
+    // This is not currently possible because babel tries to actually load plugins and presets
+    // while resolving the config, but those plugins might not be installed yet.
+    let config = yield asset.getConfig(['.babelrc', '.babelrc.js'], {
+      packageKey: 'babel'
+    });
+
+    if (!config) {
+      return null;
+    }
+
+    if (typeof config === 'function') {
+      // We cannot support function configs since there is no exposed method in babel
+      // to create the API that is passed to them...
+      throw new Error('Parcel does not support function configs in .babelrc.js yet.');
+    }
+
+    for (var _i = 0, _arr = ['extends', 'overrides', 'test', 'include', 'exclude']; _i < _arr.length; _i++) {
+      let key = _arr[_i];
+
+      if (config[key]) {
+        throw new Error(`Parcel does not support babel 7 advanced configuration option "${key}" yet.`);
+      }
+    } // Support ignore/only config options.
+
+
+    if (shouldIgnore(asset, config)) {
+      return null;
+    } // Support .babelignore
+
+
+    let ignoreConfig = yield getIgnoreConfig(asset);
+
+    if (ignoreConfig && shouldIgnore(asset, ignoreConfig)) {
+      return null;
+    }
+
+    return config;
+  });
+  return _findBabelRc.apply(this, arguments);
+}
+
+function getIgnoreConfig(_x6) {
+  return _getIgnoreConfig.apply(this, arguments);
+}
+
+function _getIgnoreConfig() {
+  _getIgnoreConfig = (0, _asyncToGenerator2.default)(function* (asset) {
+    let ignoreFile = yield asset.getConfig(['.babelignore'], {
+      load: false
+    });
+
+    if (!ignoreFile) {
+      return null;
+    }
+
+    let data = yield fs.readFile(ignoreFile, 'utf8');
+    let patterns = data.split('\n').map(line => line.replace(/#.*$/, '').trim()).filter(Boolean);
+    return {
+      ignore: patterns
+    };
+  });
+  return _getIgnoreConfig.apply(this, arguments);
+}
+
+function shouldIgnore(asset, config) {
+  if (config.ignore && matchesPatterns(config.ignore, asset.name)) {
+    return true;
+  }
+
+  if (config.only && !matchesPatterns(config.only, asset.name)) {
+    return true;
+  }
+
+  return false;
+}
+
+function matchesPatterns(patterns, path) {
+  return patterns.some(pattern => {
+    if (typeof pattern === 'function') {
+      return !!pattern(path);
+    }
+
+    if (typeof pattern === 'string') {
+      return micromatch.isMatch(path, '**/' + pattern + '/**');
+    }
+
+    return pattern.test(path);
+  });
+}
+
+function getBabelVersion(_x7, _x8) {
+  return _getBabelVersion.apply(this, arguments);
+}
+
+function _getBabelVersion() {
+  _getBabelVersion = (0, _asyncToGenerator2.default)(function* (asset, plugins) {
+    // Check the package.json to determine the babel version that is installed
+    let pkg = yield asset.getPackage();
+    let babelLegacy = getDependency(pkg, 'babel-core');
+    let babelModern = getDependency(pkg, '@babel/core');
+
+    if (babelModern) {
+      return getMaxMajor(babelModern);
+    }
+
+    if (babelLegacy) {
+      return 6;
+    } // No version was installed. This is either an old app where we didn't require a version to be installed,
+    // or a new app that just added a .babelrc without manually installing a version of babel core.
+    // We will attempt to infer a verison of babel and install it based on the dependencies of the plugins
+    // in the config. This should only happen once since we save babel core into package.json for subsequent runs.
+
+
+    let inferred = yield inferBabelVersion(asset, plugins);
+    let name = inferred === 6 ? 'babel-core' : `@babel/core`;
+    yield installPackage(name, asset.name);
+    return inferred;
+  });
+  return _getBabelVersion.apply(this, arguments);
+}
+
+function getDependency(pkg, dep) {
+  return pkg.dependencies && pkg.dependencies[dep] || pkg.peerDependencies && pkg.peerDependencies[dep] || pkg.devDependencies && pkg.devDependencies[dep];
+} // Core babel packages we use to infer the major version of babel to use.
+
+
+const CORE_DEPS = new Set(['@babel/core', '@babel/runtime', '@babel/template', '@babel/traverse', '@babel/types', '@babel/parser', '@babel/cli', '@babel/register', '@babel/generator', 'babel-core', 'babel-runtime', 'babel-template', 'babel-traverse', 'babel-types', 'babylon', 'babel-cli', 'babel-register', 'babel-generator']);
+
+function inferBabelVersion(_x9, _x10) {
+  return _inferBabelVersion.apply(this, arguments);
+}
+
+function _inferBabelVersion() {
+  _inferBabelVersion = (0, _asyncToGenerator2.default)(function* (asset, plugins) {
+    // Attempt to determine version based on dependencies of plugins
+    let version;
+
+    var _iterator = _createForOfIteratorHelper(plugins),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        let pkg = _step.value;
+
+        if (!pkg) {
+          continue;
+        }
+
+        var _iterator2 = _createForOfIteratorHelper(CORE_DEPS),
+            _step2;
+
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            let name = _step2.value;
+            let dep = getDependency(pkg, name);
+
+            if (dep) {
+              // Parse version range (ignore prerelease), and ensure it overlaps with the existing version (if any)
+              let range = new semver.Range(dep.replace(/-.*(\s|\|\||$)?/, ''));
+
+              if (version && !version.intersects(range)) {
+                throw new Error('Conflicting babel versions found in .babelrc. Make sure all of your plugins and presets depend on the same major version of babel.');
+              }
+
+              version = range;
+              break;
+            }
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+      } // Find the maximum major version allowed in the range and use that.
+      // e.g. if ^6 || ^7 were specified, use 7.
+
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    version = getMaxMajor(version);
+
+    if (!version) {
+      logger.warn(`Could not infer babel version. Defaulting to babel 7. Please add either babel-core or @babel/core as a dependency.`);
+      version = 7;
+    }
+
+    return version;
+  });
+  return _inferBabelVersion.apply(this, arguments);
+}
+
+function getPluginName(p) {
+  return Array.isArray(p) ? p[0] : p;
+}
+
+function getMaxMajor(version) {
+  try {
+    let range = new semver.Range(version);
+    let sorted = range.set.sort((a, b) => a[0].semver.compare(b[0].semver));
+    return semver.major(sorted.pop()[0].semver.version);
+  } catch (err) {
+    return null;
+  }
+}
+
+function installPlugins(_x11, _x12) {
+  return _installPlugins.apply(this, arguments);
+}
+
+function _installPlugins() {
+  _installPlugins = (0, _asyncToGenerator2.default)(function* (asset, babelrc) {
+    let presets = (babelrc.presets || []).map(p => resolveModule('preset', getPluginName(p), asset.name));
+    let plugins = (babelrc.plugins || []).map(p => resolveModule('plugin', getPluginName(p), asset.name));
+    return Promise.all([...presets, ...plugins]);
+  });
+  return _installPlugins.apply(this, arguments);
+}
+
+function resolveModule(_x13, _x14, _x15) {
+  return _resolveModule.apply(this, arguments);
+} // Copied from https://github.com/babel/babel/blob/3a399d1eb907df520f2b85bf9ddbc6533e256f6d/packages/babel-core/src/config/files/plugins.js#L61
+
+
+function _resolveModule() {
+  _resolveModule = (0, _asyncToGenerator2.default)(function* (type, name, path) {
+    try {
+      name = standardizeName(type, name);
+
+      let _yield$localRequire$r = yield localRequire.resolve(name, path),
+          _yield$localRequire$r2 = (0, _slicedToArray2.default)(_yield$localRequire$r, 2),
+          pkg = _yield$localRequire$r2[1];
+
+      return pkg;
+    } catch (err) {
+      return null;
+    }
+  });
+  return _resolveModule.apply(this, arguments);
+}
+
+const EXACT_RE = /^module:/;
+const BABEL_PLUGIN_PREFIX_RE = /^(?!@|module:|[^/]+\/|babel-plugin-)/;
+const BABEL_PRESET_PREFIX_RE = /^(?!@|module:|[^/]+\/|babel-preset-)/;
+const BABEL_PLUGIN_ORG_RE = /^(@babel\/)(?!plugin-|[^/]+\/)/;
+const BABEL_PRESET_ORG_RE = /^(@babel\/)(?!preset-|[^/]+\/)/;
+const OTHER_PLUGIN_ORG_RE = /^(@(?!babel\/)[^/]+\/)(?![^/]*babel-plugin(?:-|\/|$)|[^/]+\/)/;
+const OTHER_PRESET_ORG_RE = /^(@(?!babel\/)[^/]+\/)(?![^/]*babel-preset(?:-|\/|$)|[^/]+\/)/;
+const OTHER_ORG_DEFAULT_RE = /^(@(?!babel$)[^/]+)$/;
+
+function standardizeName(type, name) {
+  // Let absolute and relative paths through.
+  if (path.isAbsolute(name)) return name;
+  const isPreset = type === 'preset';
+  return name // foo -> babel-preset-foo
+  .replace(isPreset ? BABEL_PRESET_PREFIX_RE : BABEL_PLUGIN_PREFIX_RE, `babel-${type}-`) // @babel/es2015 -> @babel/preset-es2015
+  .replace(isPreset ? BABEL_PRESET_ORG_RE : BABEL_PLUGIN_ORG_RE, `$1${type}-`) // @foo/mypreset -> @foo/babel-preset-mypreset
+  .replace(isPreset ? OTHER_PRESET_ORG_RE : OTHER_PLUGIN_ORG_RE, `$1babel-${type}-`) // @foo -> @foo/babel-preset
+  .replace(OTHER_ORG_DEFAULT_RE, `$1/babel-${type}`) // module:mypreset -> mypreset
+  .replace(EXACT_RE, '');
+}

BACK_BACK/node_modules/parcel-bundler/lib/transforms/babel/config.js

@@ -0,0 +1,111 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+const getBabelRc = require('./babelrc');
+
+const getEnvConfig = require('./env');
+
+const getJSXConfig = require('./jsx');
+
+const getFlowConfig = require('./flow');
+
+const path = require('path');
+
+const fs = require('@parcel/fs');
+
+const NODE_MODULES = `${path.sep}node_modules${path.sep}`;
+
+const ENV_PLUGINS = require('@babel/preset-env/data/plugins');
+
+const ENV_PRESETS = {
+  es2015: true,
+  es2016: true,
+  es2017: true,
+  latest: true,
+  env: true,
+  '@babel/preset-env': true,
+  '@babel/env': true
+};
+
+function getBabelConfig(_x) {
+  return _getBabelConfig.apply(this, arguments);
+}
+
+function _getBabelConfig() {
+  _getBabelConfig = (0, _asyncToGenerator2.default)(function* (asset) {
+    // Consider the module source code rather than precompiled if the resolver
+    // used the `source` field, or it is not in node_modules.
+    let pkg = yield asset.getPackage();
+    let isSource = !!(pkg && pkg.source && (yield fs.realpath(asset.name)) !== asset.name) || !asset.name.includes(NODE_MODULES); // Try to resolve a .babelrc file. If one is found, consider the module source code.
+
+    let babelrc = yield getBabelRc(asset, isSource);
+    isSource = isSource || !!babelrc;
+    let envConfig = yield getEnvConfig(asset, isSource);
+    let jsxConfig = yield getJSXConfig(asset, isSource);
+    let flowConfig = getFlowConfig(asset, isSource);
+
+    if (babelrc && envConfig) {
+      // Filter out presets that are already applied by @babel/preset-env
+      if (Array.isArray(babelrc.config.presets)) {
+        babelrc.config.presets = babelrc.config.presets.filter(preset => {
+          return !ENV_PRESETS[getPluginName(preset)];
+        });
+      } // Filter out plugins that are already applied by @babel/preset-env
+
+
+      if (Array.isArray(babelrc.config.plugins)) {
+        babelrc.config.plugins = babelrc.config.plugins.filter(plugin => {
+          return !ENV_PLUGINS[getPluginName(plugin)];
+        });
+      }
+    }
+
+    let result = {};
+    mergeConfigs(result, babelrc);
+    mergeConfigs(result, envConfig); // Add JSX config if it isn't already specified in the babelrc
+
+    let hasReact = babelrc && (hasPlugin(babelrc.config.presets, ['react', '@babel/react', '@babel/preset-react']) || hasPlugin(babelrc.config.plugins, ['transform-react-jsx', '@babel/transform-react-jsx', '@babel/plugin-transform-react-jsx']));
+
+    if (!hasReact) {
+      mergeConfigs(result, jsxConfig);
+    } // Add Flow stripping config if it isn't already specified in the babelrc
+
+
+    let hasFlow = babelrc && hasPlugin(babelrc.config.plugins, ['transform-flow-strip-types', '@babel/transform-flow-strip-types', '@babel/plugin-transform-flow-strip-types']);
+
+    if (!hasFlow) {
+      mergeConfigs(result, flowConfig);
+    }
+
+    return result;
+  });
+  return _getBabelConfig.apply(this, arguments);
+}
+
+module.exports = getBabelConfig;
+
+function mergeConfigs(result, config) {
+  if (!config || (!config.config.presets || config.config.presets.length === 0) && (!config.config.plugins || config.config.plugins.length === 0)) {
+    return;
+  }
+
+  let merged = result[config.babelVersion];
+
+  if (merged) {
+    merged.config.presets = (merged.config.presets || []).concat(config.config.presets || []);
+    merged.config.plugins = (merged.config.plugins || []).concat(config.config.plugins || []);
+  } else {
+    result[config.babelVersion] = config;
+  }
+}
+
+function hasPlugin(arr, plugins) {
+  return Array.isArray(arr) && arr.some(p => plugins.includes(getPluginName(p)));
+}
+
+function getPluginName(p) {
+  return Array.isArray(p) ? p[0] : p;
+}

BACK_BACK/node_modules/parcel-bundler/lib/transforms/babel/env.js

@@ -0,0 +1,95 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+const presetEnv = require('@babel/preset-env');
+
+const getTargetEngines = require('../../utils/getTargetEngines');
+
+const babelCore = require('@babel/core');
+/**
+ * Generates a @babel/preset-env config for an asset.
+ * This is done by finding the source module's target engines, and the app's
+ * target engines, and doing a diff to include only the necessary plugins.
+ */
+
+
+function getEnvConfig(_x, _x2) {
+  return _getEnvConfig.apply(this, arguments);
+}
+
+function _getEnvConfig() {
+  _getEnvConfig = (0, _asyncToGenerator2.default)(function* (asset, isSourceModule) {
+    // Load the target engines for the app and generate a @babel/preset-env config
+    let targetEngines = yield getTargetEngines(asset, true);
+    let targetEnv = yield getEnvPlugins(targetEngines, true);
+
+    if (!targetEnv) {
+      return null;
+    } // If this is the app module, the source and target will be the same, so just compile everything.
+    // Otherwise, load the source engines and generate a babel-present-env config.
+
+
+    if (!isSourceModule) {
+      let sourceEngines = yield getTargetEngines(asset, false);
+      let sourceEnv = (yield getEnvPlugins(sourceEngines, false)) || targetEnv; // Do a diff of the returned plugins. We only need to process the remaining plugins to get to the app target.
+
+      let sourcePlugins = new Set(sourceEnv.map(p => p[0]));
+      targetEnv = targetEnv.filter(plugin => {
+        return !sourcePlugins.has(plugin[0]);
+      });
+    }
+
+    return {
+      internal: true,
+      babelVersion: 7,
+      config: {
+        plugins: targetEnv
+      }
+    };
+  });
+  return _getEnvConfig.apply(this, arguments);
+}
+
+const envCache = new Map();
+
+function getEnvPlugins(_x3) {
+  return _getEnvPlugins.apply(this, arguments);
+}
+
+function _getEnvPlugins() {
+  _getEnvPlugins = (0, _asyncToGenerator2.default)(function* (targets, useBuiltIns = false) {
+    if (!targets) {
+      return null;
+    }
+
+    let key = JSON.stringify(targets);
+
+    if (envCache.has(key)) {
+      return envCache.get(key);
+    }
+
+    const options = {
+      targets,
+      modules: false,
+      useBuiltIns: useBuiltIns ? 'entry' : false,
+      shippedProposals: true
+    };
+
+    if (useBuiltIns) {
+      options.corejs = 2;
+    }
+
+    let plugins = presetEnv.default({
+      version: babelCore.version,
+      assertVersion: () => true
+    }, options).plugins;
+    envCache.set(key, plugins);
+    return plugins;
+  });
+  return _getEnvPlugins.apply(this, arguments);
+}
+
+module.exports = getEnvConfig;

BACK_BACK/node_modules/parcel-bundler/lib/transforms/babel/flow.js

@@ -0,0 +1,20 @@
+"use strict";
+
+/**
+ * Generates a babel config for stripping away Flow types.
+ */
+function getFlowConfig(asset) {
+  if (/^(\/{2}|\/\*+) *@flow/.test(asset.contents.substring(0, 20))) {
+    return {
+      internal: true,
+      babelVersion: 7,
+      config: {
+        plugins: [[require('@babel/plugin-transform-flow-strip-types')]]
+      }
+    };
+  }
+
+  return null;
+}
+
+module.exports = getFlowConfig;

BACK_BACK/node_modules/parcel-bundler/lib/transforms/babel/jsx.js

@@ -0,0 +1,95 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+const path = require('path');
+
+const JSX_EXTENSIONS = {
+  '.jsx': true,
+  '.tsx': true
+};
+const JSX_PRAGMA = {
+  react: 'React.createElement',
+  preact: 'h',
+  nervjs: 'Nerv.createElement',
+  hyperapp: 'h'
+};
+
+function createJSXRegexFor(dependency) {
+  // result looks like /from\s+[`"']react[`"']|require\([`"']react[`"']\)/
+  return new RegExp(`from\\s+[\`"']${dependency}[\`"']|require\\([\`"']${dependency}[\`"']\\)`);
+}
+/**
+ * Solves a use case when JSX is used in .js files, but
+ * package.json is empty or missing yet and therefore pragma cannot
+ * be determined based on pkg.dependencies / pkg.devDependencies
+ */
+
+
+const cacheJsxRegexFor = {};
+
+function maybeCreateFallbackPragma(asset) {
+  for (const dep in JSX_PRAGMA) {
+    let regex = cacheJsxRegexFor[dep];
+
+    if (!regex) {
+      regex = createJSXRegexFor(dep);
+      cacheJsxRegexFor[dep] = regex;
+    }
+
+    if (asset.contents.match(regex)) {
+      return JSX_PRAGMA[dep];
+    }
+  }
+}
+/**
+ * Generates a babel config for JSX. Attempts to detect react or react-like libraries
+ * and changes the pragma accordingly.
+ */
+
+
+function getJSXConfig(_x, _x2) {
+  return _getJSXConfig.apply(this, arguments);
+}
+
+function _getJSXConfig() {
+  _getJSXConfig = (0, _asyncToGenerator2.default)(function* (asset, isSourceModule) {
+    // Don't enable JSX in node_modules
+    if (!isSourceModule) {
+      return null;
+    }
+
+    let pkg = yield asset.getPackage(); // Find a dependency that we can map to a JSX pragma
+
+    let pragma = null;
+
+    for (let dep in JSX_PRAGMA) {
+      if (pkg && (pkg.dependencies && pkg.dependencies[dep] || pkg.devDependencies && pkg.devDependencies[dep])) {
+        pragma = JSX_PRAGMA[dep];
+        break;
+      }
+    }
+
+    if (!pragma) {
+      pragma = maybeCreateFallbackPragma(asset);
+    }
+
+    if (pragma || JSX_EXTENSIONS[path.extname(asset.name)]) {
+      return {
+        internal: true,
+        babelVersion: 7,
+        config: {
+          plugins: [[require('@babel/plugin-transform-react-jsx'), {
+            pragma,
+            pragmaFrag: 'React.Fragment'
+          }]]
+        }
+      };
+    }
+  });
+  return _getJSXConfig.apply(this, arguments);
+}
+
+module.exports = getJSXConfig;

BACK_BACK/node_modules/parcel-bundler/lib/transforms/babel/transform.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+const babel6 = require('./babel6');
+
+const babel7 = require('./babel7');
+
+const getBabelConfig = require('./config');
+
+function babelTransform(_x) {
+  return _babelTransform.apply(this, arguments);
+}
+
+function _babelTransform() {
+  _babelTransform = (0, _asyncToGenerator2.default)(function* (asset) {
+    let config = yield getBabelConfig(asset);
+
+    if (config[6]) {
+      yield babel6(asset, config[6]);
+    }
+
+    if (config[7]) {
+      yield babel7(asset, config[7]);
+    }
+
+    return asset.ast;
+  });
+  return _babelTransform.apply(this, arguments);
+}
+
+module.exports = babelTransform;