flow like the river

BACK_BACK/node_modules/parcel-bundler/lib/packagers/CSSPackager.js

@@ -0,0 +1,119 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+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 path = require('path');
+
+const Packager = require('./Packager');
+
+const lineCounter = require('../utils/lineCounter');
+
+const urlJoin = require('../utils/urlJoin');
+
+class CSSPackager extends Packager {
+  start() {
+    var _this = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      _this.lineOffset = 0;
+      _this.columnOffset = 0;
+    })();
+  }
+
+  addAsset(asset) {
+    var _this2 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      let css = asset.generated.css || ''; // Figure out which media types this asset was imported with.
+      // We only want to import the asset once, so group them all together.
+
+      let media = [];
+
+      var _iterator = _createForOfIteratorHelper(asset.parentDeps),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          let dep = _step.value;
+
+          if (!dep.media) {
+            // Asset was imported without a media type. Don't wrap in @media.
+            media.length = 0;
+            break;
+          } else {
+            media.push(dep.media);
+          }
+        } // If any, wrap in an @media block
+
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+
+      if (media.length) {
+        css = `@media ${media.join(', ')} {\n${css.trim()}\n}\n`;
+      }
+
+      if (asset.options.sourceMaps) {
+        let lineCount = lineCounter(css);
+
+        if (lineCount == 1) {
+          _this2.bundle.addOffset(asset, _this2.lineOffset, _this2.columnOffset);
+
+          yield _this2.write(css);
+          _this2.columnOffset += css.length;
+        } else {
+          const lines = css.split('\n');
+
+          if (_this2.columnOffset == 0) {
+            _this2.bundle.addOffset(asset, _this2.lineOffset, 0);
+
+            yield _this2.write(css + '\n');
+          } else {
+            _this2.columnOffset = 0;
+
+            _this2.bundle.addOffset(asset, _this2.lineOffset + 1, 0);
+
+            _this2.columnOffset = lines[lines.length - 1].length;
+            yield _this2.write('\n' + css);
+          }
+
+          _this2.lineOffset += lineCount;
+        }
+      } else {
+        yield _this2.write(css);
+      }
+    })();
+  }
+
+  end() {
+    var _superprop_getEnd = () => super.end,
+        _this3 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      if (_this3.options.sourceMaps) {
+        // Add source map url if a map bundle exists
+        let mapBundle = _this3.bundle.siblingBundlesMap.get('map');
+
+        if (mapBundle) {
+          let mapUrl = urlJoin(_this3.options.publicURL, path.basename(mapBundle.name));
+          yield _this3.write(`\n/*# sourceMappingURL=${mapUrl} */`);
+        }
+      }
+
+      yield _superprop_getEnd().call(_this3);
+    })();
+  }
+
+}
+
+module.exports = CSSPackager;

BACK_BACK/node_modules/parcel-bundler/lib/packagers/HTMLPackager.js

@@ -0,0 +1,125 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+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 Packager = require('./Packager');
+
+const posthtml = require('posthtml');
+
+const path = require('path');
+
+const urlJoin = require('../utils/urlJoin'); // https://www.w3.org/TR/html5/dom.html#metadata-content-2
+
+
+const metadataContent = new Set(['base', 'link', 'meta', 'noscript', 'script', 'style', 'template', 'title']);
+
+class HTMLPackager extends Packager {
+  static shouldAddAsset() {
+    // We cannot combine multiple HTML files together - they should be written as separate bundles.
+    return false;
+  }
+
+  addAsset(asset) {
+    var _this = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      let html = asset.generated.html || ''; // Find child bundles that have JS or CSS sibling bundles,
+      // add them to the head so they are loaded immediately.
+
+      let siblingBundles = Array.from(_this.bundle.childBundles).reduce((p, b) => p.concat([...b.siblingBundles.values()]), []).filter(b => b.type === 'css' || b.type === 'js');
+
+      if (siblingBundles.length > 0) {
+        html = posthtml(_this.insertSiblingBundles.bind(_this, siblingBundles)).process(html, {
+          sync: true
+        }).html;
+      }
+
+      yield _this.write(html);
+    })();
+  }
+
+  addBundlesToTree(bundles, tree) {
+    const head = find(tree, 'head');
+
+    if (head) {
+      const content = head.content || (head.content = []);
+      content.push(...bundles);
+      return;
+    }
+
+    const html = find(tree, 'html');
+    const content = html ? html.content || (html.content = []) : tree;
+    const index = findBundleInsertIndex(content);
+    content.splice(index, 0, ...bundles);
+  }
+
+  insertSiblingBundles(siblingBundles, tree) {
+    const bundles = [];
+
+    var _iterator = _createForOfIteratorHelper(siblingBundles),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        let bundle = _step.value;
+
+        if (bundle.type === 'css') {
+          bundles.push({
+            tag: 'link',
+            attrs: {
+              rel: 'stylesheet',
+              href: urlJoin(this.options.publicURL, path.basename(bundle.name))
+            }
+          });
+        } else if (bundle.type === 'js') {
+          bundles.push({
+            tag: 'script',
+            attrs: {
+              src: urlJoin(this.options.publicURL, path.basename(bundle.name))
+            }
+          });
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    this.addBundlesToTree(bundles, tree);
+  }
+
+}
+
+function find(tree, tag) {
+  let res;
+  tree.match({
+    tag
+  }, node => {
+    res = node;
+    return node;
+  });
+  return res;
+}
+
+function findBundleInsertIndex(content) {
+  for (let index = 0; index < content.length; index++) {
+    const node = content[index];
+
+    if (node && node.tag && !metadataContent.has(node.tag)) {
+      return index;
+    }
+  }
+
+  return 0;
+}
+
+module.exports = HTMLPackager;

