flow like the river

BACK_BACK/node_modules/parcel-bundler/lib/scope-hoisting/concat.js

@@ -0,0 +1,452 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+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 _require = require('path'),
+      relative = _require.relative;
+
+const template = require('@babel/template').default;
+
+const t = require('@babel/types');
+
+const traverse = require('@babel/traverse').default;
+
+const generate = require('@babel/generator').default;
+
+const treeShake = require('./shake');
+
+const mangleScope = require('./mangler');
+
+const _require2 = require('./utils'),
+      getName = _require2.getName,
+      getIdentifier = _require2.getIdentifier;
+
+const EXPORTS_RE = /^\$([^$]+)\$exports$/;
+const ESMODULE_TEMPLATE = template(`$parcel$defineInteropFlag(EXPORTS);`);
+const DEFAULT_INTEROP_TEMPLATE = template('var NAME = $parcel$interopDefault(MODULE)');
+const THROW_TEMPLATE = template('$parcel$missingModule(MODULE)');
+const REQUIRE_TEMPLATE = template('require(ID)');
+
+module.exports = (packager, ast) => {
+  let assets = packager.assets;
+  let replacements = new Map();
+  let imports = new Map();
+  let referenced = new Set(); // Build a mapping of all imported identifiers to replace.
+
+  var _iterator = _createForOfIteratorHelper(assets.values()),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      let asset = _step.value;
+
+      for (let name in asset.cacheData.imports) {
+        let imp = asset.cacheData.imports[name];
+        imports.set(name, [packager.resolveModule(asset.id, imp[0]), imp[1]]);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  function replaceExportNode(module, originalName, path) {
+    let _packager$findExportM = packager.findExportModule(module.id, originalName, replacements),
+        identifier = _packager$findExportM.identifier,
+        name = _packager$findExportM.name,
+        id = _packager$findExportM.id;
+
+    let mod = assets.get(id);
+    let node;
+
+    if (identifier) {
+      node = findSymbol(path, identifier);
+    } // If the module is not in this bundle, create a `require` call for it.
+
+
+    if (!node && !mod) {
+      node = REQUIRE_TEMPLATE({
+        ID: t.stringLiteral(id)
+      }).expression;
+      return interop(module, name, path, node);
+    } // If this is an ES6 module, throw an error if we cannot resolve the module
+
+
+    if (!node && !mod.cacheData.isCommonJS && mod.cacheData.isES6Module) {
+      let relativePath = relative(packager.options.rootDir, mod.name);
+      throw new Error(`${relativePath} does not export '${name}'`);
+    } // If it is CommonJS, look for an exports object.
+
+
+    if (!node && mod.cacheData.isCommonJS) {
+      node = findSymbol(path, getName(mod, 'exports'));
+
+      if (!node) {
+        return null;
+      }
+
+      return interop(mod, name, path, node);
+    }
+
+    return node;
+  }
+
+  function findSymbol(path, symbol) {
+    if (replacements.has(symbol)) {
+      symbol = replacements.get(symbol);
+    } // if the symbol is in the scope there is not need to remap it
+
+
+    if (path.scope.getProgramParent().hasBinding(symbol)) {
+      return t.identifier(symbol);
+    }
+
+    return null;
+  }
+
+  function interop(mod, originalName, path, node) {
+    // Handle interop for default imports of CommonJS modules.
+    if (mod.cacheData.isCommonJS && originalName === 'default') {
+      let name = getName(mod, '$interop$default');
+
+      if (!path.scope.getBinding(name)) {
+        let _path$getStatementPar = path.getStatementParent().insertBefore(DEFAULT_INTEROP_TEMPLATE({
+          NAME: t.identifier(name),
+          MODULE: node
+        })),
+            _path$getStatementPar2 = (0, _slicedToArray2.default)(_path$getStatementPar, 1),
+            decl = _path$getStatementPar2[0];
+
+        let binding = path.scope.getBinding(getName(mod, 'exports'));
+
+        if (binding) {
+          binding.reference(decl.get('declarations.0.init'));
+        }
+
+        path.scope.registerDeclaration(decl);
+      }
+
+      return t.memberExpression(t.identifier(name), t.identifier('d'));
+    } // if there is a CommonJS export return $id$exports.name
+
+
+    if (originalName !== '*') {
+      return t.memberExpression(node, t.identifier(originalName));
+    }
+
+    return node;
+  }
+
+  function isUnusedValue(path) {
+    return path.parentPath.isExpressionStatement() || path.parentPath.isSequenceExpression() && (path.key !== path.container.length - 1 || isUnusedValue(path.parentPath));
+  }
+
+  traverse(ast, {
+    CallExpression(path) {
+      let _path$node = path.node,
+          args = _path$node.arguments,
+          callee = _path$node.callee;
+
+      if (!t.isIdentifier(callee)) {
+        return;
+      } // each require('module') call gets replaced with $parcel$require(id, 'module')
+
+
+      if (callee.name === '$parcel$require') {
+        let _args = (0, _slicedToArray2.default)(args, 2),
+            id = _args[0],
+            source = _args[1];
+
+        if (args.length !== 2 || !t.isStringLiteral(id) || !t.isStringLiteral(source)) {
+          throw new Error('invariant: invalid signature, expected : $parcel$require(number, string)');
+        }
+
+        let asset = assets.get(id.value);
+        let mod = packager.resolveModule(id.value, source.value);
+
+        if (!mod) {
+          if (asset.dependencies.get(source.value).optional) {
+            path.replaceWith(THROW_TEMPLATE({
+              MODULE: t.stringLiteral(source.value)
+            }));
+          } else {
+            throw new Error(`Cannot find module "${source.value}" in asset ${id.value}`);
+          }
+        } else {
+          let node;
+
+          if (assets.get(mod.id)) {
+            // Replace with nothing if the require call's result is not used.
+            if (!isUnusedValue(path)) {
+              let name = getName(mod, 'exports');
+              node = t.identifier(replacements.get(name) || name); // Insert __esModule interop flag if the required module is an ES6 module with a default export.
+              // This ensures that code generated by Babel and other tools works properly.
+
+              if (asset.cacheData.isCommonJS && mod.cacheData.isES6Module && mod.cacheData.exports.default) {
+                let binding = path.scope.getBinding(name);
+
+                if (binding && !binding.path.getData('hasESModuleFlag')) {
+                  if (binding.path.node.init) {
+                    binding.path.getStatementParent().insertAfter(ESMODULE_TEMPLATE({
+                      EXPORTS: name
+                    }));
+                  }
+
+                  var _iterator2 = _createForOfIteratorHelper(binding.constantViolations),
+                      _step2;
+
+                  try {
+                    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                      let path = _step2.value;
+                      path.insertAfter(ESMODULE_TEMPLATE({
+                        EXPORTS: name
+                      }));
+                    }
+                  } catch (err) {
+                    _iterator2.e(err);
+                  } finally {
+                    _iterator2.f();
+                  }
+
+                  binding.path.setData('hasESModuleFlag', true);
+                }
+              }
+            } // We need to wrap the module in a function when a require
+            // call happens inside a non top-level scope, e.g. in a
+            // function, if statement, or conditional expression.
+
+
+            if (mod.cacheData.shouldWrap) {
+              let call = t.callExpression(getIdentifier(mod, 'init'), []);
+              node = node ? t.sequenceExpression([call, node]) : call;
+            }
+          } else {
+            node = REQUIRE_TEMPLATE({
+              ID: t.stringLiteral(mod.id)
+            }).expression;
+          }
+
+          if (node) {
+            path.replaceWith(node);
+          } else {
+            path.remove();
+          }
+        }
+      } else if (callee.name === '$parcel$require$resolve') {
+        let _args2 = (0, _slicedToArray2.default)(args, 2),
+            id = _args2[0],
+            source = _args2[1];
+
+        if (args.length !== 2 || !t.isStringLiteral(id) || !t.isStringLiteral(source)) {
+          throw new Error('invariant: invalid signature, expected : $parcel$require$resolve(number, string)');
+        }
+
+        let mapped = assets.get(id.value);
+        let dep = mapped.dependencies.get(source.value);
+        let mod = mapped.depAssets.get(dep);
+        let bundles = mod.id;
+
+        if (dep.dynamic && packager.bundle.childBundles.has(mod.parentBundle)) {
+          bundles = [];
+
+          var _iterator3 = _createForOfIteratorHelper(mod.parentBundle.siblingBundles),
+              _step3;
+
+          try {
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              let child = _step3.value;
+
+              if (!child.isEmpty && packager.options.bundleLoaders[child.type]) {
+                bundles.push(packager.getBundleSpecifier(child));
+              }
+            }
+          } catch (err) {
+            _iterator3.e(err);
+          } finally {
+            _iterator3.f();
+          }
+
+          bundles.push(packager.getBundleSpecifier(mod.parentBundle));
+          bundles.push(mod.id);
+        }
+
+        path.replaceWith(t.valueToNode(bundles));
+      }
+    },
+
+    VariableDeclarator: {
+      exit(path) {
+        // Replace references to declarations like `var x = require('x')`
+        // with the final export identifier instead.
+        // This allows us to potentially replace accesses to e.g. `x.foo` with
+        // a variable like `$id$export$foo` later, avoiding the exports object altogether.
+        let _path$node2 = path.node,
+            id = _path$node2.id,
+            init = _path$node2.init;
+
+        if (!t.isIdentifier(init)) {
+          return;
+        }
+
+        let match = init.name.match(EXPORTS_RE);
+
+        if (!match) {
+          return;
+        } // Replace patterns like `var {x} = require('y')` with e.g. `$id$export$x`.
+
+
+        if (t.isObjectPattern(id)) {
+          var _iterator4 = _createForOfIteratorHelper(path.get('id.properties')),
+              _step4;
+
+          try {
+            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+              let p = _step4.value;
+              let _p$node = p.node,
+                  computed = _p$node.computed,
+                  key = _p$node.key,
+                  value = _p$node.value;
+
+              if (computed || !t.isIdentifier(key) || !t.isIdentifier(value)) {
+                continue;
+              }
+
+              let _packager$findExportM2 = packager.findExportModule(match[1], key.name, replacements),
+                  identifier = _packager$findExportM2.identifier;
+
+              if (identifier) {
+                replace(value.name, identifier, p);
+              }
+            }
+          } catch (err) {
+            _iterator4.e(err);
+          } finally {
+            _iterator4.f();
+          }
+
+          if (id.properties.length === 0) {
+            path.remove();
+          }
+        } else if (t.isIdentifier(id)) {
+          replace(id.name, init.name, path);
+        }
+
+        function replace(id, init, path) {
+          let binding = path.scope.getBinding(id);
+
+          if (!binding.constant) {
+            return;
+          }
+
+          var _iterator5 = _createForOfIteratorHelper(binding.referencePaths),
+              _step5;
+
+          try {
+            for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+              let ref = _step5.value;
+              ref.replaceWith(t.identifier(init));
+            }
+          } catch (err) {
+            _iterator5.e(err);
+          } finally {
+            _iterator5.f();
+          }
+
+          replacements.set(id, init);
+          path.remove();
+        }
+      }
+
+    },
+    MemberExpression: {
+      exit(path) {
+        if (!path.isReferenced()) {
+          return;
+        }
+
+        let _path$node3 = path.node,
+            object = _path$node3.object,
+            property = _path$node3.property,
+            computed = _path$node3.computed;
+
+        if (!(t.isIdentifier(object) && (t.isIdentifier(property) && !computed || t.isStringLiteral(property)))) {
+          return;
+        }
+
+        let match = object.name.match(EXPORTS_RE); // If it's a $id$exports.name expression.
+
+        if (match) {
+          let name = t.isIdentifier(property) ? property.name : property.value;
+
+          let _packager$findExportM3 = packager.findExportModule(match[1], name, replacements),
+              identifier = _packager$findExportM3.identifier; // Check if $id$export$name exists and if so, replace the node by it.
+
+
+          if (identifier) {
+            path.replaceWith(t.identifier(identifier));
+          }
+        }
+      }
+
+    },
+
+    ReferencedIdentifier(path) {
+      let name = path.node.name;
+
+      if (typeof name !== 'string') {
+        return;
+      }
+
+      if (imports.has(name)) {
+        let imp = imports.get(name);
+        let node = replaceExportNode(imp[0], imp[1], path); // If the export does not exist, replace with an empty object.
+
+        if (!node) {
+          node = t.objectExpression([]);
+        }
+
+        path.replaceWith(node);
+        return;
+      }
+
+      let match = name.match(EXPORTS_RE);
+
+      if (match) {
+        referenced.add(name);
+      } // If it's an undefined $id$exports identifier.
+
+
+      if (match && !path.scope.hasBinding(name)) {
+        path.replaceWith(t.objectExpression([]));
+      }
+    },
+
+    Program: {
+      // A small optimization to remove unused CommonJS exports as sometimes Uglify doesn't remove them.
+      exit(path) {
+        treeShake(path.scope);
+
+        if (packager.options.minify) {
+          mangleScope(path.scope);
+        }
+      }
+
+    }
+  });
+  let opts = {
+    sourceMaps: packager.options.sourceMaps,
+    sourceFileName: packager.bundle.name,
+    minified: packager.options.minify,
+    comments: !packager.options.minify
+  };
+  return generate(ast, opts);
+};

