flow like the river

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

@@ -0,0 +1,59 @@
+'use strict';
+
+function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
+
+const Packager = require('./Packager');
+
+class CSSPackager extends Packager {
+  addAsset(asset) {
+    var _this = this;
+
+    return _asyncToGenerator(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 _iteratorNormalCompletion = true;
+      var _didIteratorError = false;
+      var _iteratorError = undefined;
+
+      try {
+        for (var _iterator = asset.parentDeps[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          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) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+
+      if (media.length) {
+        css = `@media ${media.join(', ')} {\n${css.trim()}\n}\n`;
+      }
+
+      yield _this.write(css);
+    })();
+  }
+}
+
+module.exports = CSSPackager;

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

@@ -0,0 +1,119 @@
+'use strict';
+
+function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
+
+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 {
+  addAsset(asset) {
+    var _this = this;
+
+    return _asyncToGenerator(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(function (p, b) {
+        return p.concat([...b.siblingBundles.values()]);
+      }, []).filter(function (b) {
+        return 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 _iteratorNormalCompletion = true;
+    var _didIteratorError = false;
+    var _iteratorError = undefined;
+
+    try {
+      for (var _iterator = siblingBundles[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        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) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+
+    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;

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

@@ -0,0 +1,360 @@
+'use strict';
+
+var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
+
+function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
+
+const Packager = require('./Packager');
+const t = require('babel-types');
+const path = require('path');
+const fs = require('fs');
+
+const concat = require('../transforms/concat');
+
+const prelude = fs.readFileSync(path.join(__dirname, '../builtins/prelude2.js'), 'utf8').trim();
+
+class JSConcatPackager extends Packager {
+  write(string) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      _this.buffer += string;
+    })();
+  }
+
+  start() {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      _this2.addedAssets = new Set();
+      _this2.exposedModules = new Set();
+      _this2.buffer = '';
+      _this2.exports = new Map();
+      _this2.wildcards = new Map();
+      _this2.moduleMap = new Map();
+      _this2.needsPrelude = process.env.NODE_ENV === 'test';
+
+      var _iteratorNormalCompletion = true;
+      var _didIteratorError = false;
+      var _iteratorError = undefined;
+
+      try {
+        for (var _iterator = _this2.bundle.assets[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          let asset = _step.value;
+
+          // If this module is referenced by another bundle, it needs to be exposed externally.
+          let isExposed = !Array.from(asset.parentDeps).every(function (dep) {
+            return _this2.bundle.assets.has(_this2.bundler.loadedAssets.get(dep.parent));
+          });
+
+          if (isExposed || _this2.bundle.entryAsset === asset && _this2.bundle.parentBundle) {
+            _this2.exposedModules.add(asset);
+            _this2.needsPrelude = true;
+          }
+
+          var _iteratorNormalCompletion2 = true;
+          var _didIteratorError2 = false;
+          var _iteratorError2 = undefined;
+
+          try {
+            for (var _iterator2 = asset.depAssets.values()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+              let mod = _step2.value;
+
+              if (!_this2.bundle.assets.has(mod)) {
+                _this2.needsPrelude = true;
+                break;
+              }
+            }
+          } catch (err) {
+            _didIteratorError2 = true;
+            _iteratorError2 = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion2 && _iterator2.return) {
+                _iterator2.return();
+              }
+            } finally {
+              if (_didIteratorError2) {
+                throw _iteratorError2;
+              }
+            }
+          }
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+
+      if (_this2.needsPrelude) {
+        if (_this2.bundle.entryAsset) {
+          _this2.exposedModules.add(_this2.bundle.entryAsset);
+        }
+
+        yield _this2.write(prelude + '(function (require) {\n');
+      } else {
+        yield _this2.write('(function () {\n');
+      }
+    })();
+  }
+
+  getExportIdentifier(asset) {
+    return '$' + asset.id + '$exports';
+  }
+
+  addAsset(asset) {
+    var _this3 = this;
+
+    return _asyncToGenerator(function* () {
+      if (_this3.addedAssets.has(asset)) {
+        return;
+      }
+
+      _this3.addedAssets.add(asset);
+      let js = asset.generated.js;
+
+      _this3.moduleMap.set(asset.id, asset);
+      _this3.wildcards.set(asset.id, asset.cacheData.wildcards);
+
+      for (let key in asset.cacheData.exports) {
+        let local = '$' + asset.id + '$export$' + asset.cacheData.exports[key];
+        if (key !== local) {
+          _this3.exports.set(key, local);
+        }
+      }
+
+      var _iteratorNormalCompletion3 = true;
+      var _didIteratorError3 = false;
+      var _iteratorError3 = undefined;
+
+      try {
+        for (var _iterator3 = asset.depAssets[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+          let _ref = _step3.value;
+
+          var _ref2 = _slicedToArray(_ref, 2);
+
+          let dep = _ref2[0];
+          let mod = _ref2[1];
+
+          let depName = '$' + asset.id + '$require$' + t.toIdentifier(dep.name);
+          let moduleName = _this3.getExportIdentifier(mod);
+
+          // If this module is not in the current bundle, generate a `require` call for it.
+          if (!_this3.bundle.assets.has(mod)) {
+            moduleName = `require(${mod.id})`;
+          }
+
+          js = js.split(depName).join(moduleName);
+
+          // If this was an ES6 export all (e.g. export * from 'foo'), resolve to the original exports.
+          if (dep.isExportAll) {
+            for (let exp in mod.cacheData.exports) {
+              let id = mod.cacheData.exports[exp];
+              if (id !== 'default') {
+                let key = '$' + asset.id + '$export$' + id;
+                asset.cacheData.exports[key] = id;
+                _this3.exports.set(key, _this3.exports.get('$' + mod.id + '$export$' + id) || exp);
+              }
+            }
+          }
+
+          if (dep.isES6Import) {
+            if (mod.cacheData.isES6Module) {
+              js = js.split('$' + asset.id + '$import$' + t.toIdentifier(dep.name)).join('$' + mod.id + '$export');
+            } else {
+              js = js.split('$' + asset.id + '$import$' + t.toIdentifier(dep.name) + '$default').join('$' + mod.id + '$exports');
+              js = js.split('$' + asset.id + '$import$' + t.toIdentifier(dep.name) + '$').join('$' + mod.id + '$exports.');
+            }
+          }
+
+          let depResolve = '$' + asset.id + '$require_resolve$' + t.toIdentifier(dep.name);
+          let resolved = '' + mod.id;
+
+          if (dep.dynamic && _this3.bundle.childBundles.has(mod.parentBundle)) {
+            let bundles = [_this3.getBundleSpecifier(mod.parentBundle)];
+            var _iteratorNormalCompletion4 = true;
+            var _didIteratorError4 = false;
+            var _iteratorError4 = undefined;
+
+            try {
+              for (var _iterator4 = mod.parentBundle.siblingBundles[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+                let child = _step4.value;
+
+                if (!child.isEmpty) {
+                  bundles.push(_this3.getBundleSpecifier(child));
+                  yield _this3.addBundleLoader(child.type);
+                }
+              }
+            } catch (err) {
+              _didIteratorError4 = true;
+              _iteratorError4 = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion4 && _iterator4.return) {
+                  _iterator4.return();
+                }
+              } finally {
+                if (_didIteratorError4) {
+                  throw _iteratorError4;
+                }
+              }
+            }
+
+            bundles.push(mod.id);
+            resolved = JSON.stringify(bundles);
+            yield _this3.addBundleLoader(mod.type);
+          }
+
+          js = js.split(depResolve).join(resolved);
+        }
+
+        // Replace all re-exported variables
+      } catch (err) {
+        _didIteratorError3 = true;
+        _iteratorError3 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion3 && _iterator3.return) {
+            _iterator3.return();
+          }
+        } finally {
+          if (_didIteratorError3) {
+            throw _iteratorError3;
+          }
+        }
+      }
+
+      js = js.trim() + '\n';
+
+      yield _this3.write(`\n/* ASSET: ${asset.id} - ${path.relative(_this3.options.rootDir, asset.name)} */\n${js}`);
+    })();
+  }
+
+  getBundleSpecifier(bundle) {
+    let name = path.basename(bundle.name);
+    if (bundle.entryAsset) {
+      return [name, bundle.entryAsset.id];
+    }
+
+    return name;
+  }
+
+  addAssetToBundle(asset) {
+    var _this4 = this;
+
+    return _asyncToGenerator(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 _iteratorNormalCompletion5 = true;
+      var _didIteratorError5 = false;
+      var _iteratorError5 = undefined;
+
+      try {
+        for (var _iterator5 = asset.depAssets.values()[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+          let child = _step5.value;
+
+          yield _this4.addAssetToBundle(child, _this4.bundle);
+        }
+      } catch (err) {
+        _didIteratorError5 = true;
+        _iteratorError5 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion5 && _iterator5.return) {
+            _iterator5.return();
+          }
+        } finally {
+          if (_didIteratorError5) {
+            throw _iteratorError5;
+          }
+        }
+      }
+
+      yield _this4.addAsset(asset);
+    })();
+  }
+
+  addBundleLoader(bundleType) {
+    var _this5 = this;
+
+    return _asyncToGenerator(function* () {
+      let bundleLoader = _this5.bundler.loadedAssets.get(require.resolve('../builtins/bundle-loader'));
+      if (!bundleLoader) {
+        bundleLoader = yield _this5.bundler.getAsset('_bundle_loader');
+      }
+
+      if (bundleLoader) {
+        yield _this5.addAssetToBundle(bundleLoader);
+      } else {
+        return;
+      }
+
+      let loader = _this5.options.bundleLoaders[bundleType];
+      if (loader) {
+        let asset = yield _this5.bundler.getAsset(loader);
+        if (!_this5.bundle.assets.has(asset)) {
+          yield _this5.addAssetToBundle(asset);
+          yield _this5.write(`${_this5.getExportIdentifier(bundleLoader)}.register(${JSON.stringify(bundleType)},${_this5.getExportIdentifier(asset)});\n`);
+        }
+      }
+    })();
+  }
+
+  end() {
+    var _this6 = this;
+
+    return _asyncToGenerator(function* () {
+      if (_this6.needsPrelude) {
+        let exposed = [];
+        var _iteratorNormalCompletion6 = true;
+        var _didIteratorError6 = false;
+        var _iteratorError6 = undefined;
+
+        try {
+          for (var _iterator6 = _this6.exposedModules[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
+            let m = _step6.value;
+
+            exposed.push(`${m.id}: ${_this6.getExportIdentifier(m)}`);
+          }
+        } catch (err) {
+          _didIteratorError6 = true;
+          _iteratorError6 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion6 && _iterator6.return) {
+              _iterator6.return();
+            }
+          } finally {
+            if (_didIteratorError6) {
+              throw _iteratorError6;
+            }
+          }
+        }
+
+        yield _this6.write(`return {${exposed.join(', ')}};\n})`);
+      } else {
+        yield _this6.write('})();');
+      }
+
+      Packager.prototype.write.call(_this6, concat(_this6.buffer, _this6.exports, _this6.moduleMap, _this6.wildcards));
+    })();
+  }
+}
+
+module.exports = JSConcatPackager;

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