BACK_BACK/node_modules/parcel-bundler/lib/packagers/JSConcatPackager.js

@@ -0,0 +1,752 @@
+"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 Packager = require('./Packager');
+
+const path = require('path');
+
+const concat = require('../scope-hoisting/concat');
+
+const urlJoin = require('../utils/urlJoin');
+
+const getExisting = require('../utils/getExisting');
+
+const walk = require('babylon-walk');
+
+const babylon = require('@babel/parser');
+
+const t = require('@babel/types');
+
+const _require = require('../scope-hoisting/utils'),
+      getName = _require.getName,
+      getIdentifier = _require.getIdentifier;
+
+const prelude = getExisting(path.join(__dirname, '../builtins/prelude2.min.js'), path.join(__dirname, '../builtins/prelude2.js'));
+const helpers = getExisting(path.join(__dirname, '../builtins/helpers.min.js'), path.join(__dirname, '../builtins/helpers.js'));
+
+class JSConcatPackager extends Packager {
+  start() {
+    var _this = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      _this.addedAssets = new Set();
+      _this.assets = new Map();
+      _this.exposedModules = new Set();
+      _this.externalModules = new Set();
+      _this.size = 0;
+      _this.needsPrelude = false;
+      _this.statements = [];
+      _this.assetPostludes = new Map();
+
+      var _iterator = _createForOfIteratorHelper(_this.bundle.assets),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          let asset = _step.value;
+          // If this module is referenced by another JS bundle, it needs to be exposed externally.
+          let isExposed = !Array.from(asset.parentDeps).every(dep => {
+            let depAsset = _this.bundler.loadedAssets.get(dep.parent);
+
+            return _this.bundle.assets.has(depAsset) || depAsset.type !== 'js';
+          });
+
+          if (isExposed || _this.bundle.entryAsset === asset && _this.bundle.parentBundle && _this.bundle.parentBundle.childBundles.size !== 1) {
+            _this.exposedModules.add(asset);
+
+            _this.needsPrelude = true;
+          }
+
+          _this.assets.set(asset.id, asset);
+
+          var _iterator2 = _createForOfIteratorHelper(asset.depAssets.values()),
+              _step2;
+
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              let mod = _step2.value;
+
+              if (!_this.bundle.assets.has(mod) && _this.options.bundleLoaders[asset.type]) {
+                _this.needsPrelude = true;
+                break;
+              }
+            }
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+
+      if (_this.bundle.entryAsset) {
+        _this.markUsedExports(_this.bundle.entryAsset);
+      }
+
+      if (_this.needsPrelude) {
+        if (_this.bundle.entryAsset && _this.options.bundleLoaders[_this.bundle.entryAsset.type]) {
+          _this.exposedModules.add(_this.bundle.entryAsset);
+        }
+      }
+
+      _this.write(helpers.minified);
+    })();
+  }
+
+  write(string) {
+    this.statements.push(...this.parse(string));
+  }
+
+  getSize() {
+    return this.size;
+  }
+
+  markUsedExports(asset) {
+    if (asset.usedExports) {
+      return;
+    }
+
+    asset.usedExports = new Set();
+
+    for (let identifier in asset.cacheData.imports) {
+      let _asset$cacheData$impo = (0, _slicedToArray2.default)(asset.cacheData.imports[identifier], 2),
+          source = _asset$cacheData$impo[0],
+          name = _asset$cacheData$impo[1];
+
+      let dep = asset.depAssets.get(asset.dependencies.get(source));
+
+      if (dep) {
+        if (name === '*') {
+          this.markUsedExports(dep);
+        }
+
+        this.markUsed(dep, name);
+      }
+    }
+  }
+
+  markUsed(mod, name) {
+    let _this$findExportModul = this.findExportModule(mod.id, name),
+        id = _this$findExportModul.id;
+
+    mod = this.assets.get(id);
+
+    if (!mod) {
+      return;
+    }
+
+    let exp = mod.cacheData.exports[name];
+
+    if (Array.isArray(exp)) {
+      let depMod = mod.depAssets.get(mod.dependencies.get(exp[0]));
+      return this.markUsed(depMod, exp[1]);
+    }
+
+    this.markUsedExports(mod);
+    mod.usedExports.add(name);
+  }
+
+  getExportIdentifier(asset) {
+    let id = getName(asset, 'exports');
+
+    if (this.shouldWrap(asset)) {
+      return `(${getName(asset, 'init')}(), ${id})`;
+    }
+
+    return id;
+  }
+
+  addAsset(asset) {
+    var _this2 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      if (_this2.addedAssets.has(asset)) {
+        return;
+      }
+
+      _this2.addedAssets.add(asset);
+
+      let js = asset.generated.js; // If the asset has no side effects according to the its package's sideEffects flag,
+      // and there are no used exports marked, exclude the asset from the bundle.
+
+      if (asset.cacheData.sideEffects === false && (!asset.usedExports || asset.usedExports.size === 0)) {
+        return;
+      }
+
+      var _iterator3 = _createForOfIteratorHelper(asset.depAssets),
+          _step3;
+
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          let _step3$value = (0, _slicedToArray2.default)(_step3.value, 2),
+              dep = _step3$value[0],
+              mod = _step3$value[1];
+
+          if (dep.dynamic) {
+            var _iterator4 = _createForOfIteratorHelper(mod.parentBundle.siblingBundles),
+                _step4;
+
+            try {
+              for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+                let child = _step4.value;
+
+                if (!child.isEmpty) {
+                  yield _this2.addBundleLoader(child.type, asset);
+                }
+              }
+            } catch (err) {
+              _iterator4.e(err);
+            } finally {
+              _iterator4.f();
+            }
+
+            yield _this2.addBundleLoader(mod.type, asset, true);
+          } else {
+            // If the dep isn't in this bundle, add it to the list of external modules to preload.
+            // Only do this if this is the root JS bundle, otherwise they will have already been
+            // loaded in parallel with this bundle as part of a dynamic import.
+            if (!_this2.bundle.assets.has(mod) && (!_this2.bundle.parentBundle || _this2.bundle.parentBundle.type !== 'js') && _this2.options.bundleLoaders[mod.type]) {
+              _this2.externalModules.add(mod);
+
+              yield _this2.addBundleLoader(mod.type, asset);
+            }
+          }
+        } // if (this.bundle.entryAsset === asset && this.externalModules.size > 0) {
+        //   js = `
+        //     function $parcel$entry() {
+        //       ${js.trim()}
+        //     }
+        //   `;
+        // }
+        // js = js.trim() + '\n';
+
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+
+      _this2.size += js.length;
+    })();
+  }
+
+  shouldWrap(asset) {
+    if (!asset) {
+      return false;
+    }
+
+    if (asset.cacheData.shouldWrap != null) {
+      return asset.cacheData.shouldWrap;
+    } // Set to false initially so circular deps work
+
+
+    asset.cacheData.shouldWrap = false; // We need to wrap if any of the deps are marked by the hoister, e.g.
+    // when the dep is required inside a function or conditional.
+    // We also need to wrap if any of the parents are wrapped - transitive requires
+    // shouldn't be evaluated until their parents are.
+
+    let shouldWrap = [...asset.parentDeps].some(dep => dep.shouldWrap || this.shouldWrap(this.bundler.loadedAssets.get(dep.parent)));
+    asset.cacheData.shouldWrap = shouldWrap;
+    return shouldWrap;
+  }
+
+  addDeps(asset, included) {
+    if (!this.bundle.assets.has(asset) || included.has(asset)) {
+      return [];
+    }
+
+    included.add(asset);
+    let depAsts = new Map();
+
+    var _iterator5 = _createForOfIteratorHelper(asset.depAssets.values()),
+        _step5;
+
+    try {
+      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+        let depAsset = _step5.value;
+
+        if (!depAsts.has(depAsset)) {
+          let depAst = this.addDeps(depAsset, included);
+          depAsts.set(depAsset, depAst);
+        }
+      }
+    } catch (err) {
+      _iterator5.e(err);
+    } finally {
+      _iterator5.f();
+    }
+
+    let statements;
+
+    if (asset.cacheData.sideEffects === false && (!asset.usedExports || asset.usedExports.size === 0)) {
+      statements = [];
+    } else {
+      statements = this.parse(asset.generated.js, asset.name);
+    }
+
+    if (this.shouldWrap(asset)) {
+      statements = this.wrapModule(asset, statements);
+    }
+
+    if (statements[0]) {
+      if (!statements[0].leadingComments) {
+        statements[0].leadingComments = [];
+      }
+
+      statements[0].leadingComments.push({
+        type: 'CommentLine',
+        value: ` ASSET: ${path.relative(this.options.rootDir, asset.name)}`
+      });
+    }
+
+    let statementIndices = new Map();
+
+    for (let i = 0; i < statements.length; i++) {
+      let statement = statements[i];
+
+      if (t.isExpressionStatement(statement)) {
+        var _iterator6 = _createForOfIteratorHelper(this.findRequires(asset, statement)),
+            _step6;
+
+        try {
+          for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+            let depAsset = _step6.value;
+
+            if (!statementIndices.has(depAsset)) {
+              statementIndices.set(depAsset, i);
+            }
+          }
+        } catch (err) {
+          _iterator6.e(err);
+        } finally {
+          _iterator6.f();
+        }
+      }
+    }
+
+    let reverseDeps = [...asset.depAssets.values()].reverse();
+
+    var _iterator7 = _createForOfIteratorHelper(reverseDeps),
+        _step7;
+
+    try {
+      for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+        let dep = _step7.value;
+        let index = statementIndices.has(dep) ? statementIndices.get(dep) : 0;
+        statements.splice(index, 0, ...depAsts.get(dep));
+      }
+    } catch (err) {
+      _iterator7.e(err);
+    } finally {
+      _iterator7.f();
+    }
+
+    if (this.assetPostludes.has(asset)) {
+      statements.push(...this.parse(this.assetPostludes.get(asset)));
+    }
+
+    return statements;
+  }
+
+  wrapModule(asset, statements) {
+    let body = [];
+    let decls = [];
+    let fns = [];
+
+    var _iterator8 = _createForOfIteratorHelper(statements),
+        _step8;
+
+    try {
+      for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+        let node = _step8.value;
+
+        // Hoist all declarations out of the function wrapper
+        // so that they can be referenced by other modules directly.
+        if (t.isVariableDeclaration(node)) {
+          var _iterator9 = _createForOfIteratorHelper(node.declarations),
+              _step9;
+
+          try {
+            for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+              let decl = _step9.value;
+
+              if (t.isObjectPattern(decl.id) || t.isArrayPattern(decl.id)) {
+                for (var _i = 0, _Object$values = Object.values(t.getBindingIdentifiers(decl.id)); _i < _Object$values.length; _i++) {
+                  let prop = _Object$values[_i];
+                  decls.push(t.variableDeclarator(prop));
+                }
+
+                if (decl.init) {
+                  body.push(t.expressionStatement(t.assignmentExpression('=', decl.id, decl.init)));
+                }
+              } else {
+                decls.push(t.variableDeclarator(decl.id));
+
+                if (decl.init) {
+                  body.push(t.expressionStatement(t.assignmentExpression('=', t.identifier(decl.id.name), decl.init)));
+                }
+              }
+            }
+          } catch (err) {
+            _iterator9.e(err);
+          } finally {
+            _iterator9.f();
+          }
+        } else if (t.isFunctionDeclaration(node)) {
+          // Function declarations can be hoisted out of the module initialization function
+          fns.push(node);
+        } else if (t.isClassDeclaration(node)) {
+          // Class declarations are not hoisted. We declare a variable outside the
+          // function convert to a class expression assignment.
+          decls.push(t.variableDeclarator(t.identifier(node.id.name)));
+          body.push(t.expressionStatement(t.assignmentExpression('=', t.identifier(node.id.name), t.toExpression(node))));
+        } else {
+          body.push(node);
+        }
+      }
+    } catch (err) {
+      _iterator8.e(err);
+    } finally {
+      _iterator8.f();
+    }
+
+    let executed = getName(asset, 'executed');
+    decls.push(t.variableDeclarator(t.identifier(executed), t.booleanLiteral(false)));
+    let init = t.functionDeclaration(getIdentifier(asset, 'init'), [], t.blockStatement([t.ifStatement(t.identifier(executed), t.returnStatement()), t.expressionStatement(t.assignmentExpression('=', t.identifier(executed), t.booleanLiteral(true))), ...body]));
+    return [t.variableDeclaration('var', decls), ...fns, init];
+  }
+
+  parse(code, filename) {
+    let ast = babylon.parse(code, {
+      sourceFilename: filename,
+      allowReturnOutsideFunction: true
+    });
+    return ast.program.body;
+  }
+
+  findRequires(asset, ast) {
+    let result = [];
+    walk.simple(ast, {
+      CallExpression(node) {
+        let args = node.arguments,
+            callee = node.callee;
+
+        if (!t.isIdentifier(callee)) {
+          return;
+        }
+
+        if (callee.name === '$parcel$require') {
+          result.push(asset.depAssets.get(asset.dependencies.get(args[1].value)));
+        }
+      }
+
+    });
+    return result;
+  }
+
+  getBundleSpecifier(bundle) {
+    let name = path.relative(path.dirname(this.bundle.name), bundle.name);
+
+    if (bundle.entryAsset) {
+      return [name, bundle.entryAsset.id];
+    }
+
+    return name;
+  }
+
+  addAssetToBundle(asset) {
+    var _this3 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      if (_this3.bundle.assets.has(asset)) {
+        return;
+      }
+
+      _this3.assets.set(asset.id, asset);
+
+      _this3.bundle.addAsset(asset);
+
+      if (!asset.parentBundle) {
+        asset.parentBundle = _this3.bundle;
+      } // Add all dependencies as well
+
+
+      var _iterator10 = _createForOfIteratorHelper(asset.depAssets.values()),
+          _step10;
+
+      try {
+        for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+          let child = _step10.value;
+          yield _this3.addAssetToBundle(child, _this3.bundle);
+        }
+      } catch (err) {
+        _iterator10.e(err);
+      } finally {
+        _iterator10.f();
+      }
+
+      yield _this3.addAsset(asset);
+    })();
+  }
+
+  addBundleLoader(bundleType, parentAsset, dynamic) {
+    var _this4 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      let loader = _this4.options.bundleLoaders[bundleType];
+
+      if (!loader) {
+        return;
+      }
+
+      let bundleLoader = _this4.bundler.loadedAssets.get(require.resolve('../builtins/bundle-loader'));
+
+      if (!bundleLoader && !dynamic) {
+        bundleLoader = yield _this4.bundler.getAsset('_bundle_loader');
+      }
+
+      if (bundleLoader) {
+        // parentAsset.depAssets.set({name: '_bundle_loader'}, bundleLoader);
+        yield _this4.addAssetToBundle(bundleLoader);
+      } else {
+        return;
+      }
+
+      let target = _this4.options.target === 'node' ? 'node' : 'browser';
+      let asset = yield _this4.bundler.getAsset(loader[target]);
+
+      if (!_this4.bundle.assets.has(asset)) {
+        let dep = {
+          name: asset.name
+        };
+        asset.parentDeps.add(dep);
+        parentAsset.dependencies.set(dep.name, dep);
+        parentAsset.depAssets.set(dep, asset);
+
+        _this4.assetPostludes.set(asset, `${_this4.getExportIdentifier(bundleLoader)}.register(${JSON.stringify(bundleType)},${_this4.getExportIdentifier(asset)});\n`);
+
+        yield _this4.addAssetToBundle(asset);
+      }
+    })();
+  }
+
+  end() {
+    var _superprop_getWrite = () => super.write,
+        _superprop_getEnd = () => super.end,
+        _this5 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      let included = new Set();
+
+      var _iterator11 = _createForOfIteratorHelper(_this5.bundle.assets),
+          _step11;
+
+      try {
+        for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
+          let asset = _step11.value;
+
+          _this5.statements.push(..._this5.addDeps(asset, included));
+        } // Preload external modules before running entry point if needed
+
+      } catch (err) {
+        _iterator11.e(err);
+      } finally {
+        _iterator11.f();
+      }
+
+      if (_this5.externalModules.size > 0) {
+        let bundleLoader = _this5.bundler.loadedAssets.get(require.resolve('../builtins/bundle-loader'));
+
+        let preload = [];
+
+        var _iterator12 = _createForOfIteratorHelper(_this5.externalModules),
+            _step12;
+
+        try {
+          for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
+            let mod = _step12.value;
+            // Find the bundle that has the module as its entry point
+            let bundle = Array.from(mod.bundles).find(b => b.entryAsset === mod);
+
+            if (bundle) {
+              preload.push([path.basename(bundle.name), mod.id]);
+            }
+          }
+        } catch (err) {
+          _iterator12.e(err);
+        } finally {
+          _iterator12.f();
+        }
+
+        let loads = `${_this5.getExportIdentifier(bundleLoader)}.load(${JSON.stringify(preload)})`;
+
+        if (_this5.bundle.entryAsset) {
+          loads += '.then($parcel$entry)';
+        }
+
+        loads += ';';
+
+        _this5.write(loads);
+      }
+
+      let entryExports = _this5.bundle.entryAsset && _this5.getExportIdentifier(_this5.bundle.entryAsset);
+
+      if (entryExports && _this5.bundle.entryAsset.generated.js.includes(entryExports)) {
+        _this5.write(`
+        if (typeof exports === "object" && typeof module !== "undefined") {
+          // CommonJS
+          module.exports = ${entryExports};
+        } else if (typeof define === "function" && define.amd) {
+          // RequireJS
+          define(function () {
+            return ${entryExports};
+          });
+        } ${_this5.options.global ? `else {
+          // <script>
+          this[${JSON.stringify(_this5.options.global)}] = ${entryExports};
+        }` : ''}
+      `);
+      }
+
+      if (_this5.needsPrelude) {
+        let exposed = [];
+        let prepareModule = [];
+
+        var _iterator13 = _createForOfIteratorHelper(_this5.exposedModules),
+            _step13;
+
+        try {
+          for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
+            let m = _step13.value;
+
+            if (m.cacheData.isES6Module) {
+              prepareModule.push(`${_this5.getExportIdentifier(m)}.__esModule = true;`);
+            }
+
+            exposed.push(`"${m.id}": ${_this5.getExportIdentifier(m)}`);
+          }
+        } catch (err) {
+          _iterator13.e(err);
+        } finally {
+          _iterator13.f();
+        }
+
+        _this5.write(`
+        ${prepareModule.join('\n')}
+        return {${exposed.join(', ')}};
+      `);
+      }
+
+      try {
+        let ast = t.file(t.program(_this5.statements));
+
+        let _concat = concat(_this5, ast),
+            output = _concat.code;
+
+        if (!_this5.options.minify) {
+          output = '\n' + output + '\n';
+        }
+
+        let preludeCode = _this5.options.minify ? prelude.minified : prelude.source;
+
+        if (_this5.needsPrelude) {
+          output = preludeCode + '(function (require) {' + output + '});';
+        } else {
+          output = '(function () {' + output + '})();';
+        }
+
+        _this5.size = output.length;
+        let sourceMaps = _this5.options.sourceMaps;
+
+        if (sourceMaps) {
+          // Add source map url if a map bundle exists
+          let mapBundle = _this5.bundle.siblingBundlesMap.get('map');
+
+          if (mapBundle) {
+            let mapUrl = urlJoin(_this5.options.publicURL, path.basename(mapBundle.name));
+            output += `\n//# sourceMappingURL=${mapUrl}`;
+          }
+        }
+
+        yield _superprop_getWrite().call(_this5, output);
+      } catch (e) {
+        throw e;
+      } finally {
+        yield _superprop_getEnd().call(_this5);
+      }
+    })();
+  }
+
+  resolveModule(id, name) {
+    let module = this.assets.get(id);
+    return module.depAssets.get(module.dependencies.get(name));
+  }
+
+  findExportModule(id, name, replacements) {
+    let asset = this.assets.get(id);
+    let exp = asset && Object.prototype.hasOwnProperty.call(asset.cacheData.exports, name) ? asset.cacheData.exports[name] : null; // If this is a re-export, find the original module.
+
+    if (Array.isArray(exp)) {
+      let mod = this.resolveModule(id, exp[0]);
+      return this.findExportModule(mod.id, exp[1], replacements);
+    } // If this module exports wildcards, resolve the original module.
+    // Default exports are excluded from wildcard exports.
+
+
+    let wildcards = asset && asset.cacheData.wildcards;
+
+    if (wildcards && name !== 'default' && name !== '*') {
+      var _iterator14 = _createForOfIteratorHelper(wildcards),
+          _step14;
+
+      try {
+        for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
+          let source = _step14.value;
+          let mod = this.resolveModule(id, source);
+          let m = this.findExportModule(mod.id, name, replacements);
+
+          if (m.identifier) {
+            return m;
+          }
+        }
+      } catch (err) {
+        _iterator14.e(err);
+      } finally {
+        _iterator14.f();
+      }
+    } // If this is a wildcard import, resolve to the exports object.
+
+
+    if (asset && name === '*') {
+      exp = getName(asset, 'exports');
+    }
+
+    if (replacements && replacements.has(exp)) {
+      exp = replacements.get(exp);
+    }
+
+    return {
+      identifier: exp,
+      name,
+      id
+    };
+  }
+
+}
+
+module.exports = JSConcatPackager;