BACK_BACK/node_modules/parcel-bundler/lib/scope-hoisting/hoist.js

@@ -0,0 +1,570 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+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 path = require('path');
+
+const mm = require('micromatch');
+
+const t = require('@babel/types');
+
+const template = require('@babel/template').default;
+
+const traverse = require('@babel/traverse').default;
+
+const rename = require('./renamer');
+
+const _require = require('./utils'),
+      getName = _require.getName,
+      getIdentifier = _require.getIdentifier,
+      getExportIdentifier = _require.getExportIdentifier;
+
+const WRAPPER_TEMPLATE = template(`
+  var NAME = (function () {
+    var exports = this;
+    var module = {exports: this};
+    BODY;
+    return module.exports;
+  }).call({});
+`);
+const ESMODULE_TEMPLATE = template(`exports.__esModule = true;`);
+const EXPORT_ASSIGN_TEMPLATE = template('EXPORTS.NAME = LOCAL');
+const EXPORT_ALL_TEMPLATE = template('$parcel$exportWildcard(OLD_NAME, $parcel$require(ID, SOURCE))');
+const REQUIRE_CALL_TEMPLATE = template('$parcel$require(ID, SOURCE)');
+const REQUIRE_RESOLVE_CALL_TEMPLATE = template('$parcel$require$resolve(ID, SOURCE)');
+const TYPEOF = {
+  module: 'object',
+  require: 'function'
+};
+
+function hasSideEffects(asset, {
+  sideEffects
+} = asset._package) {
+  switch (typeof sideEffects) {
+    case 'undefined':
+      return true;
+
+    case 'boolean':
+      return sideEffects;
+
+    case 'string':
+      return mm.isMatch(path.relative(asset._package.pkgdir, asset.name), sideEffects, {
+        matchBase: true
+      });
+
+    case 'object':
+      return sideEffects.some(sideEffects => hasSideEffects(asset, {
+        sideEffects
+      }));
+  }
+}
+
+module.exports = {
+  Program: {
+    enter(path, asset) {
+      traverse.cache.clearScope();
+      path.scope.crawl();
+      asset.cacheData.imports = asset.cacheData.imports || Object.create(null);
+      asset.cacheData.exports = asset.cacheData.exports || Object.create(null);
+      asset.cacheData.wildcards = asset.cacheData.wildcards || [];
+      asset.cacheData.sideEffects = asset._package && hasSideEffects(asset);
+      let shouldWrap = false;
+      path.traverse({
+        CallExpression(path) {
+          // If we see an `eval` call, wrap the module in a function.
+          // Otherwise, local variables accessed inside the eval won't work.
+          let callee = path.node.callee;
+
+          if (t.isIdentifier(callee) && callee.name === 'eval' && !path.scope.hasBinding('eval', true)) {
+            asset.cacheData.isCommonJS = true;
+            shouldWrap = true;
+            path.stop();
+          }
+        },
+
+        ReturnStatement(path) {
+          // Wrap in a function if we see a top-level return statement.
+          if (!path.getFunctionParent()) {
+            shouldWrap = true;
+            asset.cacheData.isCommonJS = true;
+            path.replaceWith(t.returnStatement(t.memberExpression(t.identifier('module'), t.identifier('exports'))));
+            path.stop();
+          }
+        },
+
+        ReferencedIdentifier(path) {
+          // We must wrap if `module` is referenced as a free identifier rather
+          // than a statically resolvable member expression.
+          if (path.node.name === 'module' && (!path.parentPath.isMemberExpression() || path.parent.computed) && !(path.parentPath.isUnaryExpression() && path.parent.operator === 'typeof') && !path.scope.hasBinding('module') && !path.scope.getData('shouldWrap')) {
+            asset.cacheData.isCommonJS = true;
+            shouldWrap = true;
+            path.stop();
+          }
+        }
+
+      });
+      path.scope.setData('shouldWrap', shouldWrap);
+    },
+
+    exit(path, asset) {
+      let scope = path.scope;
+
+      if (scope.getData('shouldWrap')) {
+        if (asset.cacheData.isES6Module) {
+          path.unshiftContainer('body', [ESMODULE_TEMPLATE()]);
+        }
+
+        path.replaceWith(t.program([WRAPPER_TEMPLATE({
+          NAME: getExportsIdentifier(asset),
+          BODY: path.node.body
+        })]));
+        asset.cacheData.exports = {};
+        asset.cacheData.isCommonJS = true;
+        asset.cacheData.isES6Module = false;
+      } else {
+        // Re-crawl scope so we are sure to have all bindings.
+        scope.crawl(); // Rename each binding in the top-level scope to something unique.
+
+        for (let name in scope.bindings) {
+          if (!name.startsWith('$' + t.toIdentifier(asset.id))) {
+            let newName = getName(asset, 'var', name);
+            rename(scope, name, newName);
+          }
+        }
+
+        let exportsIdentifier = getExportsIdentifier(asset); // Add variable that represents module.exports if it is referenced and not declared.
+
+        if (scope.hasGlobal(exportsIdentifier.name) && !scope.hasBinding(exportsIdentifier.name)) {
+          scope.push({
+            id: exportsIdentifier,
+            init: t.objectExpression([])
+          });
+        }
+      }
+
+      path.stop();
+      asset.isAstDirty = true;
+    }
+
+  },
+
+  DirectiveLiteral(path) {
+    // Remove 'use strict' directives, since modules are concatenated - one strict mode
+    // module should not apply to all other modules in the same scope.
+    if (path.node.value === 'use strict') {
+      path.parentPath.remove();
+    }
+  },
+
+  MemberExpression(path, asset) {
+    if (path.scope.hasBinding('module') || path.scope.getData('shouldWrap')) {
+      return;
+    }
+
+    if (t.matchesPattern(path.node, 'module.exports')) {
+      path.replaceWith(getExportsIdentifier(asset));
+      asset.cacheData.isCommonJS = true;
+    }
+
+    if (t.matchesPattern(path.node, 'module.id')) {
+      path.replaceWith(t.stringLiteral(asset.id));
+    }
+
+    if (t.matchesPattern(path.node, 'module.hot')) {
+      path.replaceWith(t.identifier('null'));
+    }
+
+    if (t.matchesPattern(path.node, 'module.require') && asset.options.target !== 'node') {
+      path.replaceWith(t.identifier('null'));
+    }
+
+    if (t.matchesPattern(path.node, 'module.bundle')) {
+      path.replaceWith(t.identifier('require'));
+    }
+  },
+
+  ReferencedIdentifier(path, asset) {
+    if (path.node.name === 'exports' && !path.scope.hasBinding('exports') && !path.scope.getData('shouldWrap')) {
+      path.replaceWith(getExportsIdentifier(asset));
+      asset.cacheData.isCommonJS = true;
+    }
+
+    if (path.node.name === 'global' && !path.scope.hasBinding('global')) {
+      path.replaceWith(t.identifier('$parcel$global'));
+      asset.globals.delete('global');
+    }
+
+    let globalCode = asset.globals.get(path.node.name);
+
+    if (globalCode) {
+      path.scope.getProgramParent().path.unshiftContainer('body', [template(globalCode)()]);
+      asset.globals.delete(path.node.name);
+    }
+  },
+
+  ThisExpression(path, asset) {
+    if (!path.scope.parent && !path.scope.getData('shouldWrap')) {
+      path.replaceWith(getExportsIdentifier(asset));
+      asset.cacheData.isCommonJS = true;
+    }
+  },
+
+  AssignmentExpression(path, asset) {
+    if (path.scope.hasBinding('exports') || path.scope.getData('shouldWrap')) {
+      return;
+    }
+
+    let _path$node = path.node,
+        left = _path$node.left,
+        right = _path$node.right;
+
+    if (t.isIdentifier(left) && left.name === 'exports') {
+      path.get('left').replaceWith(getExportsIdentifier(asset));
+      asset.cacheData.isCommonJS = true;
+    } // If we can statically evaluate the name of a CommonJS export, create an ES6-style export for it.
+    // This allows us to remove the CommonJS export object completely in many cases.
+
+
+    if (t.isMemberExpression(left) && t.isIdentifier(left.object, {
+      name: 'exports'
+    }) && (t.isIdentifier(left.property) && !left.computed || t.isStringLiteral(left.property))) {
+      let name = t.isIdentifier(left.property) ? left.property.name : left.property.value;
+      let identifier = getExportIdentifier(asset, name); // Replace the CommonJS assignment with a reference to the ES6 identifier.
+
+      path.get('left.object').replaceWith(getExportsIdentifier(asset));
+      path.get('right').replaceWith(identifier); // If this is the first assignment, create a binding for the ES6-style export identifier.
+      // Otherwise, assign to the existing export binding.
+
+      let scope = path.scope.getProgramParent();
+
+      if (!scope.hasBinding(identifier.name)) {
+        asset.cacheData.exports[name] = identifier.name; // If in the program scope, create a variable declaration and initialize with the exported value.
+        // Otherwise, declare the variable in the program scope, and assign to it here.
+
+        if (path.scope === scope) {
+          let _path$insertBefore = path.insertBefore(t.variableDeclaration('var', [t.variableDeclarator(t.clone(identifier), right)])),
+              _path$insertBefore2 = (0, _slicedToArray2.default)(_path$insertBefore, 1),
+              decl = _path$insertBefore2[0];
+
+          scope.registerDeclaration(decl);
+        } else {
+          scope.push({
+            id: t.clone(identifier)
+          });
+          path.insertBefore(t.assignmentExpression('=', t.clone(identifier), right));
+        }
+      } else {
+        path.insertBefore(t.assignmentExpression('=', t.clone(identifier), right));
+      }
+
+      asset.cacheData.isCommonJS = true;
+    }
+  },
+
+  UnaryExpression(path) {
+    // Replace `typeof module` with "object"
+    if (path.node.operator === 'typeof' && t.isIdentifier(path.node.argument) && TYPEOF[path.node.argument.name] && !path.scope.hasBinding(path.node.argument.name) && !path.scope.getData('shouldWrap')) {
+      path.replaceWith(t.stringLiteral(TYPEOF[path.node.argument.name]));
+    }
+  },
+
+  CallExpression(path, asset) {
+    let _path$node2 = path.node,
+        callee = _path$node2.callee,
+        args = _path$node2.arguments;
+    let ignore = args.length !== 1 || !t.isStringLiteral(args[0]) || path.scope.hasBinding('require');
+
+    if (ignore) {
+      return;
+    }
+
+    if (t.isIdentifier(callee, {
+      name: 'require'
+    })) {
+      let source = args[0].value; // Ignore require calls that were ignored earlier.
+
+      if (!asset.dependencies.has(source)) {
+        return;
+      } // If this require call does not occur in the top-level, e.g. in a function
+      // or inside an if statement, or if it might potentially happen conditionally,
+      // the module must be wrapped in a function so that the module execution order is correct.
+
+
+      let parent = path.getStatementParent().parentPath;
+      let bail = path.findParent(p => p.isConditionalExpression() || p.isLogicalExpression() || p.isSequenceExpression());
+
+      if (!parent.isProgram() || bail) {
+        asset.dependencies.get(source).shouldWrap = true;
+      }
+
+      asset.cacheData.imports['$require$' + source] = [source, '*']; // Generate a variable name based on the current asset id and the module name to require.
+      // This will be replaced by the final variable name of the resolved asset in the packager.
+
+      path.replaceWith(REQUIRE_CALL_TEMPLATE({
+        ID: t.stringLiteral(asset.id),
+        SOURCE: t.stringLiteral(args[0].value)
+      }));
+    }
+
+    if (t.matchesPattern(callee, 'require.resolve')) {
+      path.replaceWith(REQUIRE_RESOLVE_CALL_TEMPLATE({
+        ID: t.stringLiteral(asset.id),
+        SOURCE: args[0]
+      }));
+    }
+  },
+
+  ImportDeclaration(path, asset) {
+    // For each specifier, rename the local variables to point to the imported name.
+    // This will be replaced by the final variable name of the resolved asset in the packager.
+    var _iterator = _createForOfIteratorHelper(path.node.specifiers),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        let specifier = _step.value;
+        let id = getIdentifier(asset, 'import', specifier.local.name);
+        rename(path.scope, specifier.local.name, id.name);
+
+        if (t.isImportDefaultSpecifier(specifier)) {
+          asset.cacheData.imports[id.name] = [path.node.source.value, 'default'];
+        } else if (t.isImportSpecifier(specifier)) {
+          asset.cacheData.imports[id.name] = [path.node.source.value, specifier.imported.name];
+        } else if (t.isImportNamespaceSpecifier(specifier)) {
+          asset.cacheData.imports[id.name] = [path.node.source.value, '*'];
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    addImport(asset, path);
+    path.remove();
+  },
+
+  ExportDefaultDeclaration(path, asset) {
+    let declaration = path.node.declaration;
+    let identifier = getExportIdentifier(asset, 'default');
+    let name = declaration.id ? declaration.id.name : declaration.name;
+
+    if (asset.cacheData.imports[name]) {
+      asset.cacheData.exports['default'] = asset.cacheData.imports[name];
+      identifier = t.identifier(name);
+    }
+
+    if (hasExport(asset, name)) {
+      identifier = t.identifier(name);
+    } // Add assignment to exports object for namespace imports and commonjs.
+
+
+    path.insertAfter(EXPORT_ASSIGN_TEMPLATE({
+      EXPORTS: getExportsIdentifier(asset, path.scope),
+      NAME: t.identifier('default'),
+      LOCAL: t.clone(identifier)
+    }));
+
+    if (t.isIdentifier(declaration)) {
+      // Rename the variable being exported.
+      safeRename(path, asset, declaration.name, identifier.name);
+      path.remove();
+    } else if (t.isExpression(declaration) || !declaration.id) {
+      // Declare a variable to hold the exported value.
+      path.replaceWith(t.variableDeclaration('var', [t.variableDeclarator(identifier, t.toExpression(declaration))]));
+      path.scope.registerDeclaration(path);
+    } else {
+      // Rename the declaration to the exported name.
+      safeRename(path, asset, declaration.id.name, identifier.name);
+      path.replaceWith(declaration);
+    }
+
+    if (!asset.cacheData.exports['default']) {
+      asset.cacheData.exports['default'] = identifier.name;
+    } // Mark the asset as an ES6 module, so we handle imports correctly in the packager.
+
+
+    asset.cacheData.isES6Module = true;
+  },
+
+  ExportNamedDeclaration(path, asset) {
+    let _path$node3 = path.node,
+        declaration = _path$node3.declaration,
+        source = _path$node3.source,
+        specifiers = _path$node3.specifiers;
+
+    if (source) {
+      var _iterator2 = _createForOfIteratorHelper(specifiers),
+          _step2;
+
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          let specifier = _step2.value;
+          let exported = specifier.exported;
+
+          if (t.isExportDefaultSpecifier(specifier)) {
+            asset.cacheData.exports[exported.name] = [source.value, 'default'];
+          } else if (t.isExportNamespaceSpecifier(specifier)) {
+            asset.cacheData.exports[exported.name] = [source.value, '*'];
+          } else if (t.isExportSpecifier(specifier)) {
+            asset.cacheData.exports[exported.name] = [source.value, specifier.local.name];
+          }
+
+          let id = getIdentifier(asset, 'import', exported.name);
+          asset.cacheData.imports[id.name] = asset.cacheData.exports[exported.name];
+          path.insertAfter(EXPORT_ASSIGN_TEMPLATE({
+            EXPORTS: getExportsIdentifier(asset, path.scope),
+            NAME: exported,
+            LOCAL: id
+          }));
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+
+      addImport(asset, path);
+      path.remove();
+    } else if (declaration) {
+      path.replaceWith(declaration);
+      let identifiers = t.isIdentifier(declaration.id) ? [declaration.id] : t.getBindingIdentifiers(declaration);
+
+      for (let id in identifiers) {
+        addExport(asset, path, identifiers[id], identifiers[id]);
+      }
+    } else if (specifiers.length > 0) {
+      var _iterator3 = _createForOfIteratorHelper(specifiers),
+          _step3;
+
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          let specifier = _step3.value;
+          addExport(asset, path, specifier.local, specifier.exported);
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+
+      path.remove();
+    } // Mark the asset as an ES6 module, so we handle imports correctly in the packager.
+
+
+    asset.cacheData.isES6Module = true;
+  },
+
+  ExportAllDeclaration(path, asset) {
+    asset.cacheData.wildcards.push(path.node.source.value);
+    asset.cacheData.isES6Module = true;
+    path.replaceWith(EXPORT_ALL_TEMPLATE({
+      OLD_NAME: getExportsIdentifier(asset),
+      SOURCE: t.stringLiteral(path.node.source.value),
+      ID: t.stringLiteral(asset.id)
+    }));
+  }
+
+};
+
+function addImport(asset, path) {
+  // Replace with a $parcel$require call so we know where to insert side effects.
+  let requireCall = REQUIRE_CALL_TEMPLATE({
+    ID: t.stringLiteral(asset.id),
+    SOURCE: t.stringLiteral(path.node.source.value)
+  }); // Hoist the call to the top of the file.
+
+  let lastImport = path.scope.getData('hoistedImport');
+
+  if (lastImport) {
+    var _lastImport$insertAft = lastImport.insertAfter(requireCall);
+
+    var _lastImport$insertAft2 = (0, _slicedToArray2.default)(_lastImport$insertAft, 1);
+
+    lastImport = _lastImport$insertAft2[0];
+  } else {
+    var _path$parentPath$unsh = path.parentPath.unshiftContainer('body', [requireCall]);
+
+    var _path$parentPath$unsh2 = (0, _slicedToArray2.default)(_path$parentPath$unsh, 1);
+
+    lastImport = _path$parentPath$unsh2[0];
+  }
+
+  path.scope.setData('hoistedImport', lastImport);
+}
+
+function addExport(asset, path, local, exported) {
+  let scope = path.scope.getProgramParent();
+  let identifier = getExportIdentifier(asset, exported.name);
+
+  if (asset.cacheData.imports[local.name]) {
+    asset.cacheData.exports[exported.name] = asset.cacheData.imports[local.name];
+    identifier = t.identifier(local.name);
+  }
+
+  if (hasExport(asset, local.name)) {
+    identifier = t.identifier(local.name);
+  }
+
+  let assignNode = EXPORT_ASSIGN_TEMPLATE({
+    EXPORTS: getExportsIdentifier(asset, scope),
+    NAME: t.identifier(exported.name),
+    LOCAL: identifier
+  });
+  let binding = scope.getBinding(local.name);
+  let constantViolations = binding ? binding.constantViolations.concat(path) : [path];
+
+  if (!asset.cacheData.exports[exported.name]) {
+    asset.cacheData.exports[exported.name] = identifier.name;
+  }
+
+  try {
+    rename(scope, local.name, identifier.name);
+  } catch (e) {
+    throw new Error('export ' + e.message);
+  }
+
+  constantViolations.forEach(path => path.insertAfter(t.cloneDeep(assignNode)));
+}
+
+function hasExport(asset, name) {
+  let exports = asset.cacheData.exports;
+  return Object.keys(exports).some(k => exports[k] === name);
+}
+
+function safeRename(path, asset, from, to) {
+  if (from === to) {
+    return;
+  } // If the binding that we're renaming is constant, it's safe to rename it.
+  // Otherwise, create a new binding that references the original.
+
+
+  let binding = path.scope.getBinding(from);
+
+  if (binding && binding.constant) {
+    rename(path.scope, from, to);
+  } else {
+    let _path$insertAfter = path.insertAfter(t.variableDeclaration('var', [t.variableDeclarator(t.identifier(to), t.identifier(from))])),
+        _path$insertAfter2 = (0, _slicedToArray2.default)(_path$insertAfter, 1),
+        decl = _path$insertAfter2[0];
+
+    path.scope.getBinding(from).reference(decl.get('declarations.0.init'));
+    path.scope.registerDeclaration(decl);
+  }
+}
+
+function getExportsIdentifier(asset, scope) {
+  if (scope && scope.getData('shouldWrap')) {
+    return t.identifier('exports');
+  } else {
+    return getIdentifier(asset, 'exports');
+  }
+}

BACK_BACK/node_modules/parcel-bundler/lib/scope-hoisting/mangler.js

@@ -0,0 +1,82 @@
+"use strict";
+
+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 rename = require('./renamer');
+
+const t = require('@babel/types');
+
+const CHARSET = ('abcdefghijklmnopqrstuvwxyz' + 'ABCDEFGHIJKLMNOPQRSTUVWXYZ$_').split('');
+/**
+ * This is a very specialized mangler designer to mangle only names in the top-level scope.
+ * Mangling of names in other scopes happens at a file level inside workers, but we can't
+ * mangle the top-level scope until scope hoisting is complete in the packager.
+ *
+ * Based on code from babel-minify!
+ * https://github.com/babel/minify/blob/master/packages/babel-plugin-minify-mangle-names/src/charset.js
+ */
+
+function mangleScope(scope) {
+  let newNames = new Set(); // Sort bindings so that more frequently referenced bindings get shorter names.
+
+  let sortedBindings = Object.keys(scope.bindings).sort((a, b) => scope.bindings[b].referencePaths.length - scope.bindings[a].referencePaths.length);
+
+  var _iterator = _createForOfIteratorHelper(sortedBindings),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      let oldName = _step.value;
+      let i = 0;
+      let newName = '';
+
+      do {
+        newName = getIdentifier(i++);
+      } while (newNames.has(newName) || !canRename(scope, scope.bindings[oldName], newName));
+
+      rename(scope, oldName, newName);
+      newNames.add(newName);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+}
+
+function getIdentifier(num) {
+  let ret = '';
+  num++;
+
+  do {
+    num--;
+    ret += CHARSET[num % CHARSET.length];
+    num = Math.floor(num / CHARSET.length);
+  } while (num > 0);
+
+  return ret;
+}
+
+function canRename(scope, binding, newName) {
+  if (!t.isValidIdentifier(newName)) {
+    return false;
+  } // If there are any references where the parent scope has a binding
+  // for the new name, we cannot rename to this name.
+
+
+  for (let i = 0; i < binding.referencePaths.length; i++) {
+    const ref = binding.referencePaths[i];
+
+    if (ref.scope.hasBinding(newName) || ref.scope.hasReference(newName)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+module.exports = mangleScope;

BACK_BACK/node_modules/parcel-bundler/lib/scope-hoisting/renamer.js

@@ -0,0 +1,83 @@
+"use strict";
+
+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 t = require('@babel/types');
+
+function rename(scope, oldName, newName) {
+  if (oldName === newName) {
+    return;
+  }
+
+  let binding = scope.getBinding(oldName);
+
+  if (!binding) {
+    throw new Error("'" + oldName + "' is not defined");
+  } // Rename all constant violations
+
+
+  var _iterator = _createForOfIteratorHelper(binding.constantViolations),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      let violation = _step.value;
+      let bindingIds = violation.getBindingIdentifierPaths(true, false);
+
+      for (let name in bindingIds) {
+        if (name === oldName) {
+          var _iterator3 = _createForOfIteratorHelper(bindingIds[name]),
+              _step3;
+
+          try {
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              let idPath = _step3.value;
+              idPath.node.name = newName;
+            }
+          } catch (err) {
+            _iterator3.e(err);
+          } finally {
+            _iterator3.f();
+          }
+        }
+      }
+    } // Rename all references
+
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  var _iterator2 = _createForOfIteratorHelper(binding.referencePaths),
+      _step2;
+
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      let path = _step2.value;
+
+      if (t.isExportSpecifier(path.parent) && path.parentPath.parent.source) {
+        continue;
+      }
+
+      if (path.node.name === oldName) {
+        path.node.name = newName;
+      }
+    } // Rename binding identifier, and update scope.
+
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+
+  scope.removeOwnBinding(oldName);
+  scope.bindings[newName] = binding;
+  binding.identifier.name = newName;
+}
+
+module.exports = rename;

BACK_BACK/node_modules/parcel-bundler/lib/scope-hoisting/shake.js

@@ -0,0 +1,115 @@
+"use strict";
+
+const t = require('@babel/types');
+/**
+ * This is a small small implementation of dead code removal specialized to handle
+ * removing unused exports. All other dead code removal happens in workers on each
+ * individual file by babel-minify.
+ */
+
+
+function treeShake(scope) {
+  // Keep passing over all bindings in the scope until we don't remove any.
+  // This handles cases where we remove one binding which had a reference to
+  // another one. That one will get removed in the next pass if it is now unreferenced.
+  let removed;
+
+  do {
+    removed = false; // Recrawl to get all bindings.
+
+    scope.crawl();
+    Object.keys(scope.bindings).forEach(name => {
+      let binding = getUnusedBinding(scope.path, name); // If it is not safe to remove the binding don't touch it.
+
+      if (!binding) {
+        return;
+      } // Remove the binding and all references to it.
+
+
+      binding.path.remove();
+      binding.referencePaths.concat(binding.constantViolations).forEach(remove);
+      scope.removeBinding(name);
+      removed = true;
+    });
+  } while (removed);
+}
+
+module.exports = treeShake; // Check if a binding is safe to remove and returns it if it is.
+
+function getUnusedBinding(path, name) {
+  let binding = path.scope.getBinding(name);
+
+  if (!binding) {
+    return null;
+  }
+
+  let pure = isPure(binding);
+
+  if (!binding.referenced && pure) {
+    return binding;
+  } // Is there any references which aren't simple assignments?
+
+
+  let bailout = binding.referencePaths.some(path => !isExportAssignment(path) && !isUnusedWildcard(path));
+
+  if (!bailout && pure) {
+    return binding;
+  }
+
+  return null;
+}
+
+function isPure(binding) {
+  if (binding.path.isVariableDeclarator() && binding.path.get('id').isIdentifier()) {
+    let init = binding.path.get('init');
+    return init.isPure() || init.isIdentifier() || init.isThisExpression();
+  }
+
+  return binding.path.isPure();
+}
+
+function isExportAssignment(path) {
+  return (// match "path.any = any;"
+    path.parentPath.isMemberExpression() && path.parentPath.parentPath.isAssignmentExpression() && path.parentPath.parentPath.node.left === path.parentPath.node
+  );
+}
+
+function isUnusedWildcard(path) {
+  let parent = path.parent;
+  return (// match `$parcel$exportWildcard` calls
+    t.isCallExpression(parent) && t.isIdentifier(parent.callee, {
+      name: '$parcel$exportWildcard'
+    }) && parent.arguments[0] === path.node && // check if the $id$exports variable is used
+    !getUnusedBinding(path, parent.arguments[1].name)
+  );
+}
+
+function remove(path) {
+  if (path.isAssignmentExpression()) {
+    if (path.parentPath.isSequenceExpression()) {
+      if (path.parent.expressions.length == 1) {
+        // replace sequence expression with it's sole child
+        path.parentPath.replaceWith(path);
+        remove(path.parentPath);
+      } else {
+        path.remove();
+      }
+    } else if (!path.parentPath.isExpressionStatement()) {
+      path.replaceWith(path.node.right);
+    } else {
+      path.remove();
+    }
+  } else if (isExportAssignment(path)) {
+    remove(path.parentPath.parentPath);
+  } else if (isUnusedWildcard(path)) {
+    remove(path.parentPath);
+  } else if (!path.removed) {
+    if (path.parentPath.isSequenceExpression() && path.parent.expressions.length === 1) {
+      // replace sequence expression with it's sole child
+      path.parentPath.replaceWith(path);
+      remove(path.parentPath);
+    } else {
+      path.remove();
+    }
+  }
+}

BACK_BACK/node_modules/parcel-bundler/lib/scope-hoisting/utils.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const t = require('@babel/types');
+
+function getName(asset, type, ...rest) {
+  return '$' + t.toIdentifier(asset.id) + '$' + type + (rest.length ? '$' + rest.map(name => name === 'default' ? name : t.toIdentifier(name)).join('$') : '');
+}
+
+function getIdentifier(asset, type, ...rest) {
+  return t.identifier(getName(asset, type, ...rest));
+}
+
+function getExportIdentifier(asset, name) {
+  return getIdentifier(asset, 'export', name);
+}
+
+exports.getName = getName;
+exports.getIdentifier = getIdentifier;
+exports.getExportIdentifier = getExportIdentifier;