@@ -0,0 +1,333 @@
+'use strict';
+
+var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
+
+function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
+
+const fs = require('fs');
+const path = require('path');
+const Packager = require('./Packager');
+const urlJoin = require('../utils/urlJoin');
+const lineCounter = require('../utils/lineCounter');
+
+const prelude = {
+  source: fs.readFileSync(path.join(__dirname, '../builtins/prelude.js'), 'utf8').trim(),
+  minified: fs.readFileSync(path.join(__dirname, '../builtins/prelude.min.js'), 'utf8').trim().replace(/;$/, '')
+};
+
+class JSPackager extends Packager {
+  start() {
+    var _this = this;
+
+    return _asyncToGenerator(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 _asyncToGenerator(function* () {
+      if (_this2.dedupe.has(asset.generated.js)) {
+        return;
+      }
+
+      // Don't dedupe when HMR is turned on since it messes with the asset ids
+      if (!_this2.options.hmr) {
+        _this2.dedupe.set(asset.generated.js, asset.id);
+      }
+
+      let deps = {};
+      var _iteratorNormalCompletion = true;
+      var _didIteratorError = false;
+      var _iteratorError = undefined;
+
+      try {
+        for (var _iterator = asset.depAssets[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          let _ref = _step.value;
+
+          var _ref2 = _slicedToArray(_ref, 2);
+
+          let dep = _ref2[0];
+          let mod = _ref2[1];
+
+          // For dynamic dependencies, list the child bundles to load along with the module id
+          if (dep.dynamic && _this2.bundle.childBundles.has(mod.parentBundle)) {
+            let bundles = [_this2.getBundleSpecifier(mod.parentBundle)];
+            var _iteratorNormalCompletion2 = true;
+            var _didIteratorError2 = false;
+            var _iteratorError2 = undefined;
+
+            try {
+              for (var _iterator2 = mod.parentBundle.siblingBundles[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+                let child = _step2.value;
+
+                if (!child.isEmpty) {
+                  bundles.push(_this2.getBundleSpecifier(child));
+                  _this2.bundleLoaders.add(child.type);
+                }
+              }
+            } catch (err) {
+              _didIteratorError2 = true;
+              _iteratorError2 = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion2 && _iterator2.return) {
+                  _iterator2.return();
+                }
+              } finally {
+                if (_didIteratorError2) {
+                  throw _iteratorError2;
+                }
+              }
+            }
+
+            bundles.push(mod.id);
+            deps[dep.name] = bundles;
+            _this2.bundleLoaders.add(mod.type);
+          } else {
+            deps[dep.name] = _this2.dedupe.get(mod.generated.js) || 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.bundle.parentBundle || _this2.bundle.parentBundle.type !== 'js')) {
+              _this2.externalModules.add(mod);
+              _this2.bundleLoaders.add(mod.type);
+            }
+          }
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+
+      _this2.bundle.addOffset(asset, _this2.lineOffset);
+      yield _this2.writeModule(asset.id, asset.generated.js, deps, asset.generated.map);
+    })();
+  }
+
+  getBundleSpecifier(bundle) {
+    let name = path.basename(bundle.name);
+    if (bundle.entryAsset) {
+      return [name, bundle.entryAsset.id];
+    }
+
+    return name;
+  }
+
+  writeModule(id, code, deps = {}, map) {
+    var _this3 = this;
+
+    return _asyncToGenerator(function* () {
+      let wrapped = _this3.first ? '' : ',';
+      wrapped += 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 _asyncToGenerator(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 _iteratorNormalCompletion3 = true;
+      var _didIteratorError3 = false;
+      var _iteratorError3 = undefined;
+
+      try {
+        for (var _iterator3 = asset.depAssets.values()[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+          let child = _step3.value;
+
+          yield _this4.addAssetToBundle(child, _this4.bundle);
+        }
+      } catch (err) {
+        _didIteratorError3 = true;
+        _iteratorError3 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion3 && _iterator3.return) {
+            _iterator3.return();
+          }
+        } finally {
+          if (_didIteratorError3) {
+            throw _iteratorError3;
+          }
+        }
+      }
+
+      yield _this4.addAsset(asset);
+    })();
+  }
+
+  writeBundleLoaders() {
+    var _this5 = this;
+
+    return _asyncToGenerator(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(' + bundleLoader.id + ');';
+      var _iteratorNormalCompletion4 = true;
+      var _didIteratorError4 = false;
+      var _iteratorError4 = undefined;
+
+      try {
+        for (var _iterator4 = _this5.bundleLoaders[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+          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(' + asset.id + '));';
+          }
+        }
+
+        // Preload external modules before running entry point if needed
+      } catch (err) {
+        _didIteratorError4 = true;
+        _iteratorError4 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion4 && _iterator4.return) {
+            _iterator4.return();
+          }
+        } finally {
+          if (_didIteratorError4) {
+            throw _iteratorError4;
+          }
+        }
+      }
+
+      if (_this5.externalModules.size > 0) {
+        let preload = [];
+        var _iteratorNormalCompletion5 = true;
+        var _didIteratorError5 = false;
+        var _iteratorError5 = undefined;
+
+        try {
+          for (var _iterator5 = _this5.externalModules[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+            let mod = _step5.value;
+
+            // Find the bundle that has the module as its entry point
+            let bundle = Array.from(mod.bundles).find(function (b) {
+              return b.entryAsset === mod;
+            });
+            if (bundle) {
+              preload.push([path.basename(bundle.name), mod.id]);
+            }
+          }
+        } catch (err) {
+          _didIteratorError5 = true;
+          _iteratorError5 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion5 && _iterator5.return) {
+              _iterator5.return();
+            }
+          } finally {
+            if (_didIteratorError5) {
+              throw _iteratorError5;
+            }
+          }
+        }
+
+        if (_this5.bundle.entryAsset) {
+          preload.push(_this5.bundle.entryAsset.id);
+        }
+
+        loads += 'b.load(' + JSON.stringify(preload) + ');';
+      }
+
+      // Asset ids normally start at 1, so this should be safe.
+      yield _this5.writeModule(0, loads, {});
+      return true;
+    })();
+  }
+
+  end() {
+    var _this6 = this;
+
+    return _asyncToGenerator(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.dest.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) {
+          yield _this6.write(`\n//# sourceMappingURL=${urlJoin(_this6.options.publicURL, path.basename(mapBundle.name))}`);
+        }
+      }
+      yield _this6.dest.end();
+    })();
+  }
+}
+
+module.exports = JSPackager;

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