BACK_BACK/node_modules/parcel-bundler/lib/packagers/JSPackager.js

@@ -0,0 +1,326 @@
+"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 path = require('path');
+
+const Packager = require('./Packager');
+
+const getExisting = require('../utils/getExisting');
+
+const urlJoin = require('../utils/urlJoin');
+
+const lineCounter = require('../utils/lineCounter');
+
+const objectHash = require('../utils/objectHash');
+
+const prelude = getExisting(path.join(__dirname, '../builtins/prelude.min.js'), path.join(__dirname, '../builtins/prelude.js'));
+
+class JSPackager extends Packager {
+  start() {
+    var _this = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      _this.first = true;
+      _this.dedupe = new Map();
+      _this.bundleLoaders = new Set();
+      _this.externalModules = new Set();
+      let preludeCode = _this.options.minify ? prelude.minified : prelude.source;
+
+      if (_this.options.target === 'electron') {
+        preludeCode = `process.env.HMR_PORT=${_this.options.hmrPort};process.env.HMR_HOSTNAME=${JSON.stringify(_this.options.hmrHostname)};` + preludeCode;
+      }
+
+      yield _this.write(preludeCode + '({');
+      _this.lineOffset = lineCounter(preludeCode);
+    })();
+  }
+
+  addAsset(asset) {
+    var _this2 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      // If this module is referenced by another JS bundle, it needs to be exposed externally.
+      // In that case, don't dedupe the asset as it would affect the module ids that are referenced by other bundles.
+      let isExposed = !Array.from(asset.parentDeps).every(dep => {
+        let depAsset = _this2.bundler.loadedAssets.get(dep.parent);
+
+        return _this2.bundle.assets.has(depAsset) || depAsset.type !== 'js';
+      });
+
+      if (!isExposed) {
+        let key = _this2.dedupeKey(asset);
+
+        if (_this2.dedupe.has(key)) {
+          return;
+        } // Don't dedupe when HMR is turned on since it messes with the asset ids
+
+
+        if (!_this2.options.hmr) {
+          _this2.dedupe.set(key, asset.id);
+        }
+      }
+
+      let deps = {};
+
+      var _iterator = _createForOfIteratorHelper(asset.depAssets),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          let _step$value = (0, _slicedToArray2.default)(_step.value, 2),
+              dep = _step$value[0],
+              mod = _step$value[1];
+
+          // For dynamic dependencies, list the child bundles to load along with the module id
+          if (dep.dynamic) {
+            let bundles = [_this2.getBundleSpecifier(mod.parentBundle)];
+
+            var _iterator2 = _createForOfIteratorHelper(mod.parentBundle.siblingBundles),
+                _step2;
+
+            try {
+              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                let child = _step2.value;
+
+                if (!child.isEmpty) {
+                  bundles.push(_this2.getBundleSpecifier(child));
+
+                  _this2.bundleLoaders.add(child.type);
+                }
+              }
+            } catch (err) {
+              _iterator2.e(err);
+            } finally {
+              _iterator2.f();
+            }
+
+            bundles.push(mod.id);
+            deps[dep.name] = bundles;
+
+            _this2.bundleLoaders.add(mod.type);
+          } else {
+            deps[dep.name] = _this2.dedupe.get(_this2.dedupeKey(mod)) || mod.id; // If the dep isn't in this bundle, add it to the list of external modules to preload.
+            // Only do this if this is the root JS bundle, otherwise they will have already been
+            // loaded in parallel with this bundle as part of a dynamic import.
+
+            if (!_this2.bundle.assets.has(mod)) {
+              _this2.externalModules.add(mod);
+
+              if (!_this2.bundle.parentBundle || _this2.bundle.isolated || _this2.bundle.parentBundle.type !== 'js') {
+                _this2.bundleLoaders.add(mod.type);
+              }
+            }
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+
+      _this2.bundle.addOffset(asset, _this2.lineOffset);
+
+      yield _this2.writeModule(asset.id, asset.generated.js, deps, asset.generated.map);
+    })();
+  }
+
+  getBundleSpecifier(bundle) {
+    let name = path.relative(path.dirname(this.bundle.name), bundle.name);
+
+    if (bundle.entryAsset) {
+      return [name, bundle.entryAsset.id];
+    }
+
+    return name;
+  }
+
+  dedupeKey(asset) {
+    // cannot rely *only* on generated JS for deduplication because paths like
+    // `../` can cause 2 identical JS files to behave differently depending on
+    // where they are located on the filesystem
+    let deps = Array.from(asset.depAssets.values(), dep => dep.name).sort();
+    return objectHash([asset.generated.js, deps]);
+  }
+
+  writeModule(id, code, deps = {}, map) {
+    var _this3 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      let wrapped = _this3.first ? '' : ',';
+      wrapped += JSON.stringify(id) + ':[function(require,module,exports) {\n' + (code || '') + '\n},';
+      wrapped += JSON.stringify(deps);
+      wrapped += ']';
+      _this3.first = false;
+      yield _this3.write(wrapped); // Use the pre-computed line count from the source map if possible
+
+      let lineCount = map && map.lineCount ? map.lineCount : lineCounter(code);
+      _this3.lineOffset += 1 + lineCount;
+    })();
+  }
+
+  addAssetToBundle(asset) {
+    var _this4 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      if (_this4.bundle.assets.has(asset)) {
+        return;
+      }
+
+      _this4.bundle.addAsset(asset);
+
+      if (!asset.parentBundle) {
+        asset.parentBundle = _this4.bundle;
+      } // Add all dependencies as well
+
+
+      var _iterator3 = _createForOfIteratorHelper(asset.depAssets.values()),
+          _step3;
+
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          let child = _step3.value;
+          yield _this4.addAssetToBundle(child);
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+
+      yield _this4.addAsset(asset);
+    })();
+  }
+
+  writeBundleLoaders() {
+    var _this5 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      if (_this5.bundleLoaders.size === 0) {
+        return false;
+      }
+
+      let bundleLoader = _this5.bundler.loadedAssets.get(require.resolve('../builtins/bundle-loader'));
+
+      if (_this5.externalModules.size > 0 && !bundleLoader) {
+        bundleLoader = yield _this5.bundler.getAsset('_bundle_loader');
+      }
+
+      if (bundleLoader) {
+        yield _this5.addAssetToBundle(bundleLoader);
+      } else {
+        return;
+      } // Generate a module to register the bundle loaders that are needed
+
+
+      let loads = 'var b=require(' + JSON.stringify(bundleLoader.id) + ');';
+
+      var _iterator4 = _createForOfIteratorHelper(_this5.bundleLoaders),
+          _step4;
+
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          let bundleType = _step4.value;
+          let loader = _this5.options.bundleLoaders[bundleType];
+
+          if (loader) {
+            let target = _this5.options.target === 'node' ? 'node' : 'browser';
+            let asset = yield _this5.bundler.getAsset(loader[target]);
+            yield _this5.addAssetToBundle(asset);
+            loads += 'b.register(' + JSON.stringify(bundleType) + ',require(' + JSON.stringify(asset.id) + '));';
+          }
+        } // Preload external modules before running entry point if needed
+
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+
+      if (_this5.externalModules.size > 0) {
+        let preload = [];
+
+        var _iterator5 = _createForOfIteratorHelper(_this5.externalModules),
+            _step5;
+
+        try {
+          for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+            let mod = _step5.value;
+            // Find the bundle that has the module as its entry point
+            let bundle = Array.from(mod.bundles).find(b => b.entryAsset === mod);
+
+            if (bundle) {
+              preload.push([path.basename(bundle.name), mod.id]);
+            }
+          }
+        } catch (err) {
+          _iterator5.e(err);
+        } finally {
+          _iterator5.f();
+        }
+
+        loads += 'b.load(' + JSON.stringify(preload) + ')';
+
+        if (_this5.bundle.entryAsset) {
+          loads += `.then(function(){require(${JSON.stringify(_this5.bundle.entryAsset.id)});})`;
+        }
+
+        loads += ';';
+      } // Asset ids normally start at 1, so this should be safe.
+
+
+      yield _this5.writeModule(0, loads, {});
+      return true;
+    })();
+  }
+
+  end() {
+    var _superprop_getEnd = () => super.end,
+        _this6 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      let entry = []; // Add the HMR runtime if needed.
+
+      if (_this6.options.hmr) {
+        let asset = yield _this6.bundler.getAsset(require.resolve('../builtins/hmr-runtime'));
+        yield _this6.addAssetToBundle(asset);
+        entry.push(asset.id);
+      }
+
+      if (yield _this6.writeBundleLoaders()) {
+        entry.push(0);
+      }
+
+      if (_this6.bundle.entryAsset && _this6.externalModules.size === 0) {
+        entry.push(_this6.bundle.entryAsset.id);
+      }
+
+      yield _this6.write('},{},' + JSON.stringify(entry) + ', ' + JSON.stringify(_this6.options.global || null) + ')');
+
+      if (_this6.options.sourceMaps) {
+        // Add source map url if a map bundle exists
+        let mapBundle = _this6.bundle.siblingBundlesMap.get('map');
+
+        if (mapBundle) {
+          let mapUrl = urlJoin(_this6.options.publicURL, path.relative(_this6.options.outDir, mapBundle.name));
+          yield _this6.write(`\n//# sourceMappingURL=${mapUrl}`);
+        }
+      }
+
+      yield _superprop_getEnd().call(_this6);
+    })();
+  }
+
+}
+
+module.exports = JSPackager;