@@ -0,0 +1,68 @@
+'use strict';
+
+function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
+
+const fs = require('fs');
+const promisify = require('../utils/promisify');
+const path = require('path');
+
+var _require = require('../utils/fs');
+
+const mkdirp = _require.mkdirp;
+
+
+class Packager {
+  constructor(bundle, bundler) {
+    this.bundle = bundle;
+    this.bundler = bundler;
+    this.options = bundler.options;
+  }
+
+  setup() {
+    var _this = this;
+
+    return _asyncToGenerator(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 _asyncToGenerator(function* () {
+      yield _this2.dest.write(string);
+    })();
+  }
+
+  start() {
+    return _asyncToGenerator(function* () {})();
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  addAsset(asset) {
+    return _asyncToGenerator(function* () {
+      throw new Error('Must be implemented by subclasses');
+    })();
+  }
+
+  getSize() {
+    return this.dest.bytesWritten;
+  }
+
+  end() {
+    var _this3 = this;
+
+    return _asyncToGenerator(function* () {
+      yield _this3.dest.end();
+    })();
+  }
+}
+
+module.exports = Packager;

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

@@ -0,0 +1,40 @@
+'use strict';
+
+function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
+
+const Packager = require('./Packager');
+const path = require('path');
+const fs = require('../utils/fs');
+
+class RawPackager extends Packager {
+  // 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 _asyncToGenerator(function* () {
+      let contents = asset.generated[asset.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;

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

@@ -0,0 +1,37 @@
+'use strict';
+
+function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
+
+const path = require('path');
+const Packager = require('./Packager');
+const SourceMap = require('../SourceMap');
+
+class SourceMapPackager extends Packager {
+  start() {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      _this.sourceMap = new SourceMap();
+    })();
+  }
+
+  addAsset(asset) {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      yield _this2.sourceMap.addMap(asset.generated.map, _this2.bundle.parentBundle.getOffset(asset));
+    })();
+  }
+
+  end() {
+    var _this3 = this;
+
+    return _asyncToGenerator(function* () {
+      let file = path.basename(_this3.bundle.name);
+      yield _this3.write(_this3.sourceMap.stringify(file, path.relative(_this3.options.outDir, _this3.options.rootDir)));
+      yield Packager.prototype.end.call(_this3);
+    })();
+  }
+}
+
+module.exports = SourceMapPackager;

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

@@ -0,0 +1,36 @@
+'use strict';
+
+const JSPackager = require('./JSPackager');
+const CSSPackager = require('./CSSPackager');
+const HTMLPackager = require('./HTMLPackager');
+const SourceMapPackager = require('./SourceMapPackager');
+const RawPackager = require('./RawPackager');
+
+class PackagerRegistry {
+  constructor() {
+    this.packagers = new Map();
+
+    this.add('js', JSPackager);
+    this.add('css', CSSPackager);
+    this.add('html', HTMLPackager);
+    this.add('map', SourceMapPackager);
+  }
+
+  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;