BACK_BACK/node_modules/parcel-bundler/lib/packagers/Packager.js

@@ -0,0 +1,76 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+const fs = require('fs');
+
+const _require = require('@parcel/utils'),
+      promisify = _require.promisify;
+
+const path = require('path');
+
+const _require2 = require('@parcel/fs'),
+      mkdirp = _require2.mkdirp;
+
+class Packager {
+  constructor(bundle, bundler) {
+    this.bundle = bundle;
+    this.bundler = bundler;
+    this.options = bundler.options;
+  }
+
+  static shouldAddAsset() {
+    return true;
+  }
+
+  setup() {
+    var _this = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      // Create sub-directories if needed
+      if (_this.bundle.name.includes(path.sep)) {
+        yield mkdirp(path.dirname(_this.bundle.name));
+      }
+
+      _this.dest = fs.createWriteStream(_this.bundle.name);
+      _this.dest.write = promisify(_this.dest.write.bind(_this.dest));
+      _this.dest.end = promisify(_this.dest.end.bind(_this.dest));
+    })();
+  }
+
+  write(string) {
+    var _this2 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      yield _this2.dest.write(string);
+    })();
+  }
+
+  start() {
+    return (0, _asyncToGenerator2.default)(function* () {})();
+  } // eslint-disable-next-line no-unused-vars
+
+
+  addAsset(asset) {
+    return (0, _asyncToGenerator2.default)(function* () {
+      throw new Error('Must be implemented by subclasses');
+    })();
+  }
+
+  getSize() {
+    return this.dest.bytesWritten;
+  }
+
+  end() {
+    var _this3 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      yield _this3.dest.end();
+    })();
+  }
+
+}
+
+module.exports = Packager;

BACK_BACK/node_modules/parcel-bundler/lib/packagers/RawPackager.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+const Packager = require('./Packager');
+
+const path = require('path');
+
+const fs = require('@parcel/fs');
+
+class RawPackager extends Packager {
+  static shouldAddAsset() {
+    // We cannot combine multiple raw assets together - they should be written as separate bundles.
+    return false;
+  } // Override so we don't create a file for this bundle.
+  // Each asset will be emitted as a separate file instead.
+
+
+  setup() {}
+
+  addAsset(asset) {
+    var _this = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      let contents = asset.generated[_this.bundle.type];
+
+      if (!contents || contents && contents.path) {
+        contents = yield fs.readFile(contents ? contents.path : asset.name);
+      } // Create sub-directories if needed
+
+
+      if (_this.bundle.name.includes(path.sep)) {
+        yield fs.mkdirp(path.dirname(_this.bundle.name));
+      }
+
+      _this.size = contents.length;
+      yield fs.writeFile(_this.bundle.name, contents);
+    })();
+  }
+
+  getSize() {
+    return this.size || 0;
+  }
+
+  end() {}
+
+}
+
+module.exports = RawPackager;

BACK_BACK/node_modules/parcel-bundler/lib/packagers/SourceMapPackager.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+const path = require('path');
+
+const Packager = require('./Packager');
+
+const SourceMap = require('../SourceMap');
+
+class SourceMapPackager extends Packager {
+  start() {
+    var _this = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      _this.sourceMap = new SourceMap();
+    })();
+  }
+
+  addAsset(asset) {
+    var _this2 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      let offsets = _this2.bundle.parentBundle.getOffset(asset);
+
+      if (asset.sourceMaps[asset.type]) {
+        yield _this2.sourceMap.addMap(asset.sourceMaps[asset.type], offsets[0], offsets[1]);
+      }
+    })();
+  }
+
+  end() {
+    var _superprop_getEnd = () => super.end,
+        _this3 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      let file = path.basename(_this3.bundle.parentBundle.name);
+      yield _this3.write(_this3.sourceMap.stringify(file, path.relative(_this3.options.outDir, _this3.options.rootDir)));
+      yield _superprop_getEnd().call(_this3);
+    })();
+  }
+
+}
+
+module.exports = SourceMapPackager;

BACK_BACK/node_modules/parcel-bundler/lib/packagers/index.js

@@ -0,0 +1,42 @@
+"use strict";
+
+const JSConcatPackager = require('./JSConcatPackager');
+
+const JSPackager = require('./JSPackager');
+
+const CSSPackager = require('./CSSPackager');
+
+const HTMLPackager = require('./HTMLPackager');
+
+const SourceMapPackager = require('./SourceMapPackager');
+
+const RawPackager = require('./RawPackager');
+
+class PackagerRegistry {
+  constructor(options) {
+    this.packagers = new Map();
+    this.add('css', CSSPackager);
+    this.add('html', HTMLPackager);
+    this.add('map', SourceMapPackager);
+    this.add('js', options.scopeHoist ? JSConcatPackager : JSPackager);
+  }
+
+  add(type, packager) {
+    if (typeof packager === 'string') {
+      packager = require(packager);
+    }
+
+    this.packagers.set(type, packager);
+  }
+
+  has(type) {
+    return this.packagers.has(type);
+  }
+
+  get(type) {
+    return this.packagers.get(type) || RawPackager;
+  }
+
+}
+
+module.exports = PackagerRegistry;