flow like the river

VISUALIZACION/node_modules/parcel-bundler/lib/Asset.js

@@ -0,0 +1,271 @@
+'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 URL = require('url');
+const path = require('path');
+const fs = require('./utils/fs');
+const objectHash = require('./utils/objectHash');
+const md5 = require('./utils/md5');
+const isURL = require('./utils/is-url');
+const config = require('./utils/config');
+
+let ASSET_ID = 1;
+
+/**
+ * An Asset represents a file in the dependency tree. Assets can have multiple
+ * parents that depend on it, and can be added to multiple output bundles.
+ * The base Asset class doesn't do much by itself, but sets up an interface
+ * for subclasses to implement.
+ */
+class Asset {
+  constructor(name, pkg, options) {
+    this.id = ASSET_ID++;
+    this.name = name;
+    this.basename = path.basename(this.name);
+    this.relativeName = path.relative(options.rootDir, this.name);
+    this.package = pkg || {};
+    this.options = options;
+    this.encoding = 'utf8';
+    this.type = path.extname(this.name).slice(1);
+
+    this.processed = false;
+    this.contents = options.rendition ? options.rendition.value : null;
+    this.ast = null;
+    this.generated = null;
+    this.hash = null;
+    this.parentDeps = new Set();
+    this.dependencies = new Map();
+    this.depAssets = new Map();
+    this.parentBundle = null;
+    this.bundles = new Set();
+    this.cacheData = {};
+    this.buildTime = 0;
+    this.bundledSize = 0;
+  }
+
+  shouldInvalidate() {
+    return false;
+  }
+
+  loadIfNeeded() {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      if (_this.contents == null) {
+        _this.contents = yield _this.load();
+      }
+    })();
+  }
+
+  parseIfNeeded() {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      yield _this2.loadIfNeeded();
+      if (!_this2.ast) {
+        _this2.ast = yield _this2.parse(_this2.contents);
+      }
+    })();
+  }
+
+  getDependencies() {
+    var _this3 = this;
+
+    return _asyncToGenerator(function* () {
+      if (_this3.options.rendition && _this3.options.rendition.hasDependencies === false) {
+        return;
+      }
+
+      yield _this3.loadIfNeeded();
+
+      if (_this3.contents && _this3.mightHaveDependencies()) {
+        yield _this3.parseIfNeeded();
+        yield _this3.collectDependencies();
+      }
+    })();
+  }
+
+  addDependency(name, opts) {
+    this.dependencies.set(name, Object.assign({ name }, opts));
+  }
+
+  addURLDependency(url, from = this.name, opts) {
+    if (!url || isURL(url)) {
+      return url;
+    }
+
+    if (typeof from === 'object') {
+      opts = from;
+      from = this.name;
+    }
+
+    const parsed = URL.parse(url);
+    const resolved = path.resolve(path.dirname(from), decodeURIComponent(parsed.pathname));
+    this.addDependency('./' + path.relative(path.dirname(this.name), resolved), Object.assign({ dynamic: true }, opts));
+
+    parsed.pathname = this.options.parser.getAsset(resolved, this.package, this.options).generateBundleName();
+
+    return URL.format(parsed);
+  }
+
+  getConfig(filenames, opts = {}) {
+    var _this4 = this;
+
+    return _asyncToGenerator(function* () {
+      // Resolve the config file
+      let conf = yield config.resolve(opts.path || _this4.name, filenames);
+      if (conf) {
+        // Add as a dependency so it is added to the watcher and invalidates
+        // this asset when the config changes.
+        _this4.addDependency(conf, { includedInParent: true });
+        if (opts.load === false) {
+          return conf;
+        }
+
+        return yield config.load(opts.path || _this4.name, filenames);
+      }
+
+      return null;
+    })();
+  }
+
+  mightHaveDependencies() {
+    return true;
+  }
+
+  load() {
+    var _this5 = this;
+
+    return _asyncToGenerator(function* () {
+      return yield fs.readFile(_this5.name, _this5.encoding);
+    })();
+  }
+
+  parse() {
+    // do nothing by default
+  }
+
+  collectDependencies() {
+    // do nothing by default
+  }
+
+  pretransform() {
+    // do nothing by default
+
+    return _asyncToGenerator(function* () {})();
+  }
+
+  transform() {
+    // do nothing by default
+
+    return _asyncToGenerator(function* () {})();
+  }
+
+  generate() {
+    var _this6 = this;
+
+    return _asyncToGenerator(function* () {
+      return {
+        [_this6.type]: _this6.contents
+      };
+    })();
+  }
+
+  process() {
+    var _this7 = this;
+
+    return _asyncToGenerator(function* () {
+      if (!_this7.generated) {
+        yield _this7.loadIfNeeded();
+        yield _this7.pretransform();
+        yield _this7.getDependencies();
+        yield _this7.transform();
+        _this7.generated = yield _this7.generate();
+        _this7.hash = yield _this7.generateHash();
+      }
+
+      return _this7.generated;
+    })();
+  }
+
+  postProcess(generated) {
+    return _asyncToGenerator(function* () {
+      return generated;
+    })();
+  }
+
+  generateHash() {
+    return objectHash(this.generated);
+  }
+
+  invalidate() {
+    this.processed = false;
+    this.contents = null;
+    this.ast = null;
+    this.generated = null;
+    this.hash = null;
+    this.dependencies.clear();
+    this.depAssets.clear();
+  }
+
+  invalidateBundle() {
+    this.parentBundle = null;
+    this.bundles.clear();
+    this.parentDeps.clear();
+  }
+
+  generateBundleName() {
+    // Generate a unique name. This will be replaced with a nicer
+    // name later as part of content hashing.
+    return md5(this.name) + '.' + this.type;
+  }
+
+  replaceBundleNames(bundleNameMap) {
+    for (let key in this.generated) {
+      let value = this.generated[key];
+      if (typeof value === 'string') {
+        // Replace temporary bundle names in the output with the final content-hashed names.
+        var _iteratorNormalCompletion = true;
+        var _didIteratorError = false;
+        var _iteratorError = undefined;
+
+        try {
+          for (var _iterator = bundleNameMap[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            let _ref = _step.value;
+
+            var _ref2 = _slicedToArray(_ref, 2);
+
+            let name = _ref2[0];
+            let map = _ref2[1];
+
+            value = value.split(name).join(map);
+          }
+        } catch (err) {
+          _didIteratorError = true;
+          _iteratorError = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return) {
+              _iterator.return();
+            }
+          } finally {
+            if (_didIteratorError) {
+              throw _iteratorError;
+            }
+          }
+        }
+
+        this.generated[key] = value;
+      }
+    }
+  }
+
+  generateErrorMessage(err) {
+    return err;
+  }
+}
+
+module.exports = Asset;

VISUALIZACION/node_modules/parcel-bundler/lib/Bundle.js

@@ -0,0 +1,416 @@
+'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 crypto = require('crypto');
+
+/**
+ * A Bundle represents an output file, containing multiple assets. Bundles can have
+ * child bundles, which are bundles that are loaded dynamically from this bundle.
+ * Child bundles are also produced when importing an asset of a different type from
+ * the bundle, e.g. importing a CSS file from JS.
+ */
+class Bundle {
+  constructor(type, name, parent) {
+    this.type = type;
+    this.name = name;
+    this.parentBundle = parent;
+    this.entryAsset = null;
+    this.assets = new Set();
+    this.childBundles = new Set();
+    this.siblingBundles = new Set();
+    this.siblingBundlesMap = new Map();
+    this.offsets = new Map();
+    this.totalSize = 0;
+    this.bundleTime = 0;
+  }
+
+  static createWithAsset(asset, parentBundle) {
+    let bundle = new Bundle(asset.type, Path.join(asset.options.outDir, asset.generateBundleName()), parentBundle);
+
+    bundle.entryAsset = asset;
+    bundle.addAsset(asset);
+    return bundle;
+  }
+
+  addAsset(asset) {
+    asset.bundles.add(this);
+    this.assets.add(asset);
+  }
+
+  removeAsset(asset) {
+    asset.bundles.delete(this);
+    this.assets.delete(asset);
+  }
+
+  addOffset(asset, line) {
+    this.offsets.set(asset, line);
+  }
+
+  getOffset(asset) {
+    return this.offsets.get(asset) || 0;
+  }
+
+  getSiblingBundle(type) {
+    if (!type || type === this.type) {
+      return this;
+    }
+
+    if (!this.siblingBundlesMap.has(type)) {
+      let bundle = new Bundle(type, Path.join(Path.dirname(this.name), Path.basename(this.name, Path.extname(this.name)) + '.' + type), this);
+
+      this.childBundles.add(bundle);
+      this.siblingBundles.add(bundle);
+      this.siblingBundlesMap.set(type, bundle);
+    }
+
+    return this.siblingBundlesMap.get(type);
+  }
+
+  createChildBundle(entryAsset) {
+    let bundle = Bundle.createWithAsset(entryAsset, this);
+    this.childBundles.add(bundle);
+    return bundle;
+  }
+
+  createSiblingBundle(entryAsset) {
+    let bundle = this.createChildBundle(entryAsset);
+    this.siblingBundles.add(bundle);
+    return bundle;
+  }
+
+  get isEmpty() {
+    return this.assets.size === 0;
+  }
+
+  getBundleNameMap(contentHash, hashes = new Map()) {
+    if (this.name) {
+      let hashedName = this.getHashedBundleName(contentHash);
+      hashes.set(Path.basename(this.name), hashedName);
+      this.name = Path.join(Path.dirname(this.name), hashedName);
+    }
+
+    var _iteratorNormalCompletion = true;
+    var _didIteratorError = false;
+    var _iteratorError = undefined;
+
+    try {
+      for (var _iterator = this.childBundles.values()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        let child = _step.value;
+
+        child.getBundleNameMap(contentHash, hashes);
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+
+    return hashes;
+  }
+
+  getHashedBundleName(contentHash) {
+    // If content hashing is enabled, generate a hash from all assets in the bundle.
+    // Otherwise, use a hash of the filename so it remains consistent across builds.
+    let ext = Path.extname(this.name);
+    let hash = (contentHash ? this.getHash() : Path.basename(this.name, ext)).slice(-8);
+    let entryAsset = this.entryAsset || this.parentBundle.entryAsset;
+    let name = Path.basename(entryAsset.name, Path.extname(entryAsset.name));
+    let isMainEntry = entryAsset.options.entryFiles[0] === entryAsset.name;
+    let isEntry = entryAsset.options.entryFiles.includes(entryAsset.name) || Array.from(entryAsset.parentDeps).some(dep => dep.entry);
+
+    // If this is the main entry file, use the output file option as the name if provided.
+    if (isMainEntry && entryAsset.options.outFile) {
+      let extname = Path.extname(entryAsset.options.outFile);
+      if (extname) {
+        ext = this.entryAsset ? extname : ext;
+        name = Path.basename(entryAsset.options.outFile, extname);
+      } else {
+        name = entryAsset.options.outFile;
+      }
+    }
+
+    // If this is an entry asset, don't hash. Return a relative path
+    // from the main file so we keep the original file paths.
+    if (isEntry) {
+      return Path.join(Path.relative(entryAsset.options.rootDir, Path.dirname(entryAsset.name)), name + ext);
+    }
+
+    // If this is an index file, use the parent directory name instead
+    // which is probably more descriptive.
+    if (name === 'index') {
+      name = Path.basename(Path.dirname(entryAsset.name));
+    }
+
+    // Add the content hash and extension.
+    return name + '.' + hash + ext;
+  }
+
+  package(bundler, oldHashes, newHashes = new Map()) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      let promises = [];
+      let mappings = [];
+
+      if (!_this.isEmpty) {
+        let hash = _this.getHash();
+        newHashes.set(_this.name, hash);
+
+        if (!oldHashes || oldHashes.get(_this.name) !== hash) {
+          promises.push(_this._package(bundler));
+        }
+      }
+
+      var _iteratorNormalCompletion2 = true;
+      var _didIteratorError2 = false;
+      var _iteratorError2 = undefined;
+
+      try {
+        for (var _iterator2 = _this.childBundles.values()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+          let bundle = _step2.value;
+
+          if (bundle.type === 'map') {
+            mappings.push(bundle);
+          } else {
+            promises.push(bundle.package(bundler, oldHashes, newHashes));
+          }
+        }
+      } catch (err) {
+        _didIteratorError2 = true;
+        _iteratorError2 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion2 && _iterator2.return) {
+            _iterator2.return();
+          }
+        } finally {
+          if (_didIteratorError2) {
+            throw _iteratorError2;
+          }
+        }
+      }
+
+      yield Promise.all(promises);
+      var _iteratorNormalCompletion3 = true;
+      var _didIteratorError3 = false;
+      var _iteratorError3 = undefined;
+
+      try {
+        for (var _iterator3 = mappings[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+          let bundle = _step3.value;
+
+          yield bundle.package(bundler, oldHashes, newHashes);
+        }
+      } catch (err) {
+        _didIteratorError3 = true;
+        _iteratorError3 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion3 && _iterator3.return) {
+            _iterator3.return();
+          }
+        } finally {
+          if (_didIteratorError3) {
+            throw _iteratorError3;
+          }
+        }
+      }
+
+      return newHashes;
+    })();
+  }
+
+  _package(bundler) {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      let Packager = bundler.packagers.get(_this2.type);
+      let packager = new Packager(_this2, bundler);
+
+      let startTime = Date.now();
+      yield packager.setup();
+      yield packager.start();
+
+      let included = new Set();
+      var _iteratorNormalCompletion4 = true;
+      var _didIteratorError4 = false;
+      var _iteratorError4 = undefined;
+
+      try {
+        for (var _iterator4 = _this2.assets[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+          let asset = _step4.value;
+
+          yield _this2._addDeps(asset, packager, included);
+        }
+      } catch (err) {
+        _didIteratorError4 = true;
+        _iteratorError4 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion4 && _iterator4.return) {
+            _iterator4.return();
+          }
+        } finally {
+          if (_didIteratorError4) {
+            throw _iteratorError4;
+          }
+        }
+      }
+
+      yield packager.end();
+
+      _this2.bundleTime = Date.now() - startTime;
+      var _iteratorNormalCompletion5 = true;
+      var _didIteratorError5 = false;
+      var _iteratorError5 = undefined;
+
+      try {
+        for (var _iterator5 = _this2.assets[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+          let asset = _step5.value;
+
+          _this2.bundleTime += asset.buildTime;
+        }
+      } catch (err) {
+        _didIteratorError5 = true;
+        _iteratorError5 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion5 && _iterator5.return) {
+            _iterator5.return();
+          }
+        } finally {
+          if (_didIteratorError5) {
+            throw _iteratorError5;
+          }
+        }
+      }
+    })();
+  }
+
+  _addDeps(asset, packager, included) {
+    var _this3 = this;
+
+    return _asyncToGenerator(function* () {
+      if (!_this3.assets.has(asset) || included.has(asset)) {
+        return;
+      }
+
+      included.add(asset);
+
+      var _iteratorNormalCompletion6 = true;
+      var _didIteratorError6 = false;
+      var _iteratorError6 = undefined;
+
+      try {
+        for (var _iterator6 = asset.depAssets.values()[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
+          let depAsset = _step6.value;
+
+          yield _this3._addDeps(depAsset, packager, included);
+        }
+      } catch (err) {
+        _didIteratorError6 = true;
+        _iteratorError6 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion6 && _iterator6.return) {
+            _iterator6.return();
+          }
+        } finally {
+          if (_didIteratorError6) {
+            throw _iteratorError6;
+          }
+        }
+      }
+
+      yield packager.addAsset(asset);
+
+      const assetSize = packager.getSize() - _this3.totalSize;
+      if (assetSize > 0) {
+        _this3.addAssetSize(asset, assetSize);
+      }
+    })();
+  }
+
+  addAssetSize(asset, size) {
+    asset.bundledSize = size;
+    this.totalSize += size;
+  }
+
+  getParents() {
+    let parents = [];
+    let bundle = this;
+
+    while (bundle) {
+      parents.push(bundle);
+      bundle = bundle.parentBundle;
+    }
+
+    return parents;
+  }
+
+  findCommonAncestor(bundle) {
+    // Get a list of parent bundles going up to the root
+    let ourParents = this.getParents();
+    let theirParents = bundle.getParents();
+
+    // Start from the root bundle, and find the first bundle that's different
+    let a = ourParents.pop();
+    let b = theirParents.pop();
+    let last;
+    while (a === b && ourParents.length > 0 && theirParents.length > 0) {
+      last = a;
+      a = ourParents.pop();
+      b = theirParents.pop();
+    }
+
+    if (a === b) {
+      // One bundle descended from the other
+      return a;
+    }
+
+    return last;
+  }
+
+  getHash() {
+    let hash = crypto.createHash('md5');
+    var _iteratorNormalCompletion7 = true;
+    var _didIteratorError7 = false;
+    var _iteratorError7 = undefined;
+
+    try {
+      for (var _iterator7 = this.assets[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
+        let asset = _step7.value;
+
+        hash.update(asset.hash);
+      }
+    } catch (err) {
+      _didIteratorError7 = true;
+      _iteratorError7 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion7 && _iterator7.return) {
+          _iterator7.return();
+        }
+      } finally {
+        if (_didIteratorError7) {
+          throw _iteratorError7;
+        }
+      }
+    }
+
+    return hash.digest('hex');
+  }
+}
+
+module.exports = Bundle;

VISUALIZACION/node_modules/parcel-bundler/lib/Bundler.js

@@ -0,0 +1,968 @@
+'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('./utils/fs');
+const Resolver = require('./Resolver');
+const Parser = require('./Parser');
+const WorkerFarm = require('./workerfarm/WorkerFarm');
+const Path = require('path');
+const Bundle = require('./Bundle');
+const Watcher = require('./Watcher');
+const FSCache = require('./FSCache');
+const HMRServer = require('./HMRServer');
+const Server = require('./Server');
+
+var _require = require('events');
+
+const EventEmitter = _require.EventEmitter;
+
+const logger = require('./Logger');
+const PackagerRegistry = require('./packagers');
+const localRequire = require('./utils/localRequire');
+const config = require('./utils/config');
+const emoji = require('./utils/emoji');
+const loadEnv = require('./utils/env');
+const PromiseQueue = require('./utils/PromiseQueue');
+const installPackage = require('./utils/installPackage');
+const bundleReport = require('./utils/bundleReport');
+const prettifyTime = require('./utils/prettifyTime');
+const getRootDir = require('./utils/getRootDir');
+const glob = require('glob');
+
+/**
+ * The Bundler is the main entry point. It resolves and loads assets,
+ * creates the bundle tree, and manages the worker farm, cache, and file watcher.
+ */
+class Bundler extends EventEmitter {
+  constructor(entryFiles, options = {}) {
+    super();
+
+    this.entryFiles = this.normalizeEntries(entryFiles);
+    this.options = this.normalizeOptions(options);
+
+    this.resolver = new Resolver(this.options);
+    this.parser = new Parser(this.options);
+    this.packagers = new PackagerRegistry();
+    this.cache = this.options.cache ? new FSCache(this.options) : null;
+    this.delegate = options.delegate || {};
+    this.bundleLoaders = {};
+
+    this.addBundleLoader('wasm', {
+      browser: require.resolve('./builtins/loaders/browser/wasm-loader'),
+      node: require.resolve('./builtins/loaders/node/wasm-loader')
+    });
+    this.addBundleLoader('css', {
+      browser: require.resolve('./builtins/loaders/browser/css-loader'),
+      node: require.resolve('./builtins/loaders/node/css-loader')
+    });
+    this.addBundleLoader('js', {
+      browser: require.resolve('./builtins/loaders/browser/js-loader'),
+      node: require.resolve('./builtins/loaders/node/js-loader')
+    });
+
+    this.pending = false;
+    this.loadedAssets = new Map();
+    this.watchedAssets = new Map();
+    this.farm = null;
+    this.watcher = null;
+    this.hmr = null;
+    this.bundleHashes = null;
+    this.errored = false;
+    this.buildQueue = new PromiseQueue(this.processAsset.bind(this));
+    this.rebuildTimeout = null;
+
+    logger.setOptions(this.options);
+  }
+
+  normalizeEntries(entryFiles) {
+    // Support passing a single file
+    if (entryFiles && !Array.isArray(entryFiles)) {
+      entryFiles = [entryFiles];
+    }
+
+    // If no entry files provided, resolve the entry point from the current directory.
+    if (!entryFiles || entryFiles.length === 0) {
+      entryFiles = [process.cwd()];
+    }
+
+    // Match files as globs
+    return entryFiles.reduce((p, m) => p.concat(glob.sync(m, { nonull: true })), []).map(f => Path.resolve(f));
+  }
+
+  normalizeOptions(options) {
+    const isProduction = options.production || process.env.NODE_ENV === 'production';
+    const publicURL = options.publicUrl || options.publicURL || '/';
+    const watch = typeof options.watch === 'boolean' ? options.watch : !isProduction;
+    const target = options.target || 'browser';
+    return {
+      production: isProduction,
+      outDir: Path.resolve(options.outDir || 'dist'),
+      outFile: options.outFile || '',
+      publicURL: publicURL,
+      watch: watch,
+      cache: typeof options.cache === 'boolean' ? options.cache : true,
+      cacheDir: Path.resolve(options.cacheDir || '.cache'),
+      killWorkers: typeof options.killWorkers === 'boolean' ? options.killWorkers : true,
+      minify: typeof options.minify === 'boolean' ? options.minify : isProduction,
+      target: target,
+      hmr: target === 'node' ? false : typeof options.hmr === 'boolean' ? options.hmr : watch,
+      https: options.https || false,
+      logLevel: isNaN(options.logLevel) ? 3 : options.logLevel,
+      entryFiles: this.entryFiles,
+      hmrPort: options.hmrPort || 0,
+      rootDir: getRootDir(this.entryFiles),
+      sourceMaps: typeof options.sourceMaps === 'boolean' ? options.sourceMaps : true,
+      hmrHostname: options.hmrHostname || (options.target === 'electron' ? 'localhost' : ''),
+      detailedReport: options.detailedReport || false,
+      global: options.global,
+      autoinstall: typeof options.autoinstall === 'boolean' ? options.autoinstall : !isProduction,
+      contentHash: typeof options.contentHash === 'boolean' ? options.contentHash : isProduction
+    };
+  }
+
+  addAssetType(extension, path) {
+    if (typeof path !== 'string') {
+      throw new Error('Asset type should be a module path.');
+    }
+
+    if (this.farm) {
+      throw new Error('Asset types must be added before bundling.');
+    }
+
+    this.parser.registerExtension(extension, path);
+  }
+
+  addPackager(type, packager) {
+    if (this.farm) {
+      throw new Error('Packagers must be added before bundling.');
+    }
+
+    this.packagers.add(type, packager);
+  }
+
+  addBundleLoader(type, paths) {
+    if (typeof paths === 'string') {
+      paths = { node: paths, browser: paths };
+    } else if (typeof paths !== 'object') {
+      throw new Error('Bundle loaders should be an object.');
+    }
+
+    for (const target in paths) {
+      if (target !== 'node' && target !== 'browser') {
+        throw new Error(`Unknown bundle loader target "${target}".`);
+      }
+
+      if (typeof paths[target] !== 'string') {
+        throw new Error('Bundle loader should be a string.');
+      }
+    }
+
+    if (this.farm) {
+      throw new Error('Bundle loaders must be added before bundling.');
+    }
+
+    this.bundleLoaders[type] = paths;
+  }
+
+  loadPlugins() {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      let relative = Path.join(_this.options.rootDir, 'index');
+      let pkg = yield config.load(relative, ['package.json']);
+      if (!pkg) {
+        return;
+      }
+
+      try {
+        let deps = Object.assign({}, pkg.dependencies, pkg.devDependencies);
+        for (let dep in deps) {
+          const pattern = /^(@.*\/)?parcel-plugin-.+/;
+          if (pattern.test(dep)) {
+            let plugin = yield localRequire(dep, relative);
+            yield plugin(_this);
+          }
+        }
+      } catch (err) {
+        logger.warn(err);
+      }
+    })();
+  }
+
+  bundle() {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      // If another bundle is already pending, wait for that one to finish and retry.
+      if (_this2.pending) {
+        return new Promise(function (resolve, reject) {
+          _this2.once('buildEnd', function () {
+            _this2.bundle().then(resolve, reject);
+          });
+        });
+      }
+
+      let isInitialBundle = !_this2.entryAssets;
+      let startTime = Date.now();
+      _this2.pending = true;
+      _this2.errored = false;
+
+      logger.clear();
+      logger.status(emoji.progress, 'Building...');
+
+      try {
+        // Start worker farm, watcher, etc. if needed
+        yield _this2.start();
+
+        // If this is the initial bundle, ensure the output directory exists, and resolve the main asset.
+        if (isInitialBundle) {
+          yield fs.mkdirp(_this2.options.outDir);
+
+          _this2.entryAssets = new Set();
+          var _iteratorNormalCompletion = true;
+          var _didIteratorError = false;
+          var _iteratorError = undefined;
+
+          try {
+            for (var _iterator = _this2.entryFiles[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+              let entry = _step.value;
+
+              let asset = yield _this2.resolveAsset(entry);
+              _this2.buildQueue.add(asset);
+              _this2.entryAssets.add(asset);
+            }
+          } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion && _iterator.return) {
+                _iterator.return();
+              }
+            } finally {
+              if (_didIteratorError) {
+                throw _iteratorError;
+              }
+            }
+          }
+        }
+
+        // Build the queued assets.
+        let loadedAssets = yield _this2.buildQueue.run();
+
+        // The changed assets are any that don't have a parent bundle yet
+        // plus the ones that were in the build queue.
+        let changedAssets = [..._this2.findOrphanAssets(), ...loadedAssets];
+
+        // Invalidate bundles
+        var _iteratorNormalCompletion2 = true;
+        var _didIteratorError2 = false;
+        var _iteratorError2 = undefined;
+
+        try {
+          for (var _iterator2 = _this2.loadedAssets.values()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+            let asset = _step2.value;
+
+            asset.invalidateBundle();
+          }
+
+          // Create a root bundle to hold all of the entry assets, and add them to the tree.
+        } catch (err) {
+          _didIteratorError2 = true;
+          _iteratorError2 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion2 && _iterator2.return) {
+              _iterator2.return();
+            }
+          } finally {
+            if (_didIteratorError2) {
+              throw _iteratorError2;
+            }
+          }
+        }
+
+        _this2.mainBundle = new Bundle();
+        var _iteratorNormalCompletion3 = true;
+        var _didIteratorError3 = false;
+        var _iteratorError3 = undefined;
+
+        try {
+          for (var _iterator3 = _this2.entryAssets[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+            let asset = _step3.value;
+
+            _this2.createBundleTree(asset, _this2.mainBundle);
+          }
+
+          // If there is only one child bundle, replace the root with that bundle.
+        } catch (err) {
+          _didIteratorError3 = true;
+          _iteratorError3 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion3 && _iterator3.return) {
+              _iterator3.return();
+            }
+          } finally {
+            if (_didIteratorError3) {
+              throw _iteratorError3;
+            }
+          }
+        }
+
+        if (_this2.mainBundle.childBundles.size === 1) {
+          _this2.mainBundle = Array.from(_this2.mainBundle.childBundles)[0];
+        }
+
+        // Generate the final bundle names, and replace references in the built assets.
+        _this2.bundleNameMap = _this2.mainBundle.getBundleNameMap(_this2.options.contentHash);
+
+        var _iteratorNormalCompletion4 = true;
+        var _didIteratorError4 = false;
+        var _iteratorError4 = undefined;
+
+        try {
+          for (var _iterator4 = changedAssets[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+            let asset = _step4.value;
+
+            asset.replaceBundleNames(_this2.bundleNameMap);
+          }
+
+          // Emit an HMR update if this is not the initial bundle.
+        } catch (err) {
+          _didIteratorError4 = true;
+          _iteratorError4 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion4 && _iterator4.return) {
+              _iterator4.return();
+            }
+          } finally {
+            if (_didIteratorError4) {
+              throw _iteratorError4;
+            }
+          }
+        }
+
+        if (_this2.hmr && !isInitialBundle) {
+          _this2.hmr.emitUpdate(changedAssets);
+        }
+
+        // Package everything up
+        _this2.bundleHashes = yield _this2.mainBundle.package(_this2, _this2.bundleHashes);
+
+        // Unload any orphaned assets
+        _this2.unloadOrphanedAssets();
+
+        let buildTime = Date.now() - startTime;
+        let time = prettifyTime(buildTime);
+        logger.status(emoji.success, `Built in ${time}.`, 'green');
+        if (!_this2.watcher) {
+          bundleReport(_this2.mainBundle, _this2.options.detailedReport);
+        }
+
+        _this2.emit('bundled', _this2.mainBundle);
+        return _this2.mainBundle;
+      } catch (err) {
+        _this2.errored = true;
+        logger.error(err);
+        if (_this2.hmr) {
+          _this2.hmr.emitError(err);
+        }
+
+        if (process.env.NODE_ENV === 'production') {
+          process.exitCode = 1;
+        } else if (process.env.NODE_ENV === 'test' && !_this2.hmr) {
+          throw err;
+        }
+      } finally {
+        _this2.pending = false;
+        _this2.emit('buildEnd');
+
+        // If not in watch mode, stop the worker farm so we don't keep the process running.
+        if (!_this2.watcher && _this2.options.killWorkers) {
+          _this2.stop();
+        }
+      }
+    })();
+  }
+
+  start() {
+    var _this3 = this;
+
+    return _asyncToGenerator(function* () {
+      if (_this3.farm) {
+        return;
+      }
+
+      yield _this3.loadPlugins();
+      yield loadEnv(Path.join(_this3.options.rootDir, 'index'));
+
+      _this3.options.extensions = Object.assign({}, _this3.parser.extensions);
+      _this3.options.bundleLoaders = _this3.bundleLoaders;
+      _this3.options.env = process.env;
+
+      if (_this3.options.watch) {
+        _this3.watcher = new Watcher();
+        _this3.watcher.on('change', _this3.onChange.bind(_this3));
+      }
+
+      if (_this3.options.hmr) {
+        _this3.hmr = new HMRServer();
+        _this3.options.hmrPort = yield _this3.hmr.start(_this3.options);
+      }
+
+      _this3.farm = WorkerFarm.getShared(_this3.options);
+    })();
+  }
+
+  stop() {
+    if (this.farm) {
+      this.farm.end();
+    }
+
+    if (this.watcher) {
+      this.watcher.stop();
+    }
+
+    if (this.hmr) {
+      this.hmr.stop();
+    }
+  }
+
+  getAsset(name, parent) {
+    var _this4 = this;
+
+    return _asyncToGenerator(function* () {
+      let asset = yield _this4.resolveAsset(name, parent);
+      _this4.buildQueue.add(asset);
+      yield _this4.buildQueue.run();
+      return asset;
+    })();
+  }
+
+  resolveAsset(name, parent) {
+    var _this5 = this;
+
+    return _asyncToGenerator(function* () {
+      var _ref = yield _this5.resolver.resolve(name, parent);
+
+      let path = _ref.path,
+          pkg = _ref.pkg;
+
+      if (_this5.loadedAssets.has(path)) {
+        return _this5.loadedAssets.get(path);
+      }
+
+      let asset = _this5.parser.getAsset(path, pkg, _this5.options);
+      _this5.loadedAssets.set(path, asset);
+
+      _this5.watch(path, asset);
+      return asset;
+    })();
+  }
+
+  watch(path, asset) {
+    if (!this.watcher) {
+      return;
+    }
+
+    if (!this.watchedAssets.has(path)) {
+      this.watcher.watch(path);
+      this.watchedAssets.set(path, new Set());
+    }
+
+    this.watchedAssets.get(path).add(asset);
+  }
+
+  unwatch(path, asset) {
+    if (!this.watchedAssets.has(path)) {
+      return;
+    }
+
+    let watched = this.watchedAssets.get(path);
+    watched.delete(asset);
+
+    if (watched.size === 0) {
+      this.watchedAssets.delete(path);
+      this.watcher.unwatch(path);
+    }
+  }
+
+  resolveDep(asset, dep, install = true) {
+    var _this6 = this;
+
+    return _asyncToGenerator(function* () {
+      try {
+        return yield _this6.resolveAsset(dep.name, asset.name);
+      } catch (err) {
+        // If the dep is optional, return before we throw
+        if (dep.optional) {
+          return;
+        }
+
+        if (err.code === 'MODULE_NOT_FOUND') {
+          let isLocalFile = /^[/~.]/.test(dep.name);
+          let fromNodeModules = asset.name.includes(`${Path.sep}node_modules${Path.sep}`);
+
+          if (!isLocalFile && !fromNodeModules && _this6.options.autoinstall && install) {
+            return yield _this6.installDep(asset, dep);
+          }
+
+          err.message = `Cannot resolve dependency '${dep.name}'`;
+          if (isLocalFile) {
+            const absPath = Path.resolve(Path.dirname(asset.name), dep.name);
+            err.message += ` at '${absPath}'`;
+          }
+
+          yield _this6.throwDepError(asset, dep, err);
+        }
+
+        throw err;
+      }
+    })();
+  }
+
+  installDep(asset, dep) {
+    var _this7 = this;
+
+    return _asyncToGenerator(function* () {
+      // Check if module exists, prevents useless installs
+      let resolved = yield _this7.resolver.resolveModule(dep.name, asset.name);
+
+      // If the module resolved (i.e. wasn't a local file), but the module directory wasn't found, install it.
+      if (resolved.moduleName && !resolved.moduleDir) {
+        try {
+          yield installPackage([resolved.moduleName], asset.name, {
+            saveDev: false
+          });
+        } catch (err) {
+          yield _this7.throwDepError(asset, dep, err);
+        }
+      }
+
+      return yield _this7.resolveDep(asset, dep, false);
+    })();
+  }
+
+  throwDepError(asset, dep, err) {
+    return _asyncToGenerator(function* () {
+      // Generate a code frame where the dependency was used
+      if (dep.loc) {
+        yield asset.loadIfNeeded();
+        err.loc = dep.loc;
+        err = asset.generateErrorMessage(err);
+      }
+
+      err.fileName = asset.name;
+      throw err;
+    })();
+  }
+
+  processAsset(asset, isRebuild) {
+    var _this8 = this;
+
+    return _asyncToGenerator(function* () {
+      if (isRebuild) {
+        asset.invalidate();
+        if (_this8.cache) {
+          _this8.cache.invalidate(asset.name);
+        }
+      }
+
+      yield _this8.loadAsset(asset);
+    })();
+  }
+
+  loadAsset(asset) {
+    var _this9 = this;
+
+    return _asyncToGenerator(function* () {
+      if (asset.processed) {
+        return;
+      }
+
+      if (!_this9.errored) {
+        logger.status(emoji.progress, `Building ${asset.basename}...`);
+      }
+
+      // Mark the asset processed so we don't load it twice
+      asset.processed = true;
+
+      // First try the cache, otherwise load and compile in the background
+      let startTime = Date.now();
+      let processed = _this9.cache && (yield _this9.cache.read(asset.name));
+      if (!processed || asset.shouldInvalidate(processed.cacheData)) {
+        processed = yield _this9.farm.run(asset.name, asset.package, _this9.options);
+        if (_this9.cache) {
+          _this9.cache.write(asset.name, processed);
+        }
+      }
+
+      asset.buildTime = Date.now() - startTime;
+      asset.generated = processed.generated;
+      asset.hash = processed.hash;
+
+      // Call the delegate to get implicit dependencies
+      let dependencies = processed.dependencies;
+      if (_this9.delegate.getImplicitDependencies) {
+        let implicitDeps = yield _this9.delegate.getImplicitDependencies(asset);
+        if (implicitDeps) {
+          dependencies = dependencies.concat(implicitDeps);
+        }
+      }
+
+      // Resolve and load asset dependencies
+      let assetDeps = yield Promise.all(dependencies.map((() => {
+        var _ref2 = _asyncToGenerator(function* (dep) {
+          if (dep.includedInParent) {
+            // This dependency is already included in the parent's generated output,
+            // so no need to load it. We map the name back to the parent asset so
+            // that changing it triggers a recompile of the parent.
+            _this9.watch(dep.name, asset);
+          } else {
+            let assetDep = yield _this9.resolveDep(asset, dep);
+            if (assetDep) {
+              yield _this9.loadAsset(assetDep);
+            }
+
+            return assetDep;
+          }
+        });
+
+        return function (_x) {
+          return _ref2.apply(this, arguments);
+        };
+      })()));
+
+      // Store resolved assets in their original order
+      dependencies.forEach(function (dep, i) {
+        asset.dependencies.set(dep.name, dep);
+        let assetDep = assetDeps[i];
+        if (assetDep) {
+          asset.depAssets.set(dep, assetDep);
+        }
+      });
+    })();
+  }
+
+  createBundleTree(asset, bundle, dep, parentBundles = new Set()) {
+    if (dep) {
+      asset.parentDeps.add(dep);
+    }
+
+    if (asset.parentBundle) {
+      // If the asset is already in a bundle, it is shared. Move it to the lowest common ancestor.
+      if (asset.parentBundle !== bundle) {
+        let commonBundle = bundle.findCommonAncestor(asset.parentBundle);
+        if (asset.parentBundle !== commonBundle && asset.parentBundle.type === commonBundle.type) {
+          this.moveAssetToBundle(asset, commonBundle);
+          return;
+        }
+      } else {
+        return;
+      }
+
+      // Detect circular bundles
+      if (parentBundles.has(asset.parentBundle)) {
+        return;
+      }
+    }
+
+    let isEntryAsset = asset.parentBundle && asset.parentBundle.entryAsset === asset;
+
+    if (dep && dep.dynamic || !bundle.type) {
+      // If the asset is already the entry asset of a bundle, don't create a duplicate.
+      if (isEntryAsset) {
+        return;
+      }
+
+      // Create a new bundle for dynamic imports
+      bundle = bundle.createChildBundle(asset);
+    } else if (asset.type && !this.packagers.has(asset.type)) {
+      // If the asset is already the entry asset of a bundle, don't create a duplicate.
+      if (isEntryAsset) {
+        return;
+      }
+
+      // No packager is available for this asset type. Create a new bundle with only this asset.
+      bundle.createSiblingBundle(asset);
+    } else {
+      // Add the asset to the common bundle of the asset's type
+      bundle.getSiblingBundle(asset.type).addAsset(asset);
+    }
+
+    // If the asset generated a representation for the parent bundle type, also add it there
+    if (asset.generated[bundle.type] != null) {
+      bundle.addAsset(asset);
+    }
+
+    // Add the asset to sibling bundles for each generated type
+    if (asset.type && asset.generated[asset.type]) {
+      for (let t in asset.generated) {
+        if (asset.generated[t]) {
+          bundle.getSiblingBundle(t).addAsset(asset);
+        }
+      }
+    }
+
+    asset.parentBundle = bundle;
+    parentBundles.add(bundle);
+
+    var _iteratorNormalCompletion5 = true;
+    var _didIteratorError5 = false;
+    var _iteratorError5 = undefined;
+
+    try {
+      for (var _iterator5 = asset.depAssets[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+        let _ref3 = _step5.value;
+
+        var _ref4 = _slicedToArray(_ref3, 2);
+
+        let dep = _ref4[0];
+        let assetDep = _ref4[1];
+
+        this.createBundleTree(assetDep, bundle, dep, parentBundles);
+      }
+    } catch (err) {
+      _didIteratorError5 = true;
+      _iteratorError5 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion5 && _iterator5.return) {
+          _iterator5.return();
+        }
+      } finally {
+        if (_didIteratorError5) {
+          throw _iteratorError5;
+        }
+      }
+    }
+
+    parentBundles.delete(bundle);
+    return bundle;
+  }
+
+  moveAssetToBundle(asset, commonBundle) {
+    // Never move the entry asset of a bundle, as it was explicitly requested to be placed in a separate bundle.
+    if (asset.parentBundle.entryAsset === asset) {
+      return;
+    }
+
+    var _iteratorNormalCompletion6 = true;
+    var _didIteratorError6 = false;
+    var _iteratorError6 = undefined;
+
+    try {
+      for (var _iterator6 = Array.from(asset.bundles)[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
+        let bundle = _step6.value;
+
+        bundle.removeAsset(asset);
+        commonBundle.getSiblingBundle(bundle.type).addAsset(asset);
+      }
+    } catch (err) {
+      _didIteratorError6 = true;
+      _iteratorError6 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion6 && _iterator6.return) {
+          _iterator6.return();
+        }
+      } finally {
+        if (_didIteratorError6) {
+          throw _iteratorError6;
+        }
+      }
+    }
+
+    let oldBundle = asset.parentBundle;
+    asset.parentBundle = commonBundle;
+
+    // Move all dependencies as well
+    var _iteratorNormalCompletion7 = true;
+    var _didIteratorError7 = false;
+    var _iteratorError7 = undefined;
+
+    try {
+      for (var _iterator7 = asset.depAssets.values()[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
+        let child = _step7.value;
+
+        if (child.parentBundle === oldBundle) {
+          this.moveAssetToBundle(child, commonBundle);
+        }
+      }
+    } catch (err) {
+      _didIteratorError7 = true;
+      _iteratorError7 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion7 && _iterator7.return) {
+          _iterator7.return();
+        }
+      } finally {
+        if (_didIteratorError7) {
+          throw _iteratorError7;
+        }
+      }
+    }
+  }
+
+  *findOrphanAssets() {
+    var _iteratorNormalCompletion8 = true;
+    var _didIteratorError8 = false;
+    var _iteratorError8 = undefined;
+
+    try {
+      for (var _iterator8 = this.loadedAssets.values()[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
+        let asset = _step8.value;
+
+        if (!asset.parentBundle) {
+          yield asset;
+        }
+      }
+    } catch (err) {
+      _didIteratorError8 = true;
+      _iteratorError8 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion8 && _iterator8.return) {
+          _iterator8.return();
+        }
+      } finally {
+        if (_didIteratorError8) {
+          throw _iteratorError8;
+        }
+      }
+    }
+  }
+
+  unloadOrphanedAssets() {
+    var _iteratorNormalCompletion9 = true;
+    var _didIteratorError9 = false;
+    var _iteratorError9 = undefined;
+
+    try {
+      for (var _iterator9 = this.findOrphanAssets()[Symbol.iterator](), _step9; !(_iteratorNormalCompletion9 = (_step9 = _iterator9.next()).done); _iteratorNormalCompletion9 = true) {
+        let asset = _step9.value;
+
+        this.unloadAsset(asset);
+      }
+    } catch (err) {
+      _didIteratorError9 = true;
+      _iteratorError9 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion9 && _iterator9.return) {
+          _iterator9.return();
+        }
+      } finally {
+        if (_didIteratorError9) {
+          throw _iteratorError9;
+        }
+      }
+    }
+  }
+
+  unloadAsset(asset) {
+    this.loadedAssets.delete(asset.name);
+    if (this.watcher) {
+      this.unwatch(asset.name, asset);
+
+      // Unwatch all included dependencies that map to this asset
+      var _iteratorNormalCompletion10 = true;
+      var _didIteratorError10 = false;
+      var _iteratorError10 = undefined;
+
+      try {
+        for (var _iterator10 = asset.dependencies.values()[Symbol.iterator](), _step10; !(_iteratorNormalCompletion10 = (_step10 = _iterator10.next()).done); _iteratorNormalCompletion10 = true) {
+          let dep = _step10.value;
+
+          if (dep.includedInParent) {
+            this.unwatch(dep.name, asset);
+          }
+        }
+      } catch (err) {
+        _didIteratorError10 = true;
+        _iteratorError10 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion10 && _iterator10.return) {
+            _iterator10.return();
+          }
+        } finally {
+          if (_didIteratorError10) {
+            throw _iteratorError10;
+          }
+        }
+      }
+    }
+  }
+
+  onChange(path) {
+    var _this10 = this;
+
+    return _asyncToGenerator(function* () {
+      let assets = _this10.watchedAssets.get(path);
+      if (!assets || !assets.size) {
+        return;
+      }
+
+      logger.clear();
+      logger.status(emoji.progress, `Building ${Path.basename(path)}...`);
+
+      // Add the asset to the rebuild queue, and reset the timeout.
+      var _iteratorNormalCompletion11 = true;
+      var _didIteratorError11 = false;
+      var _iteratorError11 = undefined;
+
+      try {
+        for (var _iterator11 = assets[Symbol.iterator](), _step11; !(_iteratorNormalCompletion11 = (_step11 = _iterator11.next()).done); _iteratorNormalCompletion11 = true) {
+          let asset = _step11.value;
+
+          _this10.buildQueue.add(asset, true);
+        }
+      } catch (err) {
+        _didIteratorError11 = true;
+        _iteratorError11 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion11 && _iterator11.return) {
+            _iterator11.return();
+          }
+        } finally {
+          if (_didIteratorError11) {
+            throw _iteratorError11;
+          }
+        }
+      }
+
+      clearTimeout(_this10.rebuildTimeout);
+
+      _this10.rebuildTimeout = setTimeout(_asyncToGenerator(function* () {
+        yield _this10.bundle();
+      }), 100);
+    })();
+  }
+
+  middleware() {
+    this.bundle();
+    return Server.middleware(this);
+  }
+
+  serve(port = 1234, https = false) {
+    var _this11 = this;
+
+    return _asyncToGenerator(function* () {
+      _this11.server = yield Server.serve(_this11, port, https);
+      _this11.bundle();
+      return _this11.server;
+    })();
+  }
+}
+
+module.exports = Bundler;
+Bundler.Asset = require('./Asset');
+Bundler.Packager = require('./packagers/Packager');

VISUALIZACION/node_modules/parcel-bundler/lib/FSCache.js

@@ -0,0 +1,174 @@
+'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('./utils/fs');
+const path = require('path');
+const md5 = require('./utils/md5');
+const objectHash = require('./utils/objectHash');
+const pkg = require('../package.json');
+const logger = require('./Logger');
+
+// These keys can affect the output, so if they differ, the cache should not match
+const OPTION_KEYS = ['publicURL', 'minify', 'hmr', 'target'];
+
+class FSCache {
+  constructor(options) {
+    this.dir = path.resolve(options.cacheDir || '.cache');
+    this.dirExists = false;
+    this.invalidated = new Set();
+    this.optionsHash = objectHash(OPTION_KEYS.reduce((p, k) => (p[k] = options[k], p), {
+      version: pkg.version
+    }));
+  }
+
+  ensureDirExists() {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      yield fs.mkdirp(_this.dir);
+      _this.dirExists = true;
+    })();
+  }
+
+  getCacheFile(filename) {
+    let hash = md5(this.optionsHash + filename);
+    return path.join(this.dir, hash + '.json');
+  }
+
+  writeDepMtimes(data) {
+    return _asyncToGenerator(function* () {
+      // Write mtimes for each dependent file that is already compiled into this asset
+      var _iteratorNormalCompletion = true;
+      var _didIteratorError = false;
+      var _iteratorError = undefined;
+
+      try {
+        for (var _iterator = data.dependencies[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          let dep = _step.value;
+
+          if (dep.includedInParent) {
+            let stats = yield fs.stat(dep.name);
+            dep.mtime = stats.mtime.getTime();
+          }
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+    })();
+  }
+
+  write(filename, data) {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      try {
+        yield _this2.ensureDirExists();
+        yield _this2.writeDepMtimes(data);
+        yield fs.writeFile(_this2.getCacheFile(filename), JSON.stringify(data));
+        _this2.invalidated.delete(filename);
+      } catch (err) {
+        logger.error('Error writing to cache', err);
+      }
+    })();
+  }
+
+  checkDepMtimes(data) {
+    return _asyncToGenerator(function* () {
+      // Check mtimes for files that are already compiled into this asset
+      // If any of them changed, invalidate.
+      var _iteratorNormalCompletion2 = true;
+      var _didIteratorError2 = false;
+      var _iteratorError2 = undefined;
+
+      try {
+        for (var _iterator2 = data.dependencies[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+          let dep = _step2.value;
+
+          if (dep.includedInParent) {
+            let stats = yield fs.stat(dep.name);
+            if (stats.mtime > dep.mtime) {
+              return false;
+            }
+          }
+        }
+      } catch (err) {
+        _didIteratorError2 = true;
+        _iteratorError2 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion2 && _iterator2.return) {
+            _iterator2.return();
+          }
+        } finally {
+          if (_didIteratorError2) {
+            throw _iteratorError2;
+          }
+        }
+      }
+
+      return true;
+    })();
+  }
+
+  read(filename) {
+    var _this3 = this;
+
+    return _asyncToGenerator(function* () {
+      if (_this3.invalidated.has(filename)) {
+        return null;
+      }
+
+      let cacheFile = _this3.getCacheFile(filename);
+
+      try {
+        let stats = yield fs.stat(filename);
+        let cacheStats = yield fs.stat(cacheFile);
+
+        if (stats.mtime > cacheStats.mtime) {
+          return null;
+        }
+
+        let json = yield fs.readFile(cacheFile);
+        let data = JSON.parse(json);
+        if (!(yield _this3.checkDepMtimes(data))) {
+          return null;
+        }
+
+        return data;
+      } catch (err) {
+        return null;
+      }
+    })();
+  }
+
+  invalidate(filename) {
+    this.invalidated.add(filename);
+  }
+
+  delete(filename) {
+    var _this4 = this;
+
+    return _asyncToGenerator(function* () {
+      try {
+        yield fs.unlink(_this4.getCacheFile(filename));
+        _this4.invalidated.delete(filename);
+      } catch (err) {
+        // Fail silently
+      }
+    })();
+  }
+}
+
+module.exports = FSCache;

VISUALIZACION/node_modules/parcel-bundler/lib/HMRServer.js

@@ -0,0 +1,172 @@
+'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 http = require('http');
+const https = require('https');
+const WebSocket = require('ws');
+const prettyError = require('./utils/prettyError');
+const generateCertificate = require('./utils/generateCertificate');
+const getCertificate = require('./utils/getCertificate');
+const logger = require('./Logger');
+
+class HMRServer {
+  start(options = {}) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      yield new Promise((() => {
+        var _ref = _asyncToGenerator(function* (resolve) {
+          if (!options.https) {
+            _this.server = http.createServer();
+          } else if (typeof options.https === 'boolean') {
+            _this.server = https.createServer(generateCertificate(options));
+          } else {
+            _this.server = https.createServer((yield getCertificate(options.https)));
+          }
+
+          _this.wss = new WebSocket.Server({ server: _this.server });
+          _this.server.listen(options.hmrPort, resolve);
+        });
+
+        return function (_x) {
+          return _ref.apply(this, arguments);
+        };
+      })());
+
+      _this.wss.on('connection', function (ws) {
+        ws.onerror = _this.handleSocketError;
+        if (_this.unresolvedError) {
+          ws.send(JSON.stringify(_this.unresolvedError));
+        }
+      });
+
+      _this.wss.on('error', _this.handleSocketError);
+
+      return _this.wss._server.address().port;
+    })();
+  }
+
+  stop() {
+    this.wss.close();
+    this.server.close();
+  }
+
+  emitError(err) {
+    var _prettyError = prettyError(err);
+
+    let message = _prettyError.message,
+        stack = _prettyError.stack;
+
+    // store the most recent error so we can notify new connections
+    // and so we can broadcast when the error is resolved
+
+    this.unresolvedError = {
+      type: 'error',
+      error: {
+        message,
+        stack
+      }
+    };
+
+    this.broadcast(this.unresolvedError);
+  }
+
+  emitUpdate(assets) {
+    if (this.unresolvedError) {
+      this.unresolvedError = null;
+      this.broadcast({
+        type: 'error-resolved'
+      });
+    }
+
+    const containsHtmlAsset = assets.some(asset => asset.type === 'html');
+    if (containsHtmlAsset) {
+      this.broadcast({
+        type: 'reload'
+      });
+    } else {
+      this.broadcast({
+        type: 'update',
+        assets: assets.map(asset => {
+          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 _ref2 = _step.value;
+
+              var _ref3 = _slicedToArray(_ref2, 2);
+
+              let dep = _ref3[0];
+              let depAsset = _ref3[1];
+
+              deps[dep.name] = depAsset.id;
+            }
+          } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion && _iterator.return) {
+                _iterator.return();
+              }
+            } finally {
+              if (_didIteratorError) {
+                throw _iteratorError;
+              }
+            }
+          }
+
+          return {
+            id: asset.id,
+            generated: asset.generated,
+            deps: deps
+          };
+        })
+      });
+    }
+  }
+
+  handleSocketError(err) {
+    if (err.error.code === 'ECONNRESET') {
+      // This gets triggered on page refresh, ignore this
+      return;
+    }
+    logger.warn(err);
+  }
+
+  broadcast(msg) {
+    const json = JSON.stringify(msg);
+    var _iteratorNormalCompletion2 = true;
+    var _didIteratorError2 = false;
+    var _iteratorError2 = undefined;
+
+    try {
+      for (var _iterator2 = this.wss.clients[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+        let ws = _step2.value;
+
+        ws.send(json);
+      }
+    } catch (err) {
+      _didIteratorError2 = true;
+      _iteratorError2 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion2 && _iterator2.return) {
+          _iterator2.return();
+        }
+      } finally {
+        if (_didIteratorError2) {
+          throw _iteratorError2;
+        }
+      }
+    }
+  }
+}
+
+module.exports = HMRServer;

VISUALIZACION/node_modules/parcel-bundler/lib/Logger.js

@@ -0,0 +1,300 @@
+'use strict';
+
+const chalk = require('chalk');
+const readline = require('readline');
+const prettyError = require('./utils/prettyError');
+const emoji = require('./utils/emoji');
+
+var _require = require('grapheme-breaker');
+
+const countBreaks = _require.countBreaks;
+
+const stripAnsi = require('strip-ansi');
+
+class Logger {
+  constructor(options) {
+    this.lines = 0;
+    this.statusLine = null;
+    this.setOptions(options);
+  }
+
+  setOptions(options) {
+    this.logLevel = options && isNaN(options.logLevel) === false ? Number(options.logLevel) : 3;
+    this.color = options && typeof options.color === 'boolean' ? options.color : chalk.supportsColor;
+    this.chalk = new chalk.constructor({ enabled: this.color });
+    this.isTest = options && typeof options.isTest === 'boolean' ? options.isTest : process.env.NODE_ENV === 'test';
+  }
+
+  countLines(message) {
+    return message.split('\n').reduce((p, line) => {
+      if (process.stdout.columns) {
+        return p + Math.ceil((line.length || 1) / process.stdout.columns);
+      }
+
+      return p + 1;
+    }, 0);
+  }
+
+  writeRaw(message) {
+    this.lines += this.countLines(message) - 1;
+    process.stdout.write(message);
+  }
+
+  write(message, persistent = false) {
+    if (!persistent) {
+      this.lines += this.countLines(message);
+    }
+
+    this._log(message);
+  }
+
+  log(message) {
+    if (this.logLevel < 3) {
+      return;
+    }
+
+    this.write(message);
+  }
+
+  persistent(message) {
+    if (this.logLevel < 3) {
+      return;
+    }
+
+    this.write(this.chalk.bold(message), true);
+  }
+
+  warn(err) {
+    if (this.logLevel < 2) {
+      return;
+    }
+
+    var _prettyError = prettyError(err, { color: this.color });
+
+    let message = _prettyError.message,
+        stack = _prettyError.stack;
+
+    this.write(this.chalk.yellow(`${emoji.warning}  ${message}`));
+    if (stack) {
+      this.write(stack);
+    }
+  }
+
+  error(err) {
+    if (this.logLevel < 1) {
+      return;
+    }
+
+    var _prettyError2 = prettyError(err, { color: this.color });
+
+    let message = _prettyError2.message,
+        stack = _prettyError2.stack;
+
+
+    this.status(emoji.error, message, 'red');
+    if (stack) {
+      this.write(stack);
+    }
+  }
+
+  clear() {
+    if (!this.color || this.isTest) {
+      return;
+    }
+
+    while (this.lines > 0) {
+      readline.clearLine(process.stdout, 0);
+      readline.moveCursor(process.stdout, 0, -1);
+      this.lines--;
+    }
+
+    readline.cursorTo(process.stdout, 0);
+    this.statusLine = null;
+  }
+
+  writeLine(line, msg) {
+    if (!this.color) {
+      return this.log(msg);
+    }
+
+    let n = this.lines - line;
+    let stdout = process.stdout;
+    readline.cursorTo(stdout, 0);
+    readline.moveCursor(stdout, 0, -n);
+    stdout.write(msg);
+    readline.clearLine(stdout, 1);
+    readline.cursorTo(stdout, 0);
+    readline.moveCursor(stdout, 0, n);
+  }
+
+  status(emoji, message, color = 'gray') {
+    if (this.logLevel < 3) {
+      return;
+    }
+
+    let hasStatusLine = this.statusLine != null;
+    if (!hasStatusLine) {
+      this.statusLine = this.lines;
+    }
+
+    this.writeLine(this.statusLine, this.chalk[color].bold(`${emoji}  ${message}`));
+
+    if (!hasStatusLine) {
+      process.stdout.write('\n');
+      this.lines++;
+    }
+  }
+
+  handleMessage(options) {
+    this[options.method](...options.args);
+  }
+
+  _log(message) {
+    console.log(message);
+  }
+
+  table(columns, table) {
+    // Measure column widths
+    let colWidths = [];
+    var _iteratorNormalCompletion = true;
+    var _didIteratorError = false;
+    var _iteratorError = undefined;
+
+    try {
+      for (var _iterator = table[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        let row = _step.value;
+
+        let i = 0;
+        var _iteratorNormalCompletion3 = true;
+        var _didIteratorError3 = false;
+        var _iteratorError3 = undefined;
+
+        try {
+          for (var _iterator3 = row[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+            let item = _step3.value;
+
+            colWidths[i] = Math.max(colWidths[i] || 0, stringWidth(item));
+            i++;
+          }
+        } catch (err) {
+          _didIteratorError3 = true;
+          _iteratorError3 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion3 && _iterator3.return) {
+              _iterator3.return();
+            }
+          } finally {
+            if (_didIteratorError3) {
+              throw _iteratorError3;
+            }
+          }
+        }
+      }
+
+      // Render rows
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+
+    var _iteratorNormalCompletion2 = true;
+    var _didIteratorError2 = false;
+    var _iteratorError2 = undefined;
+
+    try {
+      for (var _iterator2 = table[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+        let row = _step2.value;
+
+        let items = row.map((item, i) => {
+          // Add padding between columns unless the alignment is the opposite to the
+          // next column and pad to the column width.
+          let padding = !columns[i + 1] || columns[i + 1].align === columns[i].align ? 4 : 0;
+          return pad(item, colWidths[i] + padding, columns[i].align);
+        });
+
+        this.log(items.join(''));
+      }
+    } catch (err) {
+      _didIteratorError2 = true;
+      _iteratorError2 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion2 && _iterator2.return) {
+          _iterator2.return();
+        }
+      } finally {
+        if (_didIteratorError2) {
+          throw _iteratorError2;
+        }
+      }
+    }
+  }
+}
+
+// Pad a string with spaces on either side
+function pad(text, length, align = 'left') {
+  let pad = ' '.repeat(length - stringWidth(text));
+  if (align === 'right') {
+    return pad + text;
+  }
+
+  return text + pad;
+}
+
+// Count visible characters in a string
+function stringWidth(string) {
+  return countBreaks(stripAnsi('' + string));
+}
+
+// If we are in a worker, make a proxy class which will
+// send the logger calls to the main process via IPC.
+// These are handled in WorkerFarm and directed to handleMessage above.
+if (process.send && process.env.WORKER_TYPE === 'parcel-worker') {
+  const worker = require('./worker');
+  class LoggerProxy {}
+  var _iteratorNormalCompletion4 = true;
+  var _didIteratorError4 = false;
+  var _iteratorError4 = undefined;
+
+  try {
+    for (var _iterator4 = Object.getOwnPropertyNames(Logger.prototype)[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+      let method = _step4.value;
+
+      LoggerProxy.prototype[method] = (...args) => {
+        worker.addCall({
+          location: require.resolve('./Logger'),
+          method,
+          args
+        }, false);
+      };
+    }
+  } catch (err) {
+    _didIteratorError4 = true;
+    _iteratorError4 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion4 && _iterator4.return) {
+        _iterator4.return();
+      }
+    } finally {
+      if (_didIteratorError4) {
+        throw _iteratorError4;
+      }
+    }
+  }
+
+  module.exports = new LoggerProxy();
+} else {
+  module.exports = new Logger();
+}

VISUALIZACION/node_modules/parcel-bundler/lib/Parser.js

@@ -0,0 +1,87 @@
+'use strict';
+
+const path = require('path');
+const RawAsset = require('./assets/RawAsset');
+const GlobAsset = require('./assets/GlobAsset');
+const glob = require('glob');
+
+class Parser {
+  constructor(options = {}) {
+    this.extensions = {};
+
+    this.registerExtension('js', './assets/JSAsset');
+    this.registerExtension('jsx', './assets/JSAsset');
+    this.registerExtension('es6', './assets/JSAsset');
+    this.registerExtension('jsm', './assets/JSAsset');
+    this.registerExtension('mjs', './assets/JSAsset');
+    this.registerExtension('ml', './assets/ReasonAsset');
+    this.registerExtension('re', './assets/ReasonAsset');
+    this.registerExtension('ts', './assets/TypeScriptAsset');
+    this.registerExtension('tsx', './assets/TypeScriptAsset');
+    this.registerExtension('coffee', './assets/CoffeeScriptAsset');
+    this.registerExtension('vue', './assets/VueAsset');
+    this.registerExtension('json', './assets/JSONAsset');
+    this.registerExtension('json5', './assets/JSONAsset');
+    this.registerExtension('yaml', './assets/YAMLAsset');
+    this.registerExtension('yml', './assets/YAMLAsset');
+    this.registerExtension('toml', './assets/TOMLAsset');
+    this.registerExtension('gql', './assets/GraphqlAsset');
+    this.registerExtension('graphql', './assets/GraphqlAsset');
+
+    this.registerExtension('css', './assets/CSSAsset');
+    this.registerExtension('pcss', './assets/CSSAsset');
+    this.registerExtension('styl', './assets/StylusAsset');
+    this.registerExtension('stylus', './assets/StylusAsset');
+    this.registerExtension('less', './assets/LESSAsset');
+    this.registerExtension('sass', './assets/SASSAsset');
+    this.registerExtension('scss', './assets/SASSAsset');
+
+    this.registerExtension('html', './assets/HTMLAsset');
+    this.registerExtension('htm', './assets/HTMLAsset');
+    this.registerExtension('rs', './assets/RustAsset');
+
+    this.registerExtension('webmanifest', './assets/WebManifestAsset');
+
+    this.registerExtension('glsl', './assets/GLSLAsset');
+    this.registerExtension('vert', './assets/GLSLAsset');
+    this.registerExtension('frag', './assets/GLSLAsset');
+
+    this.registerExtension('jade', './assets/PugAsset');
+    this.registerExtension('pug', './assets/PugAsset');
+
+    let extensions = options.extensions || {};
+    for (let ext in extensions) {
+      this.registerExtension(ext, extensions[ext]);
+    }
+  }
+
+  registerExtension(ext, parser) {
+    if (!ext.startsWith('.')) {
+      ext = '.' + ext;
+    }
+
+    this.extensions[ext.toLowerCase()] = parser;
+  }
+
+  findParser(filename) {
+    if (/[*+{}]/.test(filename) && glob.hasMagic(filename)) {
+      return GlobAsset;
+    }
+
+    let extension = path.extname(filename).toLowerCase();
+    let parser = this.extensions[extension] || RawAsset;
+    if (typeof parser === 'string') {
+      parser = this.extensions[extension] = require(parser);
+    }
+
+    return parser;
+  }
+
+  getAsset(filename, pkg, options = {}) {
+    let Asset = this.findParser(filename);
+    options.parser = this;
+    return new Asset(filename, pkg, options);
+  }
+}
+
+module.exports = Parser;

VISUALIZACION/node_modules/parcel-bundler/lib/Pipeline.js

@@ -0,0 +1,156 @@
+'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 Parser = require('./Parser');
+const path = require('path');
+const md5 = require('./utils/md5');
+
+/**
+ * A Pipeline composes multiple Asset types together.
+ */
+class Pipeline {
+  constructor(options) {
+    this.options = options;
+    this.parser = new Parser(options);
+  }
+
+  process(path, pkg, options) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      let asset = _this.parser.getAsset(path, pkg, options);
+      let generated = yield _this.processAsset(asset);
+      let generatedMap = {};
+      var _iteratorNormalCompletion = true;
+      var _didIteratorError = false;
+      var _iteratorError = undefined;
+
+      try {
+        for (var _iterator = generated[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          let rendition = _step.value;
+
+          generatedMap[rendition.type] = rendition.value;
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+
+      return {
+        dependencies: Array.from(asset.dependencies.values()),
+        generated: generatedMap,
+        hash: asset.hash,
+        cacheData: asset.cacheData
+      };
+    })();
+  }
+
+  processAsset(asset) {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      try {
+        yield asset.process();
+      } catch (err) {
+        throw asset.generateErrorMessage(err);
+      }
+
+      let inputType = path.extname(asset.name).slice(1);
+      let generated = [];
+
+      var _iteratorNormalCompletion2 = true;
+      var _didIteratorError2 = false;
+      var _iteratorError2 = undefined;
+
+      try {
+        for (var _iterator2 = _this2.iterateRenditions(asset)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+          let rendition = _step2.value;
+          let type = rendition.type,
+              value = rendition.value;
+
+          if (typeof value !== 'string' || rendition.final) {
+            generated.push(rendition);
+            continue;
+          }
+
+          // Find an asset type for the rendition type.
+          // If the asset is not already an instance of this asset type, process it.
+          let AssetType = _this2.parser.findParser(asset.name.slice(0, -inputType.length) + type);
+          if (!(asset instanceof AssetType)) {
+            let opts = Object.assign({ rendition }, asset.options);
+            let subAsset = new AssetType(asset.name, asset.package, opts);
+            subAsset.contents = value;
+            subAsset.dependencies = asset.dependencies;
+
+            let processed = yield _this2.processAsset(subAsset);
+            generated = generated.concat(processed);
+            Object.assign(asset.cacheData, subAsset.cacheData);
+            asset.hash = md5(asset.hash + subAsset.hash);
+          } else {
+            generated.push(rendition);
+          }
+        }
+
+        // Post process. This allows assets a chance to modify the output produced by sub-asset types.
+      } catch (err) {
+        _didIteratorError2 = true;
+        _iteratorError2 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion2 && _iterator2.return) {
+            _iterator2.return();
+          }
+        } finally {
+          if (_didIteratorError2) {
+            throw _iteratorError2;
+          }
+        }
+      }
+
+      asset.generated = generated;
+      try {
+        generated = yield asset.postProcess(generated);
+      } catch (err) {
+        throw asset.generateErrorMessage(err);
+      }
+
+      return generated;
+    })();
+  }
+
+  *iterateRenditions(asset) {
+    if (Array.isArray(asset.generated)) {
+      return yield* asset.generated;
+    }
+
+    if (typeof asset.generated === 'string') {
+      return yield {
+        type: asset.type,
+        value: asset.generated
+      };
+    }
+
+    // Backward compatibility support for the old API.
+    // Assume all renditions are final - don't compose asset types together.
+    for (let type in asset.generated) {
+      yield {
+        type,
+        value: asset.generated[type],
+        final: true
+      };
+    }
+  }
+}
+
+module.exports = Pipeline;

VISUALIZACION/node_modules/parcel-bundler/lib/Resolver.js

@@ -0,0 +1,503 @@
+'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 builtins = require('./builtins');
+const path = require('path');
+const glob = require('glob');
+const fs = require('./utils/fs');
+const micromatch = require('micromatch');
+
+const EMPTY_SHIM = require.resolve('./builtins/_empty');
+const GLOB_RE = /[*+{}]/;
+
+/**
+ * This resolver implements a modified version of the node_modules resolution algorithm:
+ * https://nodejs.org/api/modules.html#modules_all_together
+ *
+ * In addition to the standard algorithm, Parcel supports:
+ *   - All file extensions supported by Parcel.
+ *   - Glob file paths
+ *   - Absolute paths (e.g. /foo) resolved relative to the project root.
+ *   - Tilde paths (e.g. ~/foo) resolved relative to the nearest module root in node_modules.
+ *   - The package.json module, jsnext:main, and browser field as replacements for package.main.
+ *   - The package.json browser and alias fields as an alias map within a local module.
+ *   - The package.json alias field in the root package for global aliases across all modules.
+ */
+class Resolver {
+  constructor(options = {}) {
+    this.options = options;
+    this.cache = new Map();
+    this.packageCache = new Map();
+    this.rootPackage = null;
+  }
+
+  resolve(input, parent) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      let filename = input;
+
+      // Check the cache first
+      let key = _this.getCacheKey(filename, parent);
+      if (_this.cache.has(key)) {
+        return _this.cache.get(key);
+      }
+
+      // Check if this is a glob
+      if (GLOB_RE.test(filename) && glob.hasMagic(filename)) {
+        return { path: path.resolve(path.dirname(parent), filename) };
+      }
+
+      // Get file extensions to search
+      let extensions = Array.isArray(_this.options.extensions) ? _this.options.extensions.slice() : Object.keys(_this.options.extensions);
+
+      if (parent) {
+        // parent's extension given high priority
+        const parentExt = path.extname(parent);
+        extensions = [parentExt, ...extensions.filter(function (ext) {
+          return ext !== parentExt;
+        })];
+      }
+
+      extensions.unshift('');
+
+      // Resolve the module directory or local file path
+      let module = yield _this.resolveModule(filename, parent);
+      let resolved;
+
+      if (module.moduleDir) {
+        resolved = yield _this.loadNodeModules(module, extensions);
+      } else if (module.filePath) {
+        resolved = yield _this.loadRelative(module.filePath, extensions);
+      }
+
+      if (!resolved) {
+        let dir = parent ? path.dirname(parent) : process.cwd();
+        let err = new Error(`Cannot find module '${input}' from '${dir}'`);
+        err.code = 'MODULE_NOT_FOUND';
+        throw err;
+      }
+
+      _this.cache.set(key, resolved);
+      return resolved;
+    })();
+  }
+
+  resolveModule(filename, parent) {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      let dir = parent ? path.dirname(parent) : process.cwd();
+
+      // If this isn't the entrypoint, resolve the input file to an absolute path
+      if (parent) {
+        filename = _this2.resolveFilename(filename, dir);
+      }
+
+      // Resolve aliases in the parent module for this file.
+      filename = yield _this2.loadAlias(filename, dir);
+
+      // Return just the file path if this is a file, not in node_modules
+      if (path.isAbsolute(filename)) {
+        return {
+          filePath: filename
+        };
+      }
+
+      // Resolve the module in node_modules
+      let resolved;
+      try {
+        resolved = yield _this2.findNodeModulePath(filename, dir);
+      } catch (err) {}
+      // ignore
+
+
+      // If we couldn't resolve the node_modules path, just return the module name info
+      if (!resolved) {
+        let parts = _this2.getModuleParts(filename);
+        resolved = {
+          moduleName: parts[0],
+          subPath: parts[1]
+        };
+      }
+
+      return resolved;
+    })();
+  }
+
+  getCacheKey(filename, parent) {
+    return (parent ? path.dirname(parent) : '') + ':' + filename;
+  }
+
+  resolveFilename(filename, dir) {
+    switch (filename[0]) {
+      case '/':
+        // Absolute path. Resolve relative to project root.
+        return path.resolve(this.options.rootDir, filename.slice(1));
+
+      case '~':
+        // Tilde path. Resolve relative to nearest node_modules directory,
+        // or the project root - whichever comes first.
+        while (dir !== this.options.rootDir && path.basename(path.dirname(dir)) !== 'node_modules') {
+          dir = path.dirname(dir);
+        }
+
+        return path.join(dir, filename.slice(1));
+
+      case '.':
+        // Relative path.
+        return path.resolve(dir, filename);
+
+      default:
+        // Module
+        return path.normalize(filename);
+    }
+  }
+
+  loadRelative(filename, extensions) {
+    var _this3 = this;
+
+    return _asyncToGenerator(function* () {
+      // Find a package.json file in the current package.
+      let pkg = yield _this3.findPackage(path.dirname(filename));
+
+      // First try as a file, then as a directory.
+      return (yield _this3.loadAsFile(filename, extensions, pkg)) || (yield _this3.loadDirectory(filename, extensions, pkg));
+    })();
+  }
+
+  findNodeModulePath(filename, dir) {
+    var _this4 = this;
+
+    return _asyncToGenerator(function* () {
+      if (builtins[filename]) {
+        return { filePath: builtins[filename] };
+      }
+
+      let parts = _this4.getModuleParts(filename);
+      let root = path.parse(dir).root;
+
+      while (dir !== root) {
+        // Skip node_modules directories
+        if (path.basename(dir) === 'node_modules') {
+          dir = path.dirname(dir);
+        }
+
+        try {
+          // First, check if the module directory exists. This prevents a lot of unnecessary checks later.
+          let moduleDir = path.join(dir, 'node_modules', parts[0]);
+          let stats = yield fs.stat(moduleDir);
+          if (stats.isDirectory()) {
+            return {
+              moduleName: parts[0],
+              subPath: parts[1],
+              moduleDir: moduleDir,
+              filePath: path.join(dir, 'node_modules', filename)
+            };
+          }
+        } catch (err) {}
+        // ignore
+
+
+        // Move up a directory
+        dir = path.dirname(dir);
+      }
+    })();
+  }
+
+  loadNodeModules(module, extensions) {
+    var _this5 = this;
+
+    return _asyncToGenerator(function* () {
+      try {
+        // If a module was specified as a module sub-path (e.g. some-module/some/path),
+        // it is likely a file. Try loading it as a file first.
+        if (module.subPath) {
+          let pkg = yield _this5.readPackage(module.moduleDir);
+          let res = yield _this5.loadAsFile(module.filePath, extensions, pkg);
+          if (res) {
+            return res;
+          }
+        }
+
+        // Otherwise, load as a directory.
+        return yield _this5.loadDirectory(module.filePath, extensions);
+      } catch (e) {
+        // ignore
+      }
+    })();
+  }
+
+  isFile(file) {
+    return _asyncToGenerator(function* () {
+      try {
+        let stat = yield fs.stat(file);
+        return stat.isFile() || stat.isFIFO();
+      } catch (err) {
+        return false;
+      }
+    })();
+  }
+
+  loadDirectory(dir, extensions, pkg) {
+    var _this6 = this;
+
+    return _asyncToGenerator(function* () {
+      try {
+        pkg = yield _this6.readPackage(dir);
+
+        // First try loading package.main as a file, then try as a directory.
+        let main = _this6.getPackageMain(pkg);
+        let res = (yield _this6.loadAsFile(main, extensions, pkg)) || (yield _this6.loadDirectory(main, extensions, pkg));
+
+        if (res) {
+          return res;
+        }
+      } catch (err) {}
+      // ignore
+
+
+      // Fall back to an index file inside the directory.
+      return yield _this6.loadAsFile(path.join(dir, 'index'), extensions, pkg);
+    })();
+  }
+
+  readPackage(dir) {
+    var _this7 = this;
+
+    return _asyncToGenerator(function* () {
+      let file = path.join(dir, 'package.json');
+      if (_this7.packageCache.has(file)) {
+        return _this7.packageCache.get(file);
+      }
+
+      let json = yield fs.readFile(file, 'utf8');
+      let pkg = JSON.parse(json);
+
+      pkg.pkgfile = file;
+      pkg.pkgdir = dir;
+
+      // If the package has a `source` field, check if it is behind a symlink.
+      // If so, we treat the module as source code rather than a pre-compiled module.
+      if (pkg.source) {
+        let realpath = yield fs.realpath(file);
+        if (realpath === file) {
+          delete pkg.source;
+        }
+      }
+
+      _this7.packageCache.set(file, pkg);
+      return pkg;
+    })();
+  }
+
+  getPackageMain(pkg) {
+    // libraries like d3.js specifies node.js specific files in the "main" which breaks the build
+    // we use the "module" or "browser" field to get the full dependency tree if available.
+    // If this is a linked module with a `source` field, use that as the entry point.
+    let main = [pkg.source, pkg.module, pkg.browser, pkg.main].find(entry => typeof entry === 'string');
+
+    // Default to index file if no main field find
+    if (!main || main === '.' || main === './') {
+      main = 'index';
+    }
+
+    return path.resolve(pkg.pkgdir, main);
+  }
+
+  loadAsFile(file, extensions, pkg) {
+    var _this8 = this;
+
+    return _asyncToGenerator(function* () {
+      // Try all supported extensions
+      var _iteratorNormalCompletion = true;
+      var _didIteratorError = false;
+      var _iteratorError = undefined;
+
+      try {
+        for (var _iterator = _this8.expandFile(file, extensions, pkg)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          let f = _step.value;
+
+          if (yield _this8.isFile(f)) {
+            return { path: f, pkg };
+          }
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+    })();
+  }
+
+  expandFile(file, extensions, pkg, expandAliases = true) {
+    // Expand extensions and aliases
+    let res = [];
+    var _iteratorNormalCompletion2 = true;
+    var _didIteratorError2 = false;
+    var _iteratorError2 = undefined;
+
+    try {
+      for (var _iterator2 = extensions[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+        let ext = _step2.value;
+
+        let f = file + ext;
+
+        if (expandAliases) {
+          let alias = this.resolveAliases(file + ext, pkg);
+          if (alias !== f) {
+            res = res.concat(this.expandFile(alias, extensions, pkg, false));
+          }
+        }
+
+        res.push(f);
+      }
+    } catch (err) {
+      _didIteratorError2 = true;
+      _iteratorError2 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion2 && _iterator2.return) {
+          _iterator2.return();
+        }
+      } finally {
+        if (_didIteratorError2) {
+          throw _iteratorError2;
+        }
+      }
+    }
+
+    return res;
+  }
+
+  resolveAliases(filename, pkg) {
+    // First resolve local package aliases, then project global ones.
+    return this.resolvePackageAliases(this.resolvePackageAliases(filename, pkg), this.rootPackage);
+  }
+
+  resolvePackageAliases(filename, pkg) {
+    if (!pkg) {
+      return filename;
+    }
+
+    // Resolve aliases in the package.source, package.alias, and package.browser fields.
+    return this.getAlias(filename, pkg.pkgdir, pkg.source) || this.getAlias(filename, pkg.pkgdir, pkg.alias) || this.getAlias(filename, pkg.pkgdir, pkg.browser) || filename;
+  }
+
+  getAlias(filename, dir, aliases) {
+    if (!filename || !aliases || typeof aliases !== 'object') {
+      return null;
+    }
+
+    let alias;
+
+    // If filename is an absolute path, get one relative to the package.json directory.
+    if (path.isAbsolute(filename)) {
+      filename = path.relative(dir, filename);
+      if (filename[0] !== '.') {
+        filename = './' + filename;
+      }
+
+      alias = this.lookupAlias(aliases, filename);
+    } else {
+      // It is a node_module. First try the entire filename as a key.
+      alias = aliases[filename];
+      if (alias == null) {
+        // If it didn't match, try only the module name.
+        let parts = this.getModuleParts(filename);
+        alias = aliases[parts[0]];
+        if (typeof alias === 'string') {
+          // Append the filename back onto the aliased module.
+          alias = path.join(alias, ...parts.slice(1));
+        }
+      }
+    }
+
+    // If the alias is set to `false`, return an empty file.
+    if (alias === false) {
+      return EMPTY_SHIM;
+    }
+
+    // If the alias is a relative path, then resolve
+    // relative to the package.json directory.
+    if (alias && alias[0] === '.') {
+      return path.resolve(dir, alias);
+    }
+
+    // Otherwise, assume the alias is a module
+    return alias;
+  }
+
+  lookupAlias(aliases, filename) {
+    // First, try looking up the exact filename
+    let alias = aliases[filename];
+    if (alias != null) {
+      return alias;
+    }
+
+    // Otherwise, try replacing glob keys
+    for (let key in aliases) {
+      if (GLOB_RE.test(key)) {
+        let re = micromatch.makeRe(key, { capture: true });
+        if (re.test(filename)) {
+          return filename.replace(re, aliases[key]);
+        }
+      }
+    }
+  }
+
+  findPackage(dir) {
+    var _this9 = this;
+
+    return _asyncToGenerator(function* () {
+      // Find the nearest package.json file within the current node_modules folder
+      let root = path.parse(dir).root;
+      while (dir !== root && path.basename(dir) !== 'node_modules') {
+        try {
+          return yield _this9.readPackage(dir);
+        } catch (err) {
+          // ignore
+        }
+
+        dir = path.dirname(dir);
+      }
+    })();
+  }
+
+  loadAlias(filename, dir) {
+    var _this10 = this;
+
+    return _asyncToGenerator(function* () {
+      // Load the root project's package.json file if we haven't already
+      if (!_this10.rootPackage) {
+        _this10.rootPackage = yield _this10.findPackage(_this10.options.rootDir);
+      }
+
+      // Load the local package, and resolve aliases
+      let pkg = yield _this10.findPackage(dir);
+      return _this10.resolveAliases(filename, pkg);
+    })();
+  }
+
+  getModuleParts(name) {
+    let parts = path.normalize(name).split(path.sep);
+    if (parts[0].charAt(0) === '@') {
+      // Scoped module (e.g. @scope/module). Merge the first two parts back together.
+      parts.splice(0, 2, `${parts[0]}/${parts[1]}`);
+    }
+
+    return parts;
+  }
+}
+
+module.exports = Resolver;

VISUALIZACION/node_modules/parcel-bundler/lib/Server.js

@@ -0,0 +1,126 @@
+'use strict';
+
+let serve = (() => {
+  var _ref = _asyncToGenerator(function* (bundler, port, useHTTPS = false) {
+    let handler = middleware(bundler);
+    let server;
+    if (!useHTTPS) {
+      server = http.createServer(handler);
+    } else if (typeof useHTTPS === 'boolean') {
+      server = https.createServer(generateCertificate(bundler.options), handler);
+    } else {
+      server = https.createServer((yield getCertificate(useHTTPS)), handler);
+    }
+
+    let freePort = yield getPort({ port });
+    server.listen(freePort);
+
+    return new Promise(function (resolve, reject) {
+      server.on('error', function (err) {
+        logger.error(new Error(serverErrors(err, server.address().port)));
+        reject(err);
+      });
+
+      server.once('listening', function () {
+        let addon = server.address().port !== port ? `- ${logger.chalk.yellow(`configured port ${port} could not be used.`)}` : '';
+
+        logger.persistent(`Server running at ${logger.chalk.cyan(`${useHTTPS ? 'https' : 'http'}://localhost:${server.address().port}`)} ${addon}`);
+
+        resolve(server);
+      });
+    });
+  });
+
+  return function serve(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+})();
+
+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 http = require('http');
+const https = require('https');
+const serveStatic = require('serve-static');
+const getPort = require('get-port');
+const serverErrors = require('./utils/customErrors').serverErrors;
+const generateCertificate = require('./utils/generateCertificate');
+const getCertificate = require('./utils/getCertificate');
+const logger = require('./Logger');
+const path = require('path');
+const url = require('url');
+
+serveStatic.mime.define({
+  'application/wasm': ['wasm']
+});
+
+function setHeaders(res) {
+  enableCors(res);
+}
+
+function enableCors(res) {
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Methods', 'GET, HEAD, PUT, PATCH, POST, DELETE');
+  res.setHeader('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Content-Type');
+}
+
+function middleware(bundler) {
+  const serve = serveStatic(bundler.options.outDir, {
+    index: false,
+    setHeaders: setHeaders
+  });
+
+  return function (req, res, next) {
+    // Wait for the bundler to finish bundling if needed
+    if (bundler.pending) {
+      bundler.once('bundled', respond);
+    } else {
+      respond();
+    }
+
+    function respond() {
+      var _url$parse = url.parse(req.url);
+
+      let pathname = _url$parse.pathname;
+
+      if (bundler.errored) {
+        return send500();
+      } else if (!pathname.startsWith(bundler.options.publicURL) || path.extname(pathname) === '') {
+        // If the URL doesn't start with the public path, or the URL doesn't
+        // have a file extension, send the main HTML bundle.
+        return sendIndex();
+      } else {
+        // Otherwise, serve the file from the dist folder
+        req.url = pathname.slice(bundler.options.publicURL.length);
+        return serve(req, res, send404);
+      }
+    }
+
+    function sendIndex() {
+      // If the main asset is an HTML file, serve it
+      if (bundler.mainBundle.type === 'html') {
+        req.url = `/${path.basename(bundler.mainBundle.name)}`;
+        serve(req, res, send404);
+      } else {
+        send404();
+      }
+    }
+
+    function send500() {
+      res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+      res.writeHead(500);
+      res.end('🚨 Build error, check the console for details.');
+    }
+
+    function send404() {
+      if (next) {
+        return next();
+      }
+
+      res.writeHead(404);
+      res.end();
+    }
+  };
+}
+
+exports.middleware = middleware;
+exports.serve = serve;

VISUALIZACION/node_modules/parcel-bundler/lib/SourceMap.js

@@ -0,0 +1,270 @@
+'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"); }); }; }
+
+var _require = require('source-map');
+
+const SourceMapConsumer = _require.SourceMapConsumer,
+      SourceMapGenerator = _require.SourceMapGenerator;
+
+const lineCounter = require('./utils/lineCounter');
+
+class SourceMap {
+  constructor(mappings, sources) {
+    this.mappings = this.purifyMappings(mappings);
+    this.sources = sources || {};
+    this.lineCount = null;
+  }
+
+  purifyMappings(mappings) {
+    if (Array.isArray(mappings)) {
+      return mappings.filter(mapping => {
+        return mapping && mapping.source && mapping.original && typeof mapping.original.line === 'number' && mapping.original.line > 0 && typeof mapping.original.column === 'number' && mapping.generated && typeof mapping.generated.line === 'number' && mapping.generated.line > 0 && typeof mapping.generated.column === 'number';
+      });
+    }
+
+    return [];
+  }
+
+  getConsumer(map) {
+    return _asyncToGenerator(function* () {
+      if (map instanceof SourceMapConsumer) {
+        return map;
+      }
+      map = typeof map === 'string' ? JSON.parse(map) : map;
+      return yield new SourceMapConsumer(map);
+    })();
+  }
+
+  addMap(map, lineOffset = 0, columnOffset = 0) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      if (!(map instanceof SourceMap) && map.version) {
+        let consumer = yield _this.getConsumer(map);
+
+        consumer.eachMapping(function (mapping) {
+          _this.addConsumerMapping(mapping, lineOffset, columnOffset);
+          if (!_this.sources[mapping.source]) {
+            _this.sources[mapping.source] = consumer.sourceContentFor(mapping.source, true);
+          }
+        });
+
+        if (consumer.destroy) {
+          // Only needs to happen in source-map 0.7
+          consumer.destroy();
+        }
+      } else {
+        if (!map.eachMapping) {
+          map = new SourceMap(map.mappings, map.sources);
+        }
+
+        if (lineOffset === 0 && columnOffset === 0) {
+          _this.mappings = _this.mappings.concat(map.mappings);
+        } else {
+          map.eachMapping(function (mapping) {
+            _this.addMapping(mapping, lineOffset, columnOffset);
+          });
+        }
+
+        Object.keys(map.sources).forEach(function (sourceName) {
+          if (!_this.sources[sourceName]) {
+            _this.sources[sourceName] = map.sources[sourceName];
+          }
+        });
+      }
+
+      return _this;
+    })();
+  }
+
+  addMapping(mapping, lineOffset = 0, columnOffset = 0) {
+    mapping.generated = {
+      line: mapping.generated.line + lineOffset,
+      column: mapping.generated.column + columnOffset
+    };
+
+    this.mappings.push(mapping);
+  }
+
+  addConsumerMapping(mapping, lineOffset = 0, columnOffset = 0) {
+    if (!mapping.source || !mapping.originalLine || !mapping.originalColumn && mapping.originalColumn !== 0) {
+      return;
+    }
+
+    this.mappings.push({
+      source: mapping.source,
+      original: {
+        line: mapping.originalLine,
+        column: mapping.originalColumn
+      },
+      generated: {
+        line: mapping.generatedLine + lineOffset,
+        column: mapping.generatedColumn + columnOffset
+      },
+      name: mapping.name
+    });
+  }
+
+  eachMapping(callback) {
+    this.mappings.forEach(callback);
+  }
+
+  generateEmptyMap(sourceName, sourceContent) {
+    this.sources[sourceName] = sourceContent;
+
+    this.lineCount = lineCounter(sourceContent);
+    for (let line = 1; line < this.lineCount + 1; line++) {
+      this.addMapping({
+        source: sourceName,
+        original: {
+          line: line,
+          column: 0
+        },
+        generated: {
+          line: line,
+          column: 0
+        }
+      });
+    }
+
+    return this;
+  }
+
+  extendSourceMap(original, extension) {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      if (!(extension instanceof SourceMap)) {
+        extension = yield new SourceMap().addMap(extension);
+      }
+      if (!(original instanceof SourceMap)) {
+        original = yield _this2.getConsumer(original);
+      }
+
+      extension.eachMapping(function (mapping) {
+        let originalMapping = original.originalPositionFor({
+          line: mapping.original.line,
+          column: mapping.original.column
+        });
+
+        if (!originalMapping.line) {
+          return false;
+        }
+
+        _this2.addMapping({
+          source: originalMapping.source,
+          name: originalMapping.name,
+          original: {
+            line: originalMapping.line,
+            column: originalMapping.column
+          },
+          generated: {
+            line: mapping.generated.line,
+            column: mapping.generated.column
+          }
+        });
+
+        if (!_this2.sources[originalMapping.source]) {
+          _this2.sources[originalMapping.source] = original.sourceContentFor(originalMapping.source, true);
+        }
+      });
+
+      if (original.destroy) {
+        // Only needs to happen in source-map 0.7
+        original.destroy();
+      }
+
+      return _this2;
+    })();
+  }
+
+  findClosest(line, column, key = 'original') {
+    if (line < 1) {
+      throw new Error('Line numbers must be >= 1');
+    }
+
+    if (column < 0) {
+      throw new Error('Column numbers must be >= 0');
+    }
+
+    if (this.mappings.length < 1) {
+      return undefined;
+    }
+
+    let startIndex = 0;
+    let stopIndex = this.mappings.length - 1;
+    let middleIndex = Math.floor((stopIndex + startIndex) / 2);
+
+    while (startIndex < stopIndex && this.mappings[middleIndex][key].line !== line) {
+      if (line < this.mappings[middleIndex][key].line) {
+        stopIndex = middleIndex - 1;
+      } else if (line > this.mappings[middleIndex][key].line) {
+        startIndex = middleIndex + 1;
+      }
+      middleIndex = Math.floor((stopIndex + startIndex) / 2);
+    }
+
+    let mapping = this.mappings[middleIndex];
+    if (!mapping || mapping[key].line !== line) {
+      return this.mappings.length - 1;
+    }
+
+    while (middleIndex >= 1 && this.mappings[middleIndex - 1][key].line === line) {
+      middleIndex--;
+    }
+
+    while (middleIndex < this.mappings.length - 1 && this.mappings[middleIndex + 1][key].line === line && column > this.mappings[middleIndex][key].column) {
+      middleIndex++;
+    }
+
+    return middleIndex;
+  }
+
+  originalPositionFor(generatedPosition) {
+    let index = this.findClosest(generatedPosition.line, generatedPosition.column, 'generated');
+    return {
+      source: this.mappings[index].source,
+      name: this.mappings[index].name,
+      line: this.mappings[index].original.line,
+      column: this.mappings[index].original.column
+    };
+  }
+
+  generatedPositionFor(originalPosition) {
+    let index = this.findClosest(originalPosition.line, originalPosition.column, 'original');
+    return {
+      source: this.mappings[index].source,
+      name: this.mappings[index].name,
+      line: this.mappings[index].generated.line,
+      column: this.mappings[index].generated.column
+    };
+  }
+
+  sourceContentFor(fileName) {
+    return this.sources[fileName];
+  }
+
+  offset(lineOffset = 0, columnOffset = 0) {
+    this.mappings.map(mapping => {
+      mapping.generated.line = mapping.generated.line + lineOffset;
+      mapping.generated.column = mapping.generated.column + columnOffset;
+      return mapping;
+    });
+
+    if (this.lineCount != null) {
+      this.lineCount += lineOffset;
+    }
+  }
+
+  stringify(file, sourceRoot) {
+    let generator = new SourceMapGenerator({ file, sourceRoot });
+
+    this.eachMapping(mapping => generator.addMapping(mapping));
+    Object.keys(this.sources).forEach(sourceName => generator.setSourceContent(sourceName, this.sources[sourceName]));
+
+    return generator.toString();
+  }
+}
+
+module.exports = SourceMap;

VISUALIZACION/node_modules/parcel-bundler/lib/Watcher.js

@@ -0,0 +1,182 @@
+'use strict';
+
+var _require = require('chokidar');
+
+const FSWatcher = _require.FSWatcher;
+
+const Path = require('path');
+
+/**
+ * This watcher wraps chokidar so that we watch directories rather than individual files.
+ * This prevents us from hitting EMFILE errors when running out of file descriptors.
+ */
+class Watcher {
+  constructor() {
+    // FS events on macOS are flakey in the tests, which write lots of files very quickly
+    // See https://github.com/paulmillr/chokidar/issues/612
+    this.shouldWatchDirs = process.env.NODE_ENV !== 'test';
+    this.watcher = new FSWatcher({
+      useFsEvents: this.shouldWatchDirs,
+      ignoreInitial: true,
+      ignored: /\.cache|\.git/
+    });
+
+    this.watchedDirectories = new Map();
+
+    // Only close the watcher after the ready event is emitted
+    this.ready = false;
+    this.stopped = false;
+    this.watcher.once('ready', () => {
+      this.ready = true;
+      if (this.stopped) {
+        this.watcher.close();
+      }
+    });
+  }
+
+  /**
+   * Find a parent directory of `path` which is already watched
+   */
+  getWatchedParent(path) {
+    path = Path.dirname(path);
+
+    let root = Path.parse(path).root;
+    while (path !== root) {
+      if (this.watchedDirectories.has(path)) {
+        return path;
+      }
+
+      path = Path.dirname(path);
+    }
+
+    return null;
+  }
+
+  /**
+   * Find a list of child directories of `path` which are already watched
+   */
+  getWatchedChildren(path) {
+    path = Path.dirname(path) + Path.sep;
+
+    let res = [];
+    var _iteratorNormalCompletion = true;
+    var _didIteratorError = false;
+    var _iteratorError = undefined;
+
+    try {
+      for (var _iterator = this.watchedDirectories.keys()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        let dir = _step.value;
+
+        if (dir.startsWith(path)) {
+          res.push(dir);
+        }
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+
+    return res;
+  }
+
+  /**
+   * Add a path to the watcher
+   */
+  watch(path) {
+    if (this.shouldWatchDirs) {
+      // If there is no parent directory already watching this path, add a new watcher.
+      let parent = this.getWatchedParent(path);
+      if (!parent) {
+        // Find watchers on child directories, and remove them. They will be handled by the new parent watcher.
+        let children = this.getWatchedChildren(path);
+        let count = 1;
+
+        var _iteratorNormalCompletion2 = true;
+        var _didIteratorError2 = false;
+        var _iteratorError2 = undefined;
+
+        try {
+          for (var _iterator2 = children[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+            let dir = _step2.value;
+
+            count += this.watchedDirectories.get(dir);
+            this.watcher._closePath(dir);
+            this.watchedDirectories.delete(dir);
+          }
+        } catch (err) {
+          _didIteratorError2 = true;
+          _iteratorError2 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion2 && _iterator2.return) {
+              _iterator2.return();
+            }
+          } finally {
+            if (_didIteratorError2) {
+              throw _iteratorError2;
+            }
+          }
+        }
+
+        let dir = Path.dirname(path);
+        this.watcher.add(dir);
+        this.watchedDirectories.set(dir, count);
+      } else {
+        // Otherwise, increment the reference count of the parent watcher.
+        this.watchedDirectories.set(parent, this.watchedDirectories.get(parent) + 1);
+      }
+    } else {
+      this.watcher.add(path);
+    }
+  }
+
+  /**
+   * Remove a path from the watcher
+   */
+  unwatch(path) {
+    if (this.shouldWatchDirs) {
+      let dir = this.getWatchedParent(path);
+      if (dir) {
+        // When the count of files watching a directory reaches zero, unwatch it.
+        let count = this.watchedDirectories.get(dir) - 1;
+        if (count === 0) {
+          this.watchedDirectories.delete(dir);
+          this.watcher.unwatch(dir);
+        } else {
+          this.watchedDirectories.set(dir, count);
+        }
+      }
+    } else {
+      this.watcher.unwatch(path);
+    }
+  }
+
+  /**
+   * Add an event handler
+   */
+  on(event, callback) {
+    this.watcher.on(event, callback);
+  }
+
+  /**
+   * Stop watching all paths
+   */
+  stop() {
+    this.stopped = true;
+    if (this.ready) {
+      this.watcher.close();
+    }
+  }
+}
+
+module.exports = Watcher;

VISUALIZACION/node_modules/parcel-bundler/lib/WorkerFarm.js

@@ -0,0 +1,150 @@
+'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"); }); }; }
+
+var _require = require('events');
+
+const EventEmitter = _require.EventEmitter;
+
+const os = require('os');
+const Farm = require('worker-farm/lib/farm');
+const promisify = require('./utils/promisify');
+const logger = require('./Logger');
+
+let shared = null;
+
+class WorkerFarm extends Farm {
+  constructor(options) {
+    let opts = {
+      maxConcurrentWorkers: getNumWorkers()
+    };
+
+    let workerPath = parseInt(process.versions.node, 10) < 8 ? require.resolve('../lib/worker') : require.resolve('../src/worker');
+
+    super(opts, workerPath);
+
+    this.localWorker = this.promisifyWorker(require('./worker'));
+    this.remoteWorker = this.promisifyWorker(this.setup(['init', 'run']));
+
+    this.started = false;
+    this.warmWorkers = 0;
+    this.init(options);
+  }
+
+  init(options) {
+    this.localWorker.init(options);
+    this.initRemoteWorkers(options);
+  }
+
+  promisifyWorker(worker) {
+    let res = {};
+
+    for (let key in worker) {
+      res[key] = promisify(worker[key].bind(worker));
+    }
+
+    return res;
+  }
+
+  initRemoteWorkers(options) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      _this.started = false;
+      _this.warmWorkers = 0;
+
+      let promises = [];
+      for (let i = 0; i < _this.options.maxConcurrentWorkers; i++) {
+        promises.push(_this.remoteWorker.init(options));
+      }
+
+      yield Promise.all(promises);
+      if (_this.options.maxConcurrentWorkers > 0) {
+        _this.started = true;
+      }
+    })();
+  }
+
+  receive(data) {
+    if (data.event) {
+      this.emit(data.event, ...data.args);
+    } else if (data.type === 'logger') {
+      if (this.shouldUseRemoteWorkers()) {
+        logger.handleMessage(data);
+      }
+    } else if (this.children[data.child]) {
+      super.receive(data);
+    }
+  }
+
+  shouldUseRemoteWorkers() {
+    return this.started && this.warmWorkers >= this.activeChildren;
+  }
+
+  run(...args) {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      // Child process workers are slow to start (~600ms).
+      // While we're waiting, just run on the main thread.
+      // This significantly speeds up startup time.
+      if (_this2.shouldUseRemoteWorkers()) {
+        return _this2.remoteWorker.run(...args, false);
+      } else {
+        // Workers have started, but are not warmed up yet.
+        // Send the job to a remote worker in the background,
+        // but use the result from the local worker - it will be faster.
+        if (_this2.started) {
+          _this2.remoteWorker.run(...args, true).then(function () {
+            _this2.warmWorkers++;
+          }, function () {
+            // ignore error
+          });
+        }
+
+        return _this2.localWorker.run(...args, false);
+      }
+    })();
+  }
+
+  end() {
+    // Force kill all children
+    this.ending = true;
+    for (let child in this.children) {
+      this.stopChild(child);
+    }
+
+    this.ending = false;
+    shared = null;
+  }
+
+  static getShared(options) {
+    if (!shared) {
+      shared = new WorkerFarm(options);
+    } else {
+      shared.init(options);
+    }
+
+    return shared;
+  }
+}
+
+for (let key in EventEmitter.prototype) {
+  WorkerFarm.prototype[key] = EventEmitter.prototype[key];
+}
+
+function getNumWorkers() {
+  if (process.env.PARCEL_WORKERS) {
+    return parseInt(process.env.PARCEL_WORKERS, 10);
+  }
+
+  let cores;
+  try {
+    cores = require('physical-cpu-count');
+  } catch (err) {
+    cores = os.cpus().length;
+  }
+  return cores || 1;
+}
+
+module.exports = WorkerFarm;

VISUALIZACION/node_modules/parcel-bundler/lib/assets/CSSAsset.js

@@ -0,0 +1,170 @@
+'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"); }); }; }
+
+function _toArray(arr) { return Array.isArray(arr) ? arr : Array.from(arr); }
+
+const Asset = require('../Asset');
+const postcss = require('postcss');
+const valueParser = require('postcss-value-parser');
+const postcssTransform = require('../transforms/postcss');
+const CssSyntaxError = require('postcss/lib/css-syntax-error');
+
+const URL_RE = /url\s*\("?(?![a-z]+:)/;
+const IMPORT_RE = /@import/;
+const PROTOCOL_RE = /^[a-z]+:/;
+
+class CSSAsset extends Asset {
+  constructor(name, pkg, options) {
+    super(name, pkg, options);
+    this.type = 'css';
+  }
+
+  mightHaveDependencies() {
+    return !/\.css$/.test(this.name) || IMPORT_RE.test(this.contents) || URL_RE.test(this.contents);
+  }
+
+  parse(code) {
+    let root = postcss.parse(code, { from: this.name, to: this.name });
+    return new CSSAst(code, root);
+  }
+
+  collectDependencies() {
+    this.ast.root.walkAtRules('import', rule => {
+      let params = valueParser(rule.params).nodes;
+
+      var _params = _toArray(params);
+
+      let name = _params[0],
+          media = _params.slice(1);
+
+      let dep;
+      if (name.type === 'string') {
+        dep = name.value;
+      } else if (name.type === 'function' && name.value === 'url' && name.nodes.length) {
+        dep = name.nodes[0].value;
+      }
+
+      if (!dep) {
+        throw new Error('Could not find import name for ' + rule);
+      }
+
+      if (PROTOCOL_RE.test(dep)) {
+        return;
+      }
+
+      media = valueParser.stringify(media).trim();
+      this.addDependency(dep, { media, loc: rule.source.start });
+
+      rule.remove();
+      this.ast.dirty = true;
+    });
+
+    this.ast.root.walkDecls(decl => {
+      if (URL_RE.test(decl.value)) {
+        let parsed = valueParser(decl.value);
+        let dirty = false;
+
+        parsed.walk(node => {
+          if (node.type === 'function' && node.value === 'url' && node.nodes.length) {
+            let url = this.addURLDependency(node.nodes[0].value, {
+              loc: decl.source.start
+            });
+            dirty = node.nodes[0].value !== url;
+            node.nodes[0].value = url;
+          }
+        });
+
+        if (dirty) {
+          decl.value = parsed.toString();
+          this.ast.dirty = true;
+        }
+      }
+    });
+  }
+
+  transform() {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      yield postcssTransform(_this);
+    })();
+  }
+
+  getCSSAst() {
+    // Converts the ast to a CSS ast if needed, so we can apply postcss transforms.
+    if (!(this.ast instanceof CSSAst)) {
+      this.ast = CSSAsset.prototype.parse.call(this, this.ast.render());
+    }
+
+    return this.ast.root;
+  }
+
+  generate() {
+    let css = this.ast ? this.ast.render() : this.contents;
+
+    let js = '';
+    if (this.options.hmr) {
+      this.addDependency('_css_loader');
+
+      js = `
+        var reloadCSS = require('_css_loader');
+        module.hot.dispose(reloadCSS);
+        module.hot.accept(reloadCSS);
+      `;
+    }
+
+    if (this.cssModules) {
+      js += 'module.exports = ' + JSON.stringify(this.cssModules, false, 2) + ';';
+    }
+
+    return [{
+      type: 'css',
+      value: css,
+      cssModules: this.cssModules
+    }, {
+      type: 'js',
+      value: js,
+      final: true
+    }];
+  }
+
+  generateErrorMessage(err) {
+    // Wrap the error in a CssSyntaxError if needed so we can generate a code frame
+    if (err.loc && !err.showSourceCode) {
+      err = new CssSyntaxError(err.message, err.loc.line, err.loc.column, this.contents);
+    }
+
+    err.message = err.reason || err.message;
+    err.loc = {
+      line: err.line,
+      column: err.column
+    };
+
+    if (err.showSourceCode) {
+      err.codeFrame = err.showSourceCode();
+      err.highlightedCodeFrame = err.showSourceCode(true);
+    }
+
+    return err;
+  }
+}
+
+class CSSAst {
+  constructor(css, root) {
+    this.css = css;
+    this.root = root;
+    this.dirty = false;
+  }
+
+  render() {
+    if (this.dirty) {
+      this.css = '';
+      postcss.stringify(this.root, c => this.css += c);
+    }
+
+    return this.css;
+  }
+}
+
+module.exports = CSSAsset;

VISUALIZACION/node_modules/parcel-bundler/lib/assets/CoffeeScriptAsset.js

@@ -0,0 +1,42 @@
+'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 Asset = require('../Asset');
+const localRequire = require('../utils/localRequire');
+
+class CoffeeScriptAsset extends Asset {
+  constructor(name, pkg, options) {
+    super(name, pkg, options);
+    this.type = 'js';
+  }
+
+  generate() {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      // require coffeescript, installed locally in the app
+      let coffee = yield localRequire('coffeescript', _this.name);
+
+      // Transpile Module using CoffeeScript and parse result as ast format through babylon
+      let transpiled = coffee.compile(_this.contents, {
+        sourceMap: _this.options.sourceMaps
+      });
+
+      let sourceMap;
+      if (transpiled.sourceMap) {
+        sourceMap = transpiled.sourceMap.generate();
+        sourceMap.sources = [_this.relativeName];
+        sourceMap.sourcesContent = [_this.contents];
+      }
+
+      return [{
+        type: 'js',
+        value: _this.options.sourceMaps ? transpiled.js : transpiled,
+        sourceMap
+      }];
+    })();
+  }
+}
+
+module.exports = CoffeeScriptAsset;

VISUALIZACION/node_modules/parcel-bundler/lib/assets/GLSLAsset.js

@@ -0,0 +1,98 @@
+'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 Asset = require('../Asset');
+const localRequire = require('../utils/localRequire');
+const path = require('path');
+const promisify = require('../utils/promisify');
+const Resolver = require('../Resolver');
+
+class GLSLAsset extends Asset {
+  constructor(name, pkg, options) {
+    super(name, pkg, options);
+    this.type = 'js';
+  }
+
+  parse() {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      const glslifyDeps = yield localRequire('glslify-deps', _this.name);
+
+      // Use the Parcel resolver rather than the default glslify one.
+      // This adds support for parcel features like alises, and tilde paths.
+      const resolver = new Resolver({
+        extensions: ['.glsl', '.vert', '.frag'],
+        rootDir: _this.options.rootDir
+      });
+
+      // Parse and collect dependencies with glslify-deps
+      let cwd = path.dirname(_this.name);
+      let depper = glslifyDeps({
+        cwd,
+        resolve: (() => {
+          var _ref = _asyncToGenerator(function* (target, opts, next) {
+            try {
+              let res = yield resolver.resolve(target, path.join(opts.basedir, 'index'));
+              next(null, res.path);
+            } catch (err) {
+              next(err);
+            }
+          });
+
+          return function resolve(_x, _x2, _x3) {
+            return _ref.apply(this, arguments);
+          };
+        })()
+      });
+
+      return yield promisify(depper.inline.bind(depper))(_this.contents, cwd);
+    })();
+  }
+
+  collectDependencies() {
+    var _iteratorNormalCompletion = true;
+    var _didIteratorError = false;
+    var _iteratorError = undefined;
+
+    try {
+      for (var _iterator = this.ast[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        let dep = _step.value;
+
+        if (!dep.entry) {
+          this.addDependency(dep.file, { includedInParent: true });
+        }
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+  }
+
+  generate() {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      // Generate the bundled glsl file
+      const glslifyBundle = yield localRequire('glslify-bundle', _this2.name);
+      let glsl = glslifyBundle(_this2.ast);
+
+      return {
+        js: `module.exports=${JSON.stringify(glsl)};`
+      };
+    })();
+  }
+}
+
+module.exports = GLSLAsset;

VISUALIZACION/node_modules/parcel-bundler/lib/assets/GlobAsset.js

@@ -0,0 +1,107 @@
+'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 Asset = require('../Asset');
+const glob = require('glob');
+const micromatch = require('micromatch');
+const path = require('path');
+
+class GlobAsset extends Asset {
+  constructor(name, pkg, options) {
+    super(name, pkg, options);
+    this.type = null; // allows this asset to be included in any type bundle
+  }
+
+  load() {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      let regularExpressionSafeName = _this.name;
+      if (process.platform === 'win32') regularExpressionSafeName = regularExpressionSafeName.replace(/\\/g, '/');
+
+      let files = glob.sync(regularExpressionSafeName, {
+        strict: true,
+        nodir: true
+      });
+      let re = micromatch.makeRe(regularExpressionSafeName, { capture: true });
+      let matches = {};
+
+      var _iteratorNormalCompletion = true;
+      var _didIteratorError = false;
+      var _iteratorError = undefined;
+
+      try {
+        for (var _iterator = files[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          let file = _step.value;
+
+          let match = file.match(re);
+          let parts = match.slice(1).filter(Boolean).reduce(function (a, p) {
+            return a.concat(p.split('/'));
+          }, []);
+          let relative = './' + path.relative(path.dirname(_this.name), file.normalize('NFC'));
+          set(matches, parts, relative);
+          _this.addDependency(relative);
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+
+      return matches;
+    })();
+  }
+
+  generate() {
+    return {
+      js: 'module.exports = ' + generate(this.contents) + ';'
+    };
+  }
+}
+
+function generate(matches, indent = '') {
+  if (typeof matches === 'string') {
+    return `require(${JSON.stringify(matches)})`;
+  }
+
+  let res = indent + '{';
+
+  let first = true;
+  for (let key in matches) {
+    if (!first) {
+      res += ',';
+    }
+
+    res += `\n${indent}  ${JSON.stringify(key)}: ${generate(matches[key], indent + '  ')}`;
+    first = false;
+  }
+
+  res += '\n' + indent + '}';
+  return res;
+}
+
+function set(obj, path, value) {
+  for (let i = 0; i < path.length - 1; i++) {
+    let part = path[i];
+
+    if (obj[part] == null) {
+      obj[part] = {};
+    }
+
+    obj = obj[part];
+  }
+
+  obj[path[path.length - 1]] = value;
+}
+
+module.exports = GlobAsset;

VISUALIZACION/node_modules/parcel-bundler/lib/assets/GraphqlAsset.js

@@ -0,0 +1,30 @@
+'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 Asset = require('../Asset');
+const localRequire = require('../utils/localRequire');
+
+class GraphqlAsset extends Asset {
+  constructor(name, pkg, options) {
+    super(name, pkg, options);
+    this.type = 'js';
+  }
+
+  parse(code) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      let gql = yield localRequire('graphql-tag', _this.name);
+      return gql(code);
+    })();
+  }
+
+  generate() {
+    return {
+      js: `module.exports=${JSON.stringify(this.ast, false, 2)};`
+    };
+  }
+}
+
+module.exports = GraphqlAsset;

VISUALIZACION/node_modules/parcel-bundler/lib/assets/HTMLAsset.js

@@ -0,0 +1,165 @@
+'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 Asset = require('../Asset');
+const parse = require('posthtml-parser');
+const api = require('posthtml/lib/api');
+const urlJoin = require('../utils/urlJoin');
+const render = require('posthtml-render');
+const posthtmlTransform = require('../transforms/posthtml');
+const htmlnanoTransform = require('../transforms/htmlnano');
+const isURL = require('../utils/is-url');
+
+// A list of all attributes that may produce a dependency
+// Based on https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes
+const ATTRS = {
+  src: ['script', 'img', 'audio', 'video', 'source', 'track', 'iframe', 'embed'],
+  href: ['link', 'a', 'use'],
+  srcset: ['img', 'source'],
+  poster: ['video'],
+  'xlink:href': ['use'],
+  content: ['meta'],
+  data: ['object']
+};
+
+// A list of metadata that should produce a dependency
+// Based on:
+// - http://schema.org/
+// - http://ogp.me
+// - https://developer.twitter.com/en/docs/tweets/optimize-with-cards/overview/markup
+// - https://msdn.microsoft.com/en-us/library/dn255024.aspx
+const META = {
+  property: ['og:image', 'og:image:url', 'og:image:secure_url', 'og:audio', 'og:audio:secure_url', 'og:video', 'og:video:secure_url'],
+  name: ['twitter:image', 'msapplication-square150x150logo', 'msapplication-square310x310logo', 'msapplication-square70x70logo', 'msapplication-wide310x150logo', 'msapplication-TileImage'],
+  itemprop: ['image', 'logo', 'screenshot', 'thumbnailUrl', 'contentUrl', 'downloadUrl']
+};
+
+// Options to be passed to `addURLDependency` for certain tags + attributes
+const OPTIONS = {
+  a: {
+    href: { entry: true }
+  },
+  iframe: {
+    src: { entry: true }
+  }
+};
+
+class HTMLAsset extends Asset {
+  constructor(name, pkg, options) {
+    super(name, pkg, options);
+    this.type = 'html';
+    this.isAstDirty = false;
+  }
+
+  parse(code) {
+    let res = parse(code, { lowerCaseAttributeNames: true });
+    res.walk = api.walk;
+    res.match = api.match;
+    return res;
+  }
+
+  processSingleDependency(path, opts) {
+    let assetPath = this.addURLDependency(path, opts);
+    if (!isURL(assetPath)) {
+      assetPath = urlJoin(this.options.publicURL, assetPath);
+    }
+    return assetPath;
+  }
+
+  collectSrcSetDependencies(srcset, opts) {
+    const newSources = [];
+    var _iteratorNormalCompletion = true;
+    var _didIteratorError = false;
+    var _iteratorError = undefined;
+
+    try {
+      for (var _iterator = srcset.split(',')[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        const source = _step.value;
+
+        const pair = source.trim().split(' ');
+        if (pair.length === 0) continue;
+        pair[0] = this.processSingleDependency(pair[0], opts);
+        newSources.push(pair.join(' '));
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+
+    return newSources.join(',');
+  }
+
+  getAttrDepHandler(attr) {
+    if (attr === 'srcset') {
+      return this.collectSrcSetDependencies;
+    }
+    return this.processSingleDependency;
+  }
+
+  collectDependencies() {
+    this.ast.walk(node => {
+      if (node.attrs) {
+        if (node.tag === 'meta') {
+          if (!Object.keys(node.attrs).some(attr => {
+            let values = META[attr];
+            return values && values.includes(node.attrs[attr]);
+          })) {
+            return node;
+          }
+        }
+
+        for (let attr in node.attrs) {
+          let elements = ATTRS[attr];
+          // Check for virtual paths
+          if (node.tag === 'a' && node.attrs[attr].lastIndexOf('.') < 1) {
+            continue;
+          }
+
+          if (elements && elements.includes(node.tag)) {
+            let depHandler = this.getAttrDepHandler(attr);
+            let options = OPTIONS[node.tag];
+            node.attrs[attr] = depHandler.call(this, node.attrs[attr], options && options[attr]);
+            this.isAstDirty = true;
+          }
+        }
+      }
+
+      return node;
+    });
+  }
+
+  pretransform() {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      yield posthtmlTransform(_this);
+    })();
+  }
+
+  transform() {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      if (_this2.options.minify) {
+        yield htmlnanoTransform(_this2);
+      }
+    })();
+  }
+
+  generate() {
+    return this.isAstDirty ? render(this.ast) : this.contents;
+  }
+}
+
+module.exports = HTMLAsset;

VISUALIZACION/node_modules/parcel-bundler/lib/assets/JSAsset.js

@@ -0,0 +1,209 @@
+'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"); }); }; }
+
+var _require = require('babel-core');
+
+const BabelFile = _require.File;
+
+const traverse = require('babel-traverse').default;
+const codeFrame = require('babel-code-frame');
+const collectDependencies = require('../visitors/dependencies');
+const walk = require('babylon-walk');
+const Asset = require('../Asset');
+const babylon = require('babylon');
+const insertGlobals = require('../visitors/globals');
+const fsVisitor = require('../visitors/fs');
+const envVisitor = require('../visitors/env');
+const babel = require('../transforms/babel');
+const generate = require('babel-generator').default;
+const uglify = require('../transforms/uglify');
+const SourceMap = require('../SourceMap');
+
+const IMPORT_RE = /\b(?:import\b|export\b|require\s*\()/;
+const ENV_RE = /\b(?:process\.env)\b/;
+const GLOBAL_RE = /\b(?:process|__dirname|__filename|global|Buffer|define)\b/;
+const FS_RE = /\breadFileSync\b/;
+const SW_RE = /\bnavigator\s*\.\s*serviceWorker\s*\.\s*register\s*\(/;
+const WORKER_RE = /\bnew\s*Worker\s*\(/;
+
+class JSAsset extends Asset {
+  constructor(name, pkg, options) {
+    super(name, pkg, options);
+    this.type = 'js';
+    this.globals = new Map();
+    this.isAstDirty = false;
+    this.isES6Module = false;
+    this.outputCode = null;
+    this.cacheData.env = {};
+    this.sourceMap = options.rendition ? options.rendition.sourceMap : null;
+  }
+
+  shouldInvalidate(cacheData) {
+    for (let key in cacheData.env) {
+      if (cacheData.env[key] !== process.env[key]) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  mightHaveDependencies() {
+    return this.isAstDirty || !/.js$/.test(this.name) || IMPORT_RE.test(this.contents) || GLOBAL_RE.test(this.contents) || SW_RE.test(this.contents) || WORKER_RE.test(this.contents);
+  }
+
+  getParserOptions() {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      // Babylon options. We enable a few plugins by default.
+      const options = {
+        filename: _this.name,
+        allowReturnOutsideFunction: true,
+        allowHashBang: true,
+        ecmaVersion: Infinity,
+        strictMode: false,
+        sourceType: 'module',
+        locations: true,
+        plugins: ['exportExtensions', 'dynamicImport']
+      };
+
+      // Check if there is a babel config file. If so, determine which parser plugins to enable
+      _this.babelConfig = yield babel.getConfig(_this);
+      if (_this.babelConfig) {
+        const file = new BabelFile(_this.babelConfig);
+        options.plugins.push(...file.parserOpts.plugins);
+      }
+
+      return options;
+    })();
+  }
+
+  parse(code) {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      const options = yield _this2.getParserOptions();
+      return babylon.parse(code, options);
+    })();
+  }
+
+  traverse(visitor) {
+    return traverse(this.ast, visitor, null, this);
+  }
+
+  traverseFast(visitor) {
+    return walk.simple(this.ast, visitor, this);
+  }
+
+  collectDependencies() {
+    walk.ancestor(this.ast, collectDependencies, this);
+  }
+
+  pretransform() {
+    var _this3 = this;
+
+    return _asyncToGenerator(function* () {
+      yield babel(_this3);
+
+      // Inline environment variables
+      if (ENV_RE.test(_this3.contents)) {
+        yield _this3.parseIfNeeded();
+        _this3.traverseFast(envVisitor);
+      }
+    })();
+  }
+
+  transform() {
+    var _this4 = this;
+
+    return _asyncToGenerator(function* () {
+      if (_this4.options.target === 'browser') {
+        if (_this4.dependencies.has('fs') && FS_RE.test(_this4.contents)) {
+          yield _this4.parseIfNeeded();
+          _this4.traverse(fsVisitor);
+        }
+
+        if (GLOBAL_RE.test(_this4.contents)) {
+          yield _this4.parseIfNeeded();
+          walk.ancestor(_this4.ast, insertGlobals, _this4);
+        }
+      }
+
+      if (_this4.isES6Module) {
+        yield babel(_this4);
+      }
+
+      if (_this4.options.minify) {
+        yield uglify(_this4);
+      }
+    })();
+  }
+
+  generate() {
+    var _this5 = this;
+
+    return _asyncToGenerator(function* () {
+      let code;
+      if (_this5.isAstDirty) {
+        let opts = {
+          sourceMaps: _this5.options.sourceMaps,
+          sourceFileName: _this5.relativeName
+        };
+
+        let generated = generate(_this5.ast, opts, _this5.contents);
+
+        if (_this5.options.sourceMaps && generated.rawMappings) {
+          let rawMap = new SourceMap(generated.rawMappings, {
+            [_this5.relativeName]: _this5.contents
+          });
+
+          // Check if we already have a source map (e.g. from TypeScript or CoffeeScript)
+          // In that case, we need to map the original source map to the babel generated one.
+          if (_this5.sourceMap) {
+            _this5.sourceMap = yield new SourceMap().extendSourceMap(_this5.sourceMap, rawMap);
+          } else {
+            _this5.sourceMap = rawMap;
+          }
+        }
+
+        code = generated.code;
+      } else {
+        code = _this5.outputCode || _this5.contents;
+      }
+
+      if (_this5.options.sourceMaps && !_this5.sourceMap) {
+        _this5.sourceMap = new SourceMap().generateEmptyMap(_this5.relativeName, _this5.contents);
+      }
+
+      if (_this5.globals.size > 0) {
+        code = Array.from(_this5.globals.values()).join('\n') + '\n' + code;
+        if (_this5.options.sourceMaps) {
+          if (!(_this5.sourceMap instanceof SourceMap)) {
+            _this5.sourceMap = yield new SourceMap().addMap(_this5.sourceMap);
+          }
+
+          _this5.sourceMap.offset(_this5.globals.size);
+        }
+      }
+
+      return {
+        js: code,
+        map: _this5.sourceMap
+      };
+    })();
+  }
+
+  generateErrorMessage(err) {
+    const loc = err.loc;
+    if (loc) {
+      err.codeFrame = codeFrame(this.contents, loc.line, loc.column + 1);
+      err.highlightedCodeFrame = codeFrame(this.contents, loc.line, loc.column + 1, { highlightCode: true });
+    }
+
+    return err;
+  }
+}
+
+module.exports = JSAsset;

VISUALIZACION/node_modules/parcel-bundler/lib/assets/JSONAsset.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const Asset = require('../Asset');
+const path = require('path');
+const json5 = require('json5');
+
+var _require = require('uglify-es');
+
+const minify = _require.minify;
+
+
+class JSONAsset extends Asset {
+  constructor(name, pkg, options) {
+    super(name, pkg, options);
+    this.type = 'js';
+  }
+
+  parse(code) {
+    return path.extname(this.name) === '.json5' ? json5.parse(code) : null;
+  }
+
+  generate() {
+    let code = `module.exports = ${this.ast ? JSON.stringify(this.ast, null, 2) : this.contents};`;
+
+    if (this.options.minify) {
+      let minified = minify(code);
+      if (minified.error) {
+        throw minified.error;
+      }
+
+      code = minified.code;
+    }
+
+    return {
+      js: code
+    };
+  }
+}
+
+module.exports = JSONAsset;

VISUALIZACION/node_modules/parcel-bundler/lib/assets/LESSAsset.js

@@ -0,0 +1,83 @@
+'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 Asset = require('../Asset');
+const localRequire = require('../utils/localRequire');
+const promisify = require('../utils/promisify');
+
+class LESSAsset extends Asset {
+  constructor(name, pkg, options) {
+    super(name, pkg, options);
+    this.type = 'css';
+  }
+
+  parse(code) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      // less should be installed locally in the module that's being required
+      let less = yield localRequire('less', _this.name);
+      let render = promisify(less.render.bind(less));
+
+      let opts = Object.assign({}, _this.package.less || (yield _this.getConfig(['.lessrc', '.lessrc.js'])));
+      opts.filename = _this.name;
+      opts.plugins = (opts.plugins || []).concat(urlPlugin(_this));
+
+      return yield render(code, opts);
+    })();
+  }
+
+  collectDependencies() {
+    var _iteratorNormalCompletion = true;
+    var _didIteratorError = false;
+    var _iteratorError = undefined;
+
+    try {
+      for (var _iterator = this.ast.imports[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        let dep = _step.value;
+
+        this.addDependency(dep, { includedInParent: true });
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+  }
+
+  generate() {
+    return [{
+      type: 'css',
+      value: this.ast ? this.ast.css : '',
+      hasDependencies: false
+    }];
+  }
+}
+
+function urlPlugin(asset) {
+  return {
+    install: (less, pluginManager) => {
+      let visitor = new less.visitors.Visitor({
+        visitUrl: node => {
+          node.value.value = asset.addURLDependency(node.value.value, node.currentFileInfo.filename);
+          return node;
+        }
+      });
+
+      visitor.run = visitor.visit;
+      pluginManager.addVisitor(visitor);
+    }
+  };
+}
+
+module.exports = LESSAsset;

VISUALIZACION/node_modules/parcel-bundler/lib/assets/PugAsset.js

@@ -0,0 +1,67 @@
+'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 Asset = require('../Asset');
+const localRequire = require('../utils/localRequire');
+
+class PugAsset extends Asset {
+  constructor(name, pkg, options) {
+    super(name, pkg, options);
+    this.type = 'html';
+  }
+
+  generate() {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      const pug = yield localRequire('pug', _this.name);
+      const config = (yield _this.getConfig(['.pugrc', '.pugrc.js', 'pug.config.js'])) || {};
+
+      const compiled = pug.compile(_this.contents, {
+        compileDebug: false,
+        filename: _this.name,
+        basedir: path.dirname(_this.name),
+        pretty: !_this.options.minify,
+        templateName: path.basename(_this.basename, path.extname(_this.basename)),
+        filters: config.filters,
+        filterOptions: config.filterOptions,
+        filterAliases: config.filterAliases
+      });
+
+      if (compiled.dependencies) {
+        var _iteratorNormalCompletion = true;
+        var _didIteratorError = false;
+        var _iteratorError = undefined;
+
+        try {
+          for (var _iterator = compiled.dependencies[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            let item = _step.value;
+
+            _this.addDependency(item, {
+              includedInParent: true
+            });
+          }
+        } catch (err) {
+          _didIteratorError = true;
+          _iteratorError = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return) {
+              _iterator.return();
+            }
+          } finally {
+            if (_didIteratorError) {
+              throw _iteratorError;
+            }
+          }
+        }
+      }
+
+      return compiled();
+    })();
+  }
+}
+
+module.exports = PugAsset;

VISUALIZACION/node_modules/parcel-bundler/lib/assets/RawAsset.js

@@ -0,0 +1,36 @@
+'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 Asset = require('../Asset');
+const urlJoin = require('../utils/urlJoin');
+const md5 = require('../utils/md5');
+
+class RawAsset extends Asset {
+  // Don't load raw assets. They will be copied by the RawPackager directly.
+  load() {}
+
+  generate() {
+    // Don't return a URL to the JS bundle if there is a bundle loader defined for this asset type.
+    // This will cause the actual asset to be automatically preloaded prior to the JS bundle running.
+    if (this.options.bundleLoaders[this.type]) {
+      return {};
+    }
+
+    const pathToAsset = urlJoin(this.options.publicURL, this.generateBundleName());
+
+    return {
+      js: `module.exports=${JSON.stringify(pathToAsset)};`
+    };
+  }
+
+  generateHash() {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      return yield md5.file(_this.name);
+    })();
+  }
+}
+
+module.exports = RawAsset;

VISUALIZACION/node_modules/parcel-bundler/lib/assets/ReasonAsset.js

@@ -0,0 +1,38 @@
+'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 Asset = require('../Asset');
+const fs = require('../utils/fs');
+const localRequire = require('../utils/localRequire');
+
+class ReasonAsset extends Asset {
+  constructor(name, pkg, options) {
+    super(name, pkg, options);
+    this.type = 'js';
+  }
+
+  generate() {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      const bsb = yield localRequire('bsb-js', _this.name);
+
+      // This runs BuckleScript - the Reason to JS compiler.
+      // Other Asset types use `localRequire` but the `bsb-js` package already
+      // does that internally. This should also take care of error handling in
+      // the Reason compilation process.
+      if (process.env.NODE_ENV !== 'test') {
+        yield bsb.runBuild();
+      }
+
+      // This is a simplified use-case for Reason - it only loads the recommended
+      // BuckleScript configuration to simplify the file processing.
+      const outputFile = _this.name.replace(/\.(re|ml)$/, '.bs.js');
+      const outputContent = yield fs.readFile(outputFile);
+      return outputContent.toString();
+    })();
+  }
+}
+
+module.exports = ReasonAsset;

VISUALIZACION/node_modules/parcel-bundler/lib/assets/RustAsset.js

@@ -0,0 +1,245 @@
+'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 path = require('path');
+const commandExists = require('command-exists');
+const childProcess = require('child_process');
+const promisify = require('../utils/promisify');
+const exec = promisify(childProcess.execFile);
+const tomlify = require('tomlify-j0.4');
+const fs = require('../utils/fs');
+const Asset = require('../Asset');
+const config = require('../utils/config');
+const pipeSpawn = require('../utils/pipeSpawn');
+const md5 = require('../utils/md5');
+
+const RUST_TARGET = 'wasm32-unknown-unknown';
+const MAIN_FILES = ['src/lib.rs', 'src/main.rs'];
+
+// Track installation status so we don't need to check more than once
+let rustInstalled = false;
+let wasmGCInstalled = false;
+
+class RustAsset extends Asset {
+  constructor(name, pkg, options) {
+    super(name, pkg, options);
+    this.type = 'wasm';
+  }
+
+  process() {
+    // We don't want to process this asset if the worker is in a warm up phase
+    // since the asset will also be processed by the main process, which
+    // may cause errors since rust writes to the filesystem.
+    if (this.options.isWarmUp) {
+      return;
+    }
+
+    return super.process();
+  }
+
+  parse() {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      // Install rust toolchain and target if needed
+      yield _this.installRust();
+
+      // See if there is a Cargo config in the project
+      let cargoConfig = yield _this.getConfig(['Cargo.toml']);
+      let cargoDir;
+      let isMainFile = false;
+
+      if (cargoConfig) {
+        const mainFiles = MAIN_FILES.slice();
+        if (cargoConfig.lib && cargoConfig.lib.path) {
+          mainFiles.push(cargoConfig.lib.path);
+        }
+
+        cargoDir = path.dirname((yield config.resolve(_this.name, ['Cargo.toml'])));
+        isMainFile = mainFiles.some(function (file) {
+          return path.join(cargoDir, file) === _this.name;
+        });
+      }
+
+      // If this is the main file of a Cargo build, use the cargo command to compile.
+      // Otherwise, use rustc directly.
+      if (isMainFile) {
+        yield _this.cargoBuild(cargoConfig, cargoDir);
+      } else {
+        yield _this.rustcBuild();
+      }
+
+      // If this is a prod build, use wasm-gc to remove unused code
+      if (_this.options.minify) {
+        yield _this.installWasmGC();
+        yield exec('wasm-gc', [_this.wasmPath, _this.wasmPath]);
+      }
+    })();
+  }
+
+  installRust() {
+    return _asyncToGenerator(function* () {
+      if (rustInstalled) {
+        return;
+      }
+
+      // Check for rustup
+      try {
+        yield commandExists('rustup');
+      } catch (e) {
+        throw new Error("Rust isn't installed. Visit https://www.rustup.rs/ for more info");
+      }
+
+      // Ensure nightly toolchain is installed
+
+      var _ref = yield exec('rustup', ['show']),
+          _ref2 = _slicedToArray(_ref, 1);
+
+      let stdout = _ref2[0];
+
+      if (!stdout.includes('nightly')) {
+        yield pipeSpawn('rustup', ['update']);
+        yield pipeSpawn('rustup', ['toolchain', 'install', 'nightly']);
+      }
+
+      // Ensure wasm target is installed
+
+      var _ref3 = yield exec('rustup', ['target', 'list', '--toolchain', 'nightly']);
+
+      var _ref4 = _slicedToArray(_ref3, 1);
+
+      stdout = _ref4[0];
+
+      if (!stdout.includes(RUST_TARGET + ' (installed)')) {
+        yield pipeSpawn('rustup', ['target', 'add', RUST_TARGET, '--toolchain', 'nightly']);
+      }
+
+      rustInstalled = true;
+    })();
+  }
+
+  installWasmGC() {
+    return _asyncToGenerator(function* () {
+      if (wasmGCInstalled) {
+        return;
+      }
+
+      try {
+        yield commandExists('wasm-gc');
+      } catch (e) {
+        yield pipeSpawn('cargo', ['install', '--git', 'https://github.com/alexcrichton/wasm-gc']);
+      }
+
+      wasmGCInstalled = true;
+    })();
+  }
+
+  cargoBuild(cargoConfig, cargoDir) {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      // Ensure the cargo config has cdylib as the crate-type
+      if (!cargoConfig.lib) {
+        cargoConfig.lib = {};
+      }
+
+      if (!Array.isArray(cargoConfig.lib['crate-type'])) {
+        cargoConfig.lib['crate-type'] = [];
+      }
+
+      if (!cargoConfig.lib['crate-type'].includes('cdylib')) {
+        cargoConfig.lib['crate-type'].push('cdylib');
+        yield fs.writeFile(path.join(cargoDir, 'Cargo.toml'), tomlify.toToml(cargoConfig));
+      }
+
+      // Run cargo
+      let args = ['+nightly', 'build', '--target', RUST_TARGET, '--release'];
+      yield exec('cargo', args, { cwd: cargoDir });
+
+      // Get output file paths
+      let outDir = path.join(cargoDir, 'target', RUST_TARGET, 'release');
+
+      // Rust converts '-' to '_' when outputting files.
+      let rustName = cargoConfig.package.name.replace(/-/g, '_');
+      _this2.wasmPath = path.join(outDir, rustName + '.wasm');
+      _this2.depsPath = path.join(outDir, rustName + '.d');
+    })();
+  }
+
+  rustcBuild() {
+    var _this3 = this;
+
+    return _asyncToGenerator(function* () {
+      // Get output filename
+      yield fs.mkdirp(_this3.options.cacheDir);
+      let name = md5(_this3.name);
+      _this3.wasmPath = path.join(_this3.options.cacheDir, name + '.wasm');
+
+      // Run rustc to compile the code
+      const args = ['+nightly', '--target', RUST_TARGET, '-O', '--crate-type=cdylib', _this3.name, '-o', _this3.wasmPath];
+      yield exec('rustc', args);
+
+      // Run again to collect dependencies
+      _this3.depsPath = path.join(_this3.options.cacheDir, name + '.d');
+      yield exec('rustc', [_this3.name, '--emit=dep-info', '-o', _this3.depsPath]);
+    })();
+  }
+
+  collectDependencies() {
+    var _this4 = this;
+
+    return _asyncToGenerator(function* () {
+      // Read deps file
+      let contents = yield fs.readFile(_this4.depsPath, 'utf8');
+      let dir = path.dirname(_this4.name);
+
+      let deps = contents.split('\n').filter(Boolean).slice(1);
+
+      var _iteratorNormalCompletion = true;
+      var _didIteratorError = false;
+      var _iteratorError = undefined;
+
+      try {
+        for (var _iterator = deps[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          let dep = _step.value;
+
+          dep = path.resolve(dir, dep.slice(0, dep.indexOf(':')));
+          if (dep !== _this4.name) {
+            _this4.addDependency(dep, { includedInParent: true });
+          }
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+    })();
+  }
+
+  generate() {
+    var _this5 = this;
+
+    return _asyncToGenerator(function* () {
+      return {
+        wasm: {
+          path: _this5.wasmPath, // pass output path to RawPackager
+          mtime: Date.now() // force re-bundling since otherwise the hash would never change
+        }
+      };
+    })();
+  }
+}
+
+module.exports = RustAsset;

VISUALIZACION/node_modules/parcel-bundler/lib/assets/SASSAsset.js

@@ -0,0 +1,95 @@
+'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 Asset = require('../Asset');
+const localRequire = require('../utils/localRequire');
+const promisify = require('../utils/promisify');
+const path = require('path');
+const os = require('os');
+const Resolver = require('../Resolver');
+const syncPromise = require('../utils/syncPromise');
+
+class SASSAsset extends Asset {
+  constructor(name, pkg, options) {
+    super(name, pkg, options);
+    this.type = 'css';
+  }
+
+  parse(code) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      // node-sass should be installed locally in the module that's being required
+      let sass = yield localRequire('node-sass', _this.name);
+      let render = promisify(sass.render.bind(sass));
+      const resolver = new Resolver({
+        extensions: ['.scss', '.sass'],
+        rootDir: _this.options.rootDir
+      });
+
+      let opts = Object.assign({}, _this.package.sass || (yield _this.getConfig(['.sassrc', '.sassrc.js'])));
+      opts.includePaths = (opts.includePaths || []).concat(path.dirname(_this.name));
+      opts.data = opts.data ? opts.data + os.EOL + code : code;
+      opts.indentedSyntax = typeof opts.indentedSyntax === 'boolean' ? opts.indentedSyntax : path.extname(_this.name).toLowerCase() === '.sass';
+
+      opts.functions = Object.assign({}, opts.functions, {
+        url: function url(node) {
+          let filename = _this.addURLDependency(node.getValue());
+          return new sass.types.String(`url(${JSON.stringify(filename)})`);
+        }
+      });
+
+      opts.importer = function (url, prev, done) {
+        let resolved;
+        try {
+          resolved = syncPromise(resolver.resolve(url, prev === 'stdin' ? _this.name : prev)).path;
+        } catch (e) {
+          resolved = url;
+        }
+        return done({
+          file: resolved
+        });
+      };
+
+      return yield render(opts);
+    })();
+  }
+
+  collectDependencies() {
+    var _iteratorNormalCompletion = true;
+    var _didIteratorError = false;
+    var _iteratorError = undefined;
+
+    try {
+      for (var _iterator = this.ast.stats.includedFiles[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        let dep = _step.value;
+
+        this.addDependency(dep, { includedInParent: true });
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+  }
+
+  generate() {
+    return [{
+      type: 'css',
+      value: this.ast ? this.ast.css.toString() : '',
+      hasDependencies: false
+    }];
+  }
+}
+
+module.exports = SASSAsset;

VISUALIZACION/node_modules/parcel-bundler/lib/assets/StylusAsset.js

@@ -0,0 +1,138 @@
+'use strict';
+
+let createEvaluator = (() => {
+  var _ref = _asyncToGenerator(function* (asset) {
+    const Evaluator = yield localRequire('stylus/lib/visitor/evaluator', asset.name);
+    const utils = yield localRequire('stylus/lib/utils', asset.name);
+    const resolver = new Resolver(Object.assign({}, asset.options, {
+      extensions: ['.styl', '.css']
+    }));
+
+    // This is a custom stylus evaluator that extends stylus with support for the node
+    // require resolution algorithm. It also adds all dependencies to the parcel asset
+    // tree so the file watcher works correctly, etc.
+    class CustomEvaluator extends Evaluator {
+      visitImport(imported) {
+        let node = this.visit(imported.path).first;
+        let path = node.string;
+        if (node.name !== 'url' && path && !URL_RE.test(path)) {
+          try {
+            // First try resolving using the node require resolution algorithm.
+            // This allows stylus files in node_modules to be resolved properly.
+            // If we find something, update the AST so stylus gets the absolute path to load later.
+            node.string = syncPromise(resolver.resolve(path, imported.filename)).path;
+            asset.addDependency(node.string, { includedInParent: true });
+          } catch (err) {
+            // If we couldn't resolve, try the normal stylus resolver.
+            // We just need to do this to keep track of the dependencies - stylus does the real work.
+
+            // support optional .styl
+            if (!/\.styl$/i.test(path)) {
+              path += '.styl';
+            }
+
+            let found = utils.find(path, this.paths, this.filename);
+            if (!found) {
+              found = utils.lookupIndex(node.string, this.paths, this.filename);
+            }
+
+            if (!found) {
+              let nodeName = imported.once ? 'require' : 'import';
+              throw new Error('failed to locate @' + nodeName + ' file ' + node.string);
+            }
+
+            var _iteratorNormalCompletion = true;
+            var _didIteratorError = false;
+            var _iteratorError = undefined;
+
+            try {
+              for (var _iterator = found[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                let file = _step.value;
+
+                asset.addDependency(file, { includedInParent: true });
+              }
+            } catch (err) {
+              _didIteratorError = true;
+              _iteratorError = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion && _iterator.return) {
+                  _iterator.return();
+                }
+              } finally {
+                if (_didIteratorError) {
+                  throw _iteratorError;
+                }
+              }
+            }
+          }
+        }
+
+        // Done. Let stylus do its thing.
+        return super.visitImport(imported);
+      }
+    }
+
+    return CustomEvaluator;
+  });
+
+  return function createEvaluator(_x) {
+    return _ref.apply(this, arguments);
+  };
+})();
+
+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 CSSAsset = require('./CSSAsset');
+const Asset = require('../Asset');
+const localRequire = require('../utils/localRequire');
+const Resolver = require('../Resolver');
+const syncPromise = require('../utils/syncPromise');
+
+const URL_RE = /^(?:url\s*\(\s*)?['"]?(?:[#/]|(?:https?:)?\/\/)/i;
+
+class StylusAsset extends Asset {
+  constructor(name, pkg, options) {
+    super(name, pkg, options);
+    this.type = 'css';
+  }
+
+  parse(code) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      // stylus should be installed locally in the module that's being required
+      let stylus = yield localRequire('stylus', _this.name);
+      let opts = _this.package.stylus || (yield _this.getConfig(['.stylusrc', '.stylusrc.js']));
+      let style = stylus(code, opts);
+      style.set('filename', _this.name);
+      style.set('include css', true);
+      style.set('Evaluator', (yield createEvaluator(_this)));
+
+      // Setup a handler for the URL function so we add dependencies for linked assets.
+      style.define('url', function (node) {
+        let filename = _this.addURLDependency(node.val, node.filename);
+        return new stylus.nodes.Literal(`url(${JSON.stringify(filename)})`);
+      });
+
+      return style;
+    })();
+  }
+
+  generate() {
+    return [{
+      type: 'css',
+      value: this.ast.render(),
+      hasDependencies: false
+    }];
+  }
+
+  generateErrorMessage(err) {
+    let index = err.message.indexOf('\n');
+    err.codeFrame = err.message.slice(index + 1);
+    err.message = err.message.slice(0, index);
+    return err;
+  }
+}
+
+module.exports = StylusAsset;

VISUALIZACION/node_modules/parcel-bundler/lib/assets/TOMLAsset.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const Asset = require('../Asset');
+const toml = require('toml');
+const serializeObject = require('../utils/serializeObject');
+
+class TOMLAsset extends Asset {
+  constructor(name, pkg, options) {
+    super(name, pkg, options);
+    this.type = 'js';
+  }
+
+  parse(code) {
+    return toml.parse(code);
+  }
+
+  generate() {
+    return {
+      js: serializeObject(this.ast, this.options.minify)
+    };
+  }
+}
+
+module.exports = TOMLAsset;

VISUALIZACION/node_modules/parcel-bundler/lib/assets/TypeScriptAsset.js

@@ -0,0 +1,64 @@
+'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 Asset = require('../Asset');
+const localRequire = require('../utils/localRequire');
+
+class TypeScriptAsset extends Asset {
+  constructor(name, pkg, options) {
+    super(name, pkg, options);
+    this.type = 'js';
+  }
+
+  generate() {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      // require typescript, installed locally in the app
+      let typescript = yield localRequire('typescript', _this.name);
+      let transpilerOptions = {
+        compilerOptions: {
+          module: typescript.ModuleKind.CommonJS,
+          jsx: typescript.JsxEmit.Preserve,
+
+          // it brings the generated output from TypeScript closer to that generated by Babel
+          // see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-7.html
+          esModuleInterop: true
+        },
+        fileName: _this.relativeName
+      };
+
+      let tsconfig = yield _this.getConfig(['tsconfig.json']);
+
+      // Overwrite default if config is found
+      if (tsconfig) {
+        transpilerOptions.compilerOptions = Object.assign(transpilerOptions.compilerOptions, tsconfig.compilerOptions);
+      }
+      transpilerOptions.compilerOptions.noEmit = false;
+      transpilerOptions.compilerOptions.sourceMap = _this.options.sourceMaps;
+
+      // Transpile Module using TypeScript and parse result as ast format through babylon
+      let transpiled = typescript.transpileModule(_this.contents, transpilerOptions);
+      let sourceMap = transpiled.sourceMapText;
+
+      if (sourceMap) {
+        sourceMap = JSON.parse(sourceMap);
+        sourceMap.sources = [_this.relativeName];
+        sourceMap.sourcesContent = [_this.contents];
+
+        // Remove the source map URL
+        let content = transpiled.outputText;
+        transpiled.outputText = content.substring(0, content.lastIndexOf('//# sourceMappingURL'));
+      }
+
+      return [{
+        type: 'js',
+        value: transpiled.outputText,
+        sourceMap
+      }];
+    })();
+  }
+}
+
+module.exports = TypeScriptAsset;

VISUALIZACION/node_modules/parcel-bundler/lib/assets/VueAsset.js

@@ -0,0 +1,309 @@
+'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 Asset = require('../Asset');
+const localRequire = require('../utils/localRequire');
+const md5 = require('../utils/md5');
+
+var _require = require('uglify-es');
+
+const minify = _require.minify;
+
+
+class VueAsset extends Asset {
+  constructor(name, pkg, options) {
+    super(name, pkg, options);
+    this.type = 'js';
+  }
+
+  parse(code) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      // Is being used in component-compiler-utils, errors if not installed...
+      _this.vueTemplateCompiler = yield localRequire('vue-template-compiler', _this.name);
+      _this.vue = yield localRequire('@vue/component-compiler-utils', _this.name);
+
+      return _this.vue.parse({
+        source: code,
+        needMap: _this.options.sourceMaps,
+        filename: _this.relativeName, // Used for sourcemaps
+        sourceRoot: '' // Used for sourcemaps. Override so it doesn't use cwd
+      });
+    })();
+  }
+
+  generate() {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      let descriptor = _this2.ast;
+      let parts = [];
+
+      if (descriptor.script) {
+        parts.push({
+          type: descriptor.script.lang || 'js',
+          value: descriptor.script.content,
+          sourceMap: descriptor.script.map
+        });
+      }
+
+      if (descriptor.template) {
+        parts.push({
+          type: descriptor.template.lang || 'html',
+          value: descriptor.template.content.trim()
+        });
+      }
+
+      if (descriptor.styles) {
+        var _iteratorNormalCompletion = true;
+        var _didIteratorError = false;
+        var _iteratorError = undefined;
+
+        try {
+          for (var _iterator = descriptor.styles[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            let style = _step.value;
+
+            parts.push({
+              type: style.lang || 'css',
+              value: style.content.trim(),
+              modules: !!style.module
+            });
+          }
+        } catch (err) {
+          _didIteratorError = true;
+          _iteratorError = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return) {
+              _iterator.return();
+            }
+          } finally {
+            if (_didIteratorError) {
+              throw _iteratorError;
+            }
+          }
+        }
+      }
+
+      return parts;
+    })();
+  }
+
+  postProcess(generated) {
+    var _this3 = this;
+
+    return _asyncToGenerator(function* () {
+      let result = [];
+
+      let hasScoped = _this3.ast.styles.some(function (s) {
+        return s.scoped;
+      });
+      let id = md5(_this3.name).slice(-6);
+      let scopeId = hasScoped ? `data-v-${id}` : null;
+      let optsVar = '$' + id;
+
+      // Generate JS output.
+      let js = _this3.ast.script ? generated[0].value : '';
+      let supplemental = `
+      var ${optsVar} = exports.default || module.exports;
+      if (typeof ${optsVar} === 'function') {
+        ${optsVar} = ${optsVar}.options;
+      }
+    `;
+
+      supplemental += _this3.compileTemplate(generated, scopeId, optsVar);
+      supplemental += _this3.compileCSSModules(generated, optsVar);
+      supplemental += _this3.compileHMR(generated, optsVar);
+
+      if (_this3.options.minify && supplemental) {
+        var _minify = minify(supplemental, { toplevel: true });
+
+        let code = _minify.code,
+            error = _minify.error;
+
+        if (error) {
+          throw error;
+        }
+
+        supplemental = code;
+      }
+
+      js += supplemental;
+
+      if (js) {
+        result.push({
+          type: 'js',
+          value: js
+        });
+      }
+
+      let map = generated.find(function (r) {
+        return r.type === 'map';
+      });
+      if (map) {
+        result.push(map);
+      }
+
+      let css = _this3.compileStyle(generated, scopeId);
+      if (css) {
+        result.push({
+          type: 'css',
+          value: css
+        });
+      }
+
+      return result;
+    })();
+  }
+
+  compileTemplate(generated, scopeId, optsVar) {
+    let html = generated.find(r => r.type === 'html');
+    if (html) {
+      let isFunctional = this.ast.template.attrs.functional;
+      let template = this.vue.compileTemplate({
+        source: html.value,
+        filename: this.relativeName,
+        compiler: this.vueTemplateCompiler,
+        isProduction: this.options.production,
+        isFunctional,
+        compilerOptions: {
+          scopeId
+        }
+      });
+
+      if (Array.isArray(template.errors) && template.errors.length >= 1) {
+        throw new Error(template.errors[0]);
+      }
+
+      return `
+        /* template */
+        Object.assign(${optsVar}, (function () {
+          ${template.code}
+          return {
+            render: render,
+            staticRenderFns: staticRenderFns,
+            _compiled: true,
+            _scopeId: ${JSON.stringify(scopeId)},
+            functional: ${JSON.stringify(isFunctional)}
+          };
+        })());
+      `;
+    }
+
+    return '';
+  }
+
+  compileCSSModules(generated, optsVar) {
+    let cssRenditions = generated.filter(r => r.type === 'css');
+    let cssModulesCode = '';
+    this.ast.styles.forEach((style, index) => {
+      if (style.module) {
+        let cssModules = JSON.stringify(cssRenditions[index].cssModules);
+        let name = style.module === true ? '$style' : style.module;
+        cssModulesCode += `\nthis[${JSON.stringify(name)}] = ${cssModules};`;
+      }
+    });
+
+    if (cssModulesCode) {
+      cssModulesCode = `function hook(){${cssModulesCode}\n}`;
+
+      let isFunctional = this.ast.template && this.ast.template.attrs.functional;
+      if (isFunctional) {
+        return `
+          /* css modules */
+          (function () {
+            ${cssModulesCode}
+            ${optsVar}._injectStyles = hook;
+            var originalRender = ${optsVar}.render;
+            ${optsVar}.render = function (h, context) {
+              hook.call(context);
+              return originalRender(h, context);
+            };
+          })();
+        `;
+      } else {
+        return `
+          /* css modules */
+          (function () {
+            ${cssModulesCode}
+            ${optsVar}.beforeCreate = ${optsVar}.beforeCreate ? ${optsVar}.beforeCreate.concat(hook) : [hook];
+          })();
+        `;
+      }
+    }
+
+    return '';
+  }
+
+  compileStyle(generated, scopeId) {
+    return generated.filter(r => r.type === 'css').reduce((p, r, i) => {
+      let css = r.value;
+      let scoped = this.ast.styles[i].scoped;
+
+      // Process scoped styles if needed.
+      if (scoped) {
+        var _vue$compileStyle = this.vue.compileStyle({
+          source: css,
+          filename: this.relativeName,
+          id: scopeId,
+          scoped
+        });
+
+        let code = _vue$compileStyle.code,
+            errors = _vue$compileStyle.errors;
+
+
+        if (errors.length) {
+          throw errors[0];
+        }
+
+        css = code;
+      }
+
+      return p + css;
+    }, '');
+  }
+
+  compileHMR(generated, optsVar) {
+    if (!this.options.hmr) {
+      return '';
+    }
+
+    this.addDependency('vue-hot-reload-api');
+    this.addDependency('vue');
+
+    let cssHMR = '';
+    if (this.ast.styles.length) {
+      cssHMR = `
+        var reloadCSS = require('_css_loader');
+        module.hot.dispose(reloadCSS);
+        module.hot.accept(reloadCSS);
+      `;
+    }
+
+    let isFunctional = this.ast.template && this.ast.template.attrs.functional;
+
+    return `
+    /* hot reload */
+    (function () {
+      if (module.hot) {
+        var api = require('vue-hot-reload-api');
+        api.install(require('vue'));
+        if (api.compatible) {
+          module.hot.accept();
+          if (!module.hot.data) {
+            api.createRecord('${optsVar}', ${optsVar});
+          } else {
+            api.${isFunctional ? 'rerender' : 'reload'}('${optsVar}', ${optsVar});
+          }
+        }
+
+        ${cssHMR}
+      }
+    })();`;
+  }
+}
+
+module.exports = VueAsset;

VISUALIZACION/node_modules/parcel-bundler/lib/assets/WebManifestAsset.js

@@ -0,0 +1,80 @@
+'use strict';
+
+const Asset = require('../Asset');
+
+class WebManifestAsset extends Asset {
+  constructor(name, pkg, options) {
+    super(name, pkg, options);
+    this.type = 'webmanifest';
+  }
+
+  parse(content) {
+    return JSON.parse(content);
+  }
+
+  collectDependencies() {
+    if (Array.isArray(this.ast.icons)) {
+      var _iteratorNormalCompletion = true;
+      var _didIteratorError = false;
+      var _iteratorError = undefined;
+
+      try {
+        for (var _iterator = this.ast.icons[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          let icon = _step.value;
+
+          icon.src = this.addURLDependency(icon.src);
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+    }
+
+    if (Array.isArray(this.ast.screenshots)) {
+      var _iteratorNormalCompletion2 = true;
+      var _didIteratorError2 = false;
+      var _iteratorError2 = undefined;
+
+      try {
+        for (var _iterator2 = this.ast.screenshots[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+          let shot = _step2.value;
+
+          shot.src = this.addURLDependency(shot.src);
+        }
+      } catch (err) {
+        _didIteratorError2 = true;
+        _iteratorError2 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion2 && _iterator2.return) {
+            _iterator2.return();
+          }
+        } finally {
+          if (_didIteratorError2) {
+            throw _iteratorError2;
+          }
+        }
+      }
+    }
+
+    if (this.ast.serviceworker && this.ast.serviceworker.src) {
+      this.ast.serviceworker.src = this.addURLDependency(this.ast.serviceworker.src);
+    }
+  }
+
+  generate() {
+    return JSON.stringify(this.ast);
+  }
+}
+
+module.exports = WebManifestAsset;

VISUALIZACION/node_modules/parcel-bundler/lib/assets/YAMLAsset.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const Asset = require('../Asset');
+const yaml = require('js-yaml');
+const serializeObject = require('../utils/serializeObject');
+
+class YAMLAsset extends Asset {
+  constructor(name, pkg, options) {
+    super(name, pkg, options);
+    this.type = 'js';
+  }
+
+  parse(code) {
+    return yaml.safeLoad(code);
+  }
+
+  generate() {
+    return {
+      js: serializeObject(this.ast, this.options.minify)
+    };
+  }
+}
+
+module.exports = YAMLAsset;

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/.eslintrc.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../.eslintrc.json",
+  "parserOptions": {
+    "ecmaVersion": 5
+  },
+  "env": {
+    "browser": true
+  },
+  "rules": {
+    "no-global-assign": 1
+  }
+}

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/builtins/.eslintrc.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../.eslintrc.json",
+  "parserOptions": {
+    "ecmaVersion": 5
+  },
+  "env": {
+    "browser": true
+  },
+  "rules": {
+    "no-global-assign": 1
+  }
+}

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/builtins/bundle-loader.js

@@ -0,0 +1,92 @@
+var getBundleURL = require('./bundle-url').getBundleURL;
+
+function loadBundles(bundles) {
+  var id = Array.isArray(bundles) ? bundles[bundles.length - 1] : bundles;
+
+  try {
+    return Promise.resolve(require(id));
+  } catch (err) {
+    if (err.code === 'MODULE_NOT_FOUND') {
+      return new LazyPromise(function (resolve, reject) {
+        Promise.all(bundles.slice(0, -1).map(loadBundle)).then(function () {
+          return require(id);
+        }).then(resolve, reject);
+      });
+    }
+
+    throw err;
+  }
+}
+
+module.exports = exports = loadBundles;
+
+var bundles = {};
+var bundleLoaders = {
+  js: loadJSBundle,
+  css: loadCSSBundle
+};
+
+function loadBundle(bundle) {
+  if (bundles[bundle]) {
+    return bundles[bundle];
+  }
+
+  var type = bundle.match(/\.(.+)$/)[1].toLowerCase();
+  var bundleLoader = bundleLoaders[type];
+  if (bundleLoader) {
+    return bundles[bundle] = bundleLoader(getBundleURL() + bundle);
+  }
+}
+
+function loadJSBundle(bundle) {
+  return new Promise(function (resolve, reject) {
+    var script = document.createElement('script');
+    script.async = true;
+    script.type = 'text/javascript';
+    script.charset = 'utf-8';
+    script.src = bundle;
+    script.onerror = function (e) {
+      script.onerror = script.onload = null;
+      reject(e);
+    };
+
+    script.onload = function () {
+      script.onerror = script.onload = null;
+      resolve();
+    };
+
+    document.getElementsByTagName('head')[0].appendChild(script);
+  });
+}
+
+function loadCSSBundle(bundle) {
+  return new Promise(function (resolve, reject) {
+    var link = document.createElement('link');
+    link.rel = 'stylesheet';
+    link.href = bundle;
+    link.onerror = function (e) {
+      link.onerror = link.onload = null;
+      reject(e);
+    };
+
+    link.onload = function () {
+      link.onerror = link.onload = null;
+      resolve();
+    };
+
+    document.getElementsByTagName('head')[0].appendChild(link);
+  });
+}
+
+function LazyPromise(executor) {
+  this.executor = executor;
+  this.promise = null;
+}
+
+LazyPromise.prototype.then = function (onSuccess, onError) {
+  return this.promise || (this.promise = new Promise(this.executor).then(onSuccess, onError));
+};
+
+LazyPromise.prototype.catch = function (onError) {
+  return this.promise || (this.promise = new Promise(this.executor).catch(onError));
+};

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/builtins/bundle-url.js

@@ -0,0 +1,29 @@
+var bundleURL = null;
+function getBundleURLCached() {
+  if (!bundleURL) {
+    bundleURL = getBundleURL();
+  }
+
+  return bundleURL;
+}
+
+function getBundleURL() {
+  // Attempt to find the URL of the current script and use that as the base URL
+  try {
+    throw new Error;
+  } catch (err) {
+    var matches = ('' + err.stack).match(/(https?|file|ftp):\/\/[^)\n]+/g);
+    if (matches) {
+      return getBaseURL(matches[0]);
+    }
+  }
+
+  return '/';
+}
+
+function getBaseURL(url) {
+  return ('' + url).replace(/^((?:https?|file|ftp):\/\/.+)\/[^/]+$/, '$1') + '/';
+}
+
+exports.getBundleURL = getBundleURLCached;
+exports.getBaseURL = getBaseURL;

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/builtins/css-loader.js

@@ -0,0 +1,30 @@
+var bundle = require('./bundle-url');
+
+function updateLink(link) {
+  var newLink = link.cloneNode();
+  newLink.onload = function () {
+    link.remove();
+  };
+  newLink.href = link.href.split('?')[0] + '?' + Date.now();
+  link.parentNode.insertBefore(newLink, link.nextSibling);
+}
+
+var cssTimeout = null;
+function reloadCSS() {
+  if (cssTimeout) {
+    return;
+  }
+
+  cssTimeout = setTimeout(function () {
+    var links = document.querySelectorAll('link[rel="stylesheet"]');
+    for (var i = 0; i < links.length; i++) {
+      if (bundle.getBaseURL(links[i].href) === bundle.getBundleURL()) {
+        updateLink(links[i]);
+      }
+    }
+
+    cssTimeout = null;
+  }, 50);
+}
+
+module.exports = reloadCSS;

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/builtins/hmr-runtime.js

@@ -0,0 +1,118 @@
+var global = (1, eval)('this');
+var OldModule = module.bundle.Module;
+function Module() {
+  OldModule.call(this);
+  this.hot = {
+    accept: function (fn) {
+      this._acceptCallback = fn || function () {};
+    },
+    dispose: function (fn) {
+      this._disposeCallback = fn;
+    }
+  };
+}
+
+module.bundle.Module = Module;
+
+if (!module.bundle.parent && typeof WebSocket !== 'undefined') {
+  var ws = new WebSocket('ws://' + window.location.hostname + ':{{HMR_PORT}}/');
+  ws.onmessage = function(event) {
+    var data = JSON.parse(event.data);
+
+    if (data.type === 'update') {
+      data.assets.forEach(function (asset) {
+        hmrApply(global.require, asset);
+      });
+
+      data.assets.forEach(function (asset) {
+        if (!asset.isNew) {
+          hmrAccept(global.require, asset.id);
+        }
+      });
+    }
+
+    if (data.type === 'reload') {
+      ws.close();
+      ws.onclose = function () {
+        window.location.reload();
+      }
+    }
+
+    if (data.type === 'error-resolved') {
+      console.log('[parcel] ✨ Error resolved');
+    }
+
+    if (data.type === 'error') {
+      console.error('[parcel] 🚨  ' + data.error.message + '\n' + 'data.error.stack');
+    }
+  };
+}
+
+function getParents(bundle, id) {
+  var modules = bundle.modules;
+  if (!modules) {
+    return [];
+  }
+
+  var parents = [];
+  var k, d, dep;
+
+  for (k in modules) {
+    for (d in modules[k][1]) {
+      dep = modules[k][1][d];
+      if (dep === id || (Array.isArray(dep) && dep[dep.length - 1] === id)) {
+        parents.push(+k);
+      }
+    }
+  }
+
+  if (bundle.parent) {
+    parents = parents.concat(getParents(bundle.parent, id));
+  }
+
+  return parents;
+}
+
+function hmrApply(bundle, asset) {
+  var modules = bundle.modules;
+  if (!modules) {
+    return;
+  }
+
+  if (modules[asset.id] || !bundle.parent) {
+    var fn = new Function('require', 'module', 'exports', asset.generated.js);
+    asset.isNew = !modules[asset.id];
+    modules[asset.id] = [fn, asset.deps];
+  } else if (bundle.parent) {
+    hmrApply(bundle.parent, asset);
+  }
+}
+
+function hmrAccept(bundle, id) {
+  var modules = bundle.modules;
+  if (!modules) {
+    return;
+  }
+
+  if (!modules[id] && bundle.parent) {
+    return hmrAccept(bundle.parent, id);
+  }
+
+  var cached = bundle.cache[id];
+  if (cached && cached.hot._disposeCallback) {
+    cached.hot._disposeCallback();
+  }
+
+  delete bundle.cache[id];
+  bundle(id);
+
+  cached = bundle.cache[id];
+  if (cached && cached.hot && cached.hot._acceptCallback) {
+    cached.hot._acceptCallback();
+    return true;
+  }
+
+  return getParents(global.require, id).some(function (id) {
+    return hmrAccept(global.require, id)
+  });
+}

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

@@ -0,0 +1,12 @@
+var builtins = require('node-libs-browser');
+
+for (var key in builtins) {
+  if (builtins[key] == null) {
+    builtins[key] = require.resolve('./_empty.js');
+  }
+}
+
+builtins['_bundle_loader'] = require.resolve('./bundle-loader.js');
+builtins['_css_loader'] = require.resolve('./css-loader.js');
+
+module.exports = builtins;

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/builtins/loaders/css-loader.js

@@ -0,0 +1,18 @@
+module.exports = function loadCSSBundle(bundle) {
+  return new Promise(function (resolve, reject) {
+    var link = document.createElement('link');
+    link.rel = 'stylesheet';
+    link.href = bundle;
+    link.onerror = function (e) {
+      link.onerror = link.onload = null;
+      reject(e);
+    };
+
+    link.onload = function () {
+      link.onerror = link.onload = null;
+      resolve();
+    };
+
+    document.getElementsByTagName('head')[0].appendChild(link);
+  });
+};

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/builtins/loaders/js-loader.js

@@ -0,0 +1,20 @@
+module.exports = function loadJSBundle(bundle) {
+  return new Promise(function (resolve, reject) {
+    var script = document.createElement('script');
+    script.async = true;
+    script.type = 'text/javascript';
+    script.charset = 'utf-8';
+    script.src = bundle;
+    script.onerror = function (e) {
+      script.onerror = script.onload = null;
+      reject(e);
+    };
+
+    script.onload = function () {
+      script.onerror = script.onload = null;
+      resolve();
+    };
+
+    document.getElementsByTagName('head')[0].appendChild(script);
+  });
+};

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/builtins/loaders/wasm-loader.js

@@ -0,0 +1,16 @@
+module.exports = function loadWASMBundle(bundle) {
+  return fetch(bundle)
+    .then(function (res) {
+      if (WebAssembly.compileStreaming) {
+        return WebAssembly.compileStreaming(res);
+      } else {
+        return res.arrayBuffer()
+          .then(function (data) {
+            return WebAssembly.compile(data);
+          });
+      }
+    })
+    .then(function (wasmModule) {
+      return new WebAssembly.Instance(wasmModule).exports;
+    });
+};

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/builtins/prelude.js

@@ -0,0 +1,72 @@
+// modules are defined as an array
+// [ module function, map of requires ]
+//
+// map of requires is short require name -> numeric require
+//
+// anything defined in a previous bundle is accessed via the
+// orig method which is the require for previous bundles
+
+// eslint-disable-next-line no-global-assign
+require = (function (modules, cache, entry) {
+  // Save the require from previous bundle to this closure if any
+  var previousRequire = typeof require === "function" && require;
+
+  function newRequire(name, jumped) {
+    if (!cache[name]) {
+      if (!modules[name]) {
+        // if we cannot find the module within our internal map or
+        // cache jump to the current global require ie. the last bundle
+        // that was added to the page.
+        var currentRequire = typeof require === "function" && require;
+        if (!jumped && currentRequire) {
+          return currentRequire(name, true);
+        }
+
+        // If there are other bundles on this page the require from the
+        // previous one is saved to 'previousRequire'. Repeat this as
+        // many times as there are bundles until the module is found or
+        // we exhaust the require chain.
+        if (previousRequire) {
+          return previousRequire(name, true);
+        }
+
+        var err = new Error('Cannot find module \'' + name + '\'');
+        err.code = 'MODULE_NOT_FOUND';
+        throw err;
+      }
+      
+      localRequire.resolve = resolve;
+
+      var module = cache[name] = new newRequire.Module;
+
+      modules[name][0].call(module.exports, localRequire, module, module.exports);
+    }
+
+    return cache[name].exports;
+
+    function localRequire(x){
+      return newRequire(localRequire.resolve(x));
+    }
+
+    function resolve(x){
+      return modules[name][1][x] || x;
+    }
+  }
+
+  function Module() {
+    this.bundle = newRequire;
+    this.exports = {};
+  }
+
+  newRequire.Module = Module;
+  newRequire.modules = modules;
+  newRequire.cache = cache;
+  newRequire.parent = previousRequire;
+
+  for (var i = 0; i < entry.length; i++) {
+    newRequire(entry[i]);
+  }
+
+  // Override the current require with this new one
+  return newRequire;
+})

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/builtins/prelude.min.js

@@ -0,0 +1 @@
+require=function(r,e,n){function t(n,o){function i(r){return t(i.resolve(r))}function f(e){return r[n][1][e]||e}if(!e[n]){if(!r[n]){var c="function"==typeof require&&require;if(!o&&c)return c(n,!0);if(u)return u(n,!0);var l=new Error("Cannot find module '"+n+"'");throw l.code="MODULE_NOT_FOUND",l}i.resolve=f;var a=e[n]=new t.Module;r[n][0].call(a.exports,i,a,a.exports)}return e[n].exports}function o(){this.bundle=t,this.exports={}}var u="function"==typeof require&&require;t.Module=o,t.modules=r,t.cache=e,t.parent=u;for(var i=0;i<n.length;i++)t(n[i]);return t};

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/bundle-loader.js

@@ -0,0 +1,83 @@
+var getBundleURL = require('./bundle-url').getBundleURL;
+
+function loadBundlesLazy(bundles) {
+  if (!Array.isArray(bundles)) {
+    bundles = [bundles]
+  }
+
+  var id = bundles[bundles.length - 1];
+
+  try {
+    return Promise.resolve(require(id));
+  } catch (err) {
+    if (err.code === 'MODULE_NOT_FOUND') {
+      return new LazyPromise(function (resolve, reject) {
+        loadBundles(bundles)
+          .then(resolve, reject);
+      });
+    }
+
+    throw err;
+  }
+}
+
+function loadBundles(bundles) {
+  var id = bundles[bundles.length - 1];
+
+  return Promise.all(bundles.slice(0, -1).map(loadBundle))
+    .then(function () {
+      return require(id);
+    });
+}
+
+var bundleLoaders = {};
+function registerBundleLoader(type, loader) {
+  bundleLoaders[type] = loader;
+}
+
+module.exports = exports = loadBundlesLazy;
+exports.load = loadBundles;
+exports.register = registerBundleLoader;
+
+var bundles = {};
+function loadBundle(bundle) {
+  var id;
+  if (Array.isArray(bundle)) {
+    id = bundle[1];
+    bundle = bundle[0];
+  }
+
+  if (bundles[bundle]) {
+    return bundles[bundle];
+  }
+
+  var type = (bundle.substring(bundle.lastIndexOf('.') + 1, bundle.length) || bundle).toLowerCase();
+  var bundleLoader = bundleLoaders[type];
+  if (bundleLoader) {
+    return bundles[bundle] = bundleLoader(getBundleURL() + bundle)
+      .then(function (resolved) {
+        if (resolved) {
+          module.bundle.modules[id] = [function (require, module) {
+            module.exports = resolved;
+          }, {}];
+        }
+
+        return resolved;
+      });
+  }
+}
+
+function LazyPromise(executor) {
+  this.executor = executor;
+  this.promise = null;
+}
+
+LazyPromise.prototype.then = function (onSuccess, onError) {
+  if (this.promise === null) this.promise = new Promise(this.executor)
+  return this.promise.then(onSuccess, onError)
+};
+
+LazyPromise.prototype.catch = function (onError) {
+  if (this.promise === null) this.promise = new Promise(this.executor)
+  return this.promise.catch(onError)
+};

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/bundle-url.js

@@ -0,0 +1,29 @@
+var bundleURL = null;
+function getBundleURLCached() {
+  if (!bundleURL) {
+    bundleURL = getBundleURL();
+  }
+
+  return bundleURL;
+}
+
+function getBundleURL() {
+  // Attempt to find the URL of the current script and use that as the base URL
+  try {
+    throw new Error;
+  } catch (err) {
+    var matches = ('' + err.stack).match(/(https?|file|ftp):\/\/[^)\n]+/g);
+    if (matches) {
+      return getBaseURL(matches[0]);
+    }
+  }
+
+  return '/';
+}
+
+function getBaseURL(url) {
+  return ('' + url).replace(/^((?:https?|file|ftp):\/\/.+)\/[^/]+$/, '$1') + '/';
+}
+
+exports.getBundleURL = getBundleURLCached;
+exports.getBaseURL = getBaseURL;

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/css-loader.js

@@ -0,0 +1,30 @@
+var bundle = require('./bundle-url');
+
+function updateLink(link) {
+  var newLink = link.cloneNode();
+  newLink.onload = function () {
+    link.remove();
+  };
+  newLink.href = link.href.split('?')[0] + '?' + Date.now();
+  link.parentNode.insertBefore(newLink, link.nextSibling);
+}
+
+var cssTimeout = null;
+function reloadCSS() {
+  if (cssTimeout) {
+    return;
+  }
+
+  cssTimeout = setTimeout(function () {
+    var links = document.querySelectorAll('link[rel="stylesheet"]');
+    for (var i = 0; i < links.length; i++) {
+      if (bundle.getBaseURL(links[i].href) === bundle.getBundleURL()) {
+        updateLink(links[i]);
+      }
+    }
+
+    cssTimeout = null;
+  }, 50);
+}
+
+module.exports = reloadCSS;

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/hmr-runtime.js

@@ -0,0 +1,176 @@
+var OVERLAY_ID = '__parcel__error__overlay__';
+
+var OldModule = module.bundle.Module;
+
+function Module(moduleName) {
+  OldModule.call(this, moduleName);
+  this.hot = {
+    data: module.bundle.hotData,
+    _acceptCallbacks: [],
+    _disposeCallbacks: [],
+    accept: function (fn) {
+      this._acceptCallbacks.push(fn || function () {});
+    },
+    dispose: function (fn) {
+      this._disposeCallbacks.push(fn);
+    }
+  };
+
+  module.bundle.hotData = null;
+}
+
+module.bundle.Module = Module;
+
+var parent = module.bundle.parent;
+if ((!parent || !parent.isParcelRequire) && typeof WebSocket !== 'undefined') {
+  var hostname = process.env.HMR_HOSTNAME || location.hostname;
+  var protocol = location.protocol === 'https:' ? 'wss' : 'ws';
+  var ws = new WebSocket(protocol + '://' + hostname + ':' + process.env.HMR_PORT + '/');
+  ws.onmessage = function(event) {
+    var data = JSON.parse(event.data);
+
+    if (data.type === 'update') {
+      data.assets.forEach(function (asset) {
+        hmrApply(global.parcelRequire, asset);
+      });
+
+      data.assets.forEach(function (asset) {
+        if (!asset.isNew) {
+          hmrAccept(global.parcelRequire, asset.id);
+        }
+      });
+      // Clear the console after HMR
+      console.clear();
+    }
+
+    if (data.type === 'reload') {
+      ws.close();
+      ws.onclose = function () {
+        location.reload();
+      }
+    }
+
+    if (data.type === 'error-resolved') {
+      console.log('[parcel] ✨ Error resolved');
+
+      removeErrorOverlay();
+    }
+
+    if (data.type === 'error') {
+      console.error('[parcel] 🚨  ' + data.error.message + '\n' + data.error.stack);
+
+      removeErrorOverlay();
+
+      var overlay = createErrorOverlay(data);
+      document.body.appendChild(overlay);
+    }
+  };
+}
+
+function removeErrorOverlay() {
+  var overlay = document.getElementById(OVERLAY_ID);
+  if (overlay) {
+    overlay.remove();
+  }
+}
+
+function createErrorOverlay(data) {
+  var overlay = document.createElement('div');
+  overlay.id = OVERLAY_ID;
+
+  // html encode message and stack trace
+  var message = document.createElement('div');
+  var stackTrace = document.createElement('pre');
+  message.innerText = data.error.message;
+  stackTrace.innerText = data.error.stack;
+
+  overlay.innerHTML = (
+    '<div style="background: black; font-size: 16px; color: white; position: fixed; height: 100%; width: 100%; top: 0px; left: 0px; padding: 30px; opacity: 0.85; font-family: Menlo, Consolas, monospace; z-index: 9999;">' +
+      '<span style="background: red; padding: 2px 4px; border-radius: 2px;">ERROR</span>' +
+      '<span style="top: 2px; margin-left: 5px; position: relative;">🚨</span>' +
+      '<div style="font-size: 18px; font-weight: bold; margin-top: 20px;">' + message.innerHTML + '</div>' +
+      '<pre>' + stackTrace.innerHTML + '</pre>' +
+    '</div>'
+  );
+
+  return overlay;
+
+}
+
+function getParents(bundle, id) {
+  var modules = bundle.modules;
+  if (!modules) {
+    return [];
+  }
+
+  var parents = [];
+  var k, d, dep;
+
+  for (k in modules) {
+    for (d in modules[k][1]) {
+      dep = modules[k][1][d];
+      if (dep === id || (Array.isArray(dep) && dep[dep.length - 1] === id)) {
+        parents.push(+k);
+      }
+    }
+  }
+
+  if (bundle.parent) {
+    parents = parents.concat(getParents(bundle.parent, id));
+  }
+
+  return parents;
+}
+
+function hmrApply(bundle, asset) {
+  var modules = bundle.modules;
+  if (!modules) {
+    return;
+  }
+
+  if (modules[asset.id] || !bundle.parent) {
+    var fn = new Function('require', 'module', 'exports', asset.generated.js);
+    asset.isNew = !modules[asset.id];
+    modules[asset.id] = [fn, asset.deps];
+  } else if (bundle.parent) {
+    hmrApply(bundle.parent, asset);
+  }
+}
+
+function hmrAccept(bundle, id) {
+  var modules = bundle.modules;
+  if (!modules) {
+    return;
+  }
+
+  if (!modules[id] && bundle.parent) {
+    return hmrAccept(bundle.parent, id);
+  }
+
+  var cached = bundle.cache[id];
+  bundle.hotData = {};
+  if (cached) {
+    cached.hot.data = bundle.hotData;
+  }
+
+  if (cached && cached.hot && cached.hot._disposeCallbacks.length) {
+    cached.hot._disposeCallbacks.forEach(function (cb) {
+      cb(bundle.hotData);
+    });
+  }
+
+  delete bundle.cache[id];
+  bundle(id);
+
+  cached = bundle.cache[id];
+  if (cached && cached.hot && cached.hot._acceptCallbacks.length) {
+    cached.hot._acceptCallbacks.forEach(function (cb) {
+      cb();
+    });
+    return true;
+  }
+
+  return getParents(global.parcelRequire, id).some(function (id) {
+    return hmrAccept(global.parcelRequire, id)
+  });
+}

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

@@ -0,0 +1,12 @@
+var builtins = require('node-libs-browser');
+
+for (var key in builtins) {
+  if (builtins[key] == null) {
+    builtins[key] = require.resolve('./_empty.js');
+  }
+}
+
+builtins['_bundle_loader'] = require.resolve('./bundle-loader.js');
+builtins['_css_loader'] = require.resolve('./css-loader.js');
+
+module.exports = builtins;

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/loaders/browser/css-loader.js

@@ -0,0 +1,18 @@
+module.exports = function loadCSSBundle(bundle) {
+  return new Promise(function (resolve, reject) {
+    var link = document.createElement('link');
+    link.rel = 'stylesheet';
+    link.href = bundle;
+    link.onerror = function (e) {
+      link.onerror = link.onload = null;
+      reject(e);
+    };
+
+    link.onload = function () {
+      link.onerror = link.onload = null;
+      resolve();
+    };
+
+    document.getElementsByTagName('head')[0].appendChild(link);
+  });
+};

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/loaders/browser/js-loader.js

@@ -0,0 +1,20 @@
+module.exports = function loadJSBundle(bundle) {
+  return new Promise(function (resolve, reject) {
+    var script = document.createElement('script');
+    script.async = true;
+    script.type = 'text/javascript';
+    script.charset = 'utf-8';
+    script.src = bundle;
+    script.onerror = function (e) {
+      script.onerror = script.onload = null;
+      reject(e);
+    };
+
+    script.onload = function () {
+      script.onerror = script.onload = null;
+      resolve();
+    };
+
+    document.getElementsByTagName('head')[0].appendChild(script);
+  });
+};

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/loaders/browser/wasm-loader.js

@@ -0,0 +1,16 @@
+module.exports = function loadWASMBundle(bundle) {
+  return fetch(bundle)
+    .then(function (res) {
+      if (WebAssembly.instantiateStreaming) {
+        return WebAssembly.instantiateStreaming(res);
+      } else {
+        return res.arrayBuffer()
+          .then(function (data) {
+            return WebAssembly.instantiate(data);
+          });
+      }
+    })
+    .then(function (wasmModule) {
+      return wasmModule.instance.exports;
+    });
+};

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/loaders/css-loader.js

@@ -0,0 +1,18 @@
+module.exports = function loadCSSBundle(bundle) {
+  return new Promise(function (resolve, reject) {
+    var link = document.createElement('link');
+    link.rel = 'stylesheet';
+    link.href = bundle;
+    link.onerror = function (e) {
+      link.onerror = link.onload = null;
+      reject(e);
+    };
+
+    link.onload = function () {
+      link.onerror = link.onload = null;
+      resolve();
+    };
+
+    document.getElementsByTagName('head')[0].appendChild(link);
+  });
+};

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/loaders/js-loader.js

@@ -0,0 +1,20 @@
+module.exports = function loadJSBundle(bundle) {
+  return new Promise(function (resolve, reject) {
+    var script = document.createElement('script');
+    script.async = true;
+    script.type = 'text/javascript';
+    script.charset = 'utf-8';
+    script.src = bundle;
+    script.onerror = function (e) {
+      script.onerror = script.onload = null;
+      reject(e);
+    };
+
+    script.onload = function () {
+      script.onerror = script.onload = null;
+      resolve();
+    };
+
+    document.getElementsByTagName('head')[0].appendChild(script);
+  });
+};

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/loaders/node/css-loader.js

@@ -0,0 +1,4 @@
+// loading a CSS style is a no-op in Node.js
+module.exports = function loadCSSBundle() {
+  return Promise.resolve();
+};

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/loaders/node/js-loader.js

@@ -0,0 +1,20 @@
+var fs = require('fs');
+
+module.exports = function loadJSBundle(bundle) {
+  return new Promise(function(resolve, reject) {
+    fs.readFile(__dirname + bundle, 'utf8', function(err, data) {
+      if (err) {
+        reject(err);
+      } else {
+        // wait for the next event loop iteration, so we are sure
+        // the current module is fully loaded
+        setImmediate(function() {
+          resolve(data);
+        });
+      }
+    });
+  })
+  .then(function(code) {
+    new Function('', code)();
+  });
+};

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/loaders/node/wasm-loader.js

@@ -0,0 +1,19 @@
+var fs = require('fs');
+
+module.exports = function loadWASMBundle(bundle) {
+  return new Promise(function(resolve, reject) {
+    fs.readFile(__dirname + bundle, function(err, data) {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(data.buffer);
+      }
+    });
+  })
+  .then(function(data) {
+    return WebAssembly.instantiate(data);
+  })
+  .then(function(wasmModule) {
+    return wasmModule.instance.exports;
+  });
+};

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/loaders/wasm-loader.js

@@ -0,0 +1,16 @@
+module.exports = function loadWASMBundle(bundle) {
+  return fetch(bundle)
+    .then(function (res) {
+      if (WebAssembly.instantiateStreaming) {
+        return WebAssembly.instantiateStreaming(res);
+      } else {
+        return res.arrayBuffer()
+          .then(function (data) {
+            return WebAssembly.instantiate(data);
+          });
+      }
+    })
+    .then(function (wasmModule) {
+      return wasmModule.instance.exports;
+    });
+};

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/prelude.js

@@ -0,0 +1,101 @@
+// modules are defined as an array
+// [ module function, map of requires ]
+//
+// map of requires is short require name -> numeric require
+//
+// anything defined in a previous bundle is accessed via the
+// orig method which is the require for previous bundles
+
+// eslint-disable-next-line no-global-assign
+parcelRequire = (function (modules, cache, entry, globalName) {
+  // Save the require from previous bundle to this closure if any
+  var previousRequire = typeof parcelRequire === 'function' && parcelRequire;
+  var nodeRequire = typeof require === 'function' && require;
+
+  function newRequire(name, jumped) {
+    if (!cache[name]) {
+      if (!modules[name]) {
+        // if we cannot find the module within our internal map or
+        // cache jump to the current global require ie. the last bundle
+        // that was added to the page.
+        var currentRequire = typeof parcelRequire === 'function' && parcelRequire;
+        if (!jumped && currentRequire) {
+          return currentRequire(name, true);
+        }
+
+        // If there are other bundles on this page the require from the
+        // previous one is saved to 'previousRequire'. Repeat this as
+        // many times as there are bundles until the module is found or
+        // we exhaust the require chain.
+        if (previousRequire) {
+          return previousRequire(name, true);
+        }
+
+        // Try the node require function if it exists.
+        if (nodeRequire && typeof name === 'string') {
+          return nodeRequire(name);
+        }
+
+        var err = new Error('Cannot find module \'' + name + '\'');
+        err.code = 'MODULE_NOT_FOUND';
+        throw err;
+      }
+
+      localRequire.resolve = resolve;
+
+      var module = cache[name] = new newRequire.Module(name);
+
+      modules[name][0].call(module.exports, localRequire, module, module.exports, this);
+    }
+
+    return cache[name].exports;
+
+    function localRequire(x){
+      return newRequire(localRequire.resolve(x));
+    }
+
+    function resolve(x){
+      return modules[name][1][x] || x;
+    }
+  }
+
+  function Module(moduleName) {
+    this.id = moduleName;
+    this.bundle = newRequire;
+    this.exports = {};
+  }
+
+  newRequire.isParcelRequire = true;
+  newRequire.Module = Module;
+  newRequire.modules = modules;
+  newRequire.cache = cache;
+  newRequire.parent = previousRequire;
+
+  for (var i = 0; i < entry.length; i++) {
+    newRequire(entry[i]);
+  }
+
+  if (entry.length) {
+    // Expose entry point to Node, AMD or browser globals
+    // Based on https://github.com/ForbesLindesay/umd/blob/master/template.js
+    var mainExports = newRequire(entry[entry.length - 1]);
+
+    // CommonJS
+    if (typeof exports === "object" && typeof module !== "undefined") {
+      module.exports = mainExports;
+
+    // RequireJS
+    } else if (typeof define === "function" && define.amd) {
+     define(function () {
+       return mainExports;
+     });
+
+    // <script>
+    } else if (globalName) {
+      this[globalName] = mainExports;
+    }
+  }
+
+  // Override the current require with this new one
+  return newRequire;
+})

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/prelude.min.js

@@ -0,0 +1 @@
+parcelRequire=function(e,r,n,t){function i(n,t){function o(e){return i(o.resolve(e))}function c(r){return e[n][1][r]||r}if(!r[n]){if(!e[n]){var l="function"==typeof parcelRequire&&parcelRequire;if(!t&&l)return l(n,!0);if(u)return u(n,!0);if(f&&"string"==typeof n)return f(n);var p=new Error("Cannot find module '"+n+"'");throw p.code="MODULE_NOT_FOUND",p}o.resolve=c;var a=r[n]=new i.Module(n);e[n][0].call(a.exports,o,a,a.exports,this)}return r[n].exports}function o(e){this.id=e,this.bundle=i,this.exports={}}var u="function"==typeof parcelRequire&&parcelRequire,f="function"==typeof require&&require;i.isParcelRequire=!0,i.Module=o,i.modules=e,i.cache=r,i.parent=u;for(var c=0;c<n.length;c++)i(n[c]);if(n.length){var l=i(n[n.length-1]);"object"==typeof exports&&"undefined"!=typeof module?module.exports=l:"function"==typeof define&&define.amd?define(function(){return l}):t&&(this[t]=l)}return i};

VISUALIZACION/node_modules/parcel-bundler/lib/builtins/prelude2.js

@@ -0,0 +1,41 @@
+parcelRequire = (function (init) {
+  // Save the require from previous bundle to this closure if any
+  var previousRequire = typeof parcelRequire === 'function' && parcelRequire;
+  var nodeRequire = typeof require === 'function' && require;
+  var modules = {};
+
+  function localRequire(name, jumped) {
+    if (modules[name]) {
+      return modules[name];
+    }
+
+    // if we cannot find the module within our internal map or
+    // cache jump to the current global require ie. the last bundle
+    // that was added to the page.
+    var currentRequire = typeof parcelRequire === 'function' && parcelRequire;
+    if (!jumped && currentRequire) {
+      return currentRequire(name, true);
+    }
+
+    // If there are other bundles on this page the require from the
+    // previous one is saved to 'previousRequire'. Repeat this as
+    // many times as there are bundles until the module is found or
+    // we exhaust the require chain.
+    if (previousRequire) {
+      return previousRequire(name, true);
+    }
+
+    // Try the node require function if it exists.
+    if (nodeRequire && typeof name === 'string') {
+      return nodeRequire(name);
+    }
+
+    var err = new Error('Cannot find module \'' + name + '\'');
+    err.code = 'MODULE_NOT_FOUND';
+    throw err;
+  }
+
+  modules = init(localRequire);
+  localRequire.modules = modules;
+  return localRequire;
+})

VISUALIZACION/node_modules/parcel-bundler/lib/cli.js

@@ -0,0 +1,72 @@
+'use strict';
+
+let bundle = (() => {
+  var _ref = _asyncToGenerator(function* (main, command) {
+    // Require bundler here so the help command is fast
+    const Bundler = require('../');
+
+    if (command.name() === 'build') {
+      process.env.NODE_ENV = 'production';
+    } else {
+      process.env.NODE_ENV = process.env.NODE_ENV || 'development';
+    }
+
+    if (command.cert && command.key) {
+      command.https = {
+        cert: command.cert,
+        key: command.key
+      };
+    }
+
+    const bundler = new Bundler(main, command);
+
+    command.target = command.target || 'browser';
+    if (command.name() === 'serve' && command.target === 'browser') {
+      const server = yield bundler.serve(command.port || 1234, command.https);
+      if (server && command.open) {
+        yield require('./utils/openInBrowser')(`${command.https ? 'https' : 'http'}://localhost:${server.address().port}`, command.open);
+      }
+    } else {
+      bundler.bundle();
+    }
+  });
+
+  return function bundle(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+})();
+
+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"); }); }; }
+
+require('v8-compile-cache');
+const chalk = require('chalk');
+const program = require('commander');
+const version = require('../package.json').version;
+
+program.version(version);
+
+program.command('serve [input...]').description('starts a development server').option('-p, --port <port>', 'set the port to serve on. defaults to 1234', parseInt).option('--hmr-port <port>', 'set the port to serve HMR websockets, defaults to random', parseInt).option('--hmr-hostname <hostname>', 'set the hostname of HMR websockets, defaults to location.hostname of current window').option('--https', 'serves files over HTTPS').option('--cert <path>', 'path to certificate to use with HTTPS').option('--key <path>', 'path to private key to use with HTTPS').option('--open [browser]', 'automatically open in specified browser, defaults to default browser').option('-d, --out-dir <path>', 'set the output directory. defaults to "dist"').option('-o, --out-file <filename>', 'set the output filename for the application entry point.').option('--public-url <url>', 'set the public URL to serve on. defaults to the same as the --out-dir option').option('--global <variable>', 'expose your module through a global variable').option('--no-hmr', 'disable hot module replacement').option('--no-cache', 'disable the filesystem cache').option('--no-source-maps', 'disable sourcemaps').option('--no-autoinstall', 'disable autoinstall').option('-t, --target [target]', 'set the runtime environment, either "node", "browser" or "electron". defaults to "browser"', /^(node|browser|electron)$/).option('-V, --version', 'output the version number').option('--log-level <level>', 'set the log level, either "0" (no output), "1" (errors), "2" (warnings + errors) or "3" (all).', /^([0-3])$/).action(bundle);
+
+program.command('watch [input...]').description('starts the bundler in watch mode').option('-d, --out-dir <path>', 'set the output directory. defaults to "dist"').option('-o, --out-file <filename>', 'set the output filename for the application entry point.').option('--public-url <url>', 'set the public URL to serve on. defaults to the same as the --out-dir option').option('--global <variable>', 'expose your module through a global variable').option('--hmr-port <port>', 'set the port to serve HMR websockets, defaults to random', parseInt).option('--hmr-hostname <hostname>', 'set the hostname of HMR websockets, defaults to location.hostname of current window').option('--no-hmr', 'disable hot module replacement').option('--no-cache', 'disable the filesystem cache').option('--no-source-maps', 'disable sourcemaps').option('--no-autoinstall', 'disable autoinstall').option('-t, --target [target]', 'set the runtime environment, either "node", "browser" or "electron". defaults to "browser"', /^(node|browser|electron)$/).option('--log-level <level>', 'set the log level, either "0" (no output), "1" (errors), "2" (warnings + errors) or "3" (all).', /^([0-3])$/).action(bundle);
+
+program.command('build [input...]').description('bundles for production').option('-d, --out-dir <path>', 'set the output directory. defaults to "dist"').option('-o, --out-file <filename>', 'set the output filename for the application entry point.').option('--public-url <url>', 'set the public URL to serve on. defaults to the same as the --out-dir option').option('--global <variable>', 'expose your module through a global variable').option('--no-minify', 'disable minification').option('--no-cache', 'disable the filesystem cache').option('--no-source-maps', 'disable sourcemaps').option('-t, --target <target>', 'set the runtime environment, either "node", "browser" or "electron". defaults to "browser"', /^(node|browser|electron)$/).option('--detailed-report', 'print a detailed build report after a completed build').option('--log-level <level>', 'set the log level, either "0" (no output), "1" (errors), "2" (warnings + errors) or "3" (all).', /^([0-3])$/).action(bundle);
+
+program.command('help [command]').description('display help information for a command').action(function (command) {
+  let cmd = program.commands.find(c => c.name() === command) || program;
+  cmd.help();
+});
+
+program.on('--help', function () {
+  console.log('');
+  console.log('  Run `' + chalk.bold('parcel help <command>') + '` for more information on specific commands');
+  console.log('');
+});
+
+// Make serve the default command except for --help
+var args = process.argv;
+if (args[2] === '--help' || args[2] === '-h') args[2] = 'help';
+if (!args[2] || !program.commands.some(c => c.name() === args[2])) {
+  args.splice(2, 0, 'serve');
+}
+
+program.parse(args);

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;

VISUALIZACION/node_modules/parcel-bundler/lib/transforms/babel.js

@@ -0,0 +1,341 @@
+'use strict';
+
+let babelTransform = (() => {
+  var _ref = _asyncToGenerator(function* (asset) {
+    let config = yield getConfig(asset);
+    if (!config) {
+      return;
+    }
+
+    yield asset.parseIfNeeded();
+
+    // If this is an internally generated config, use our internal babel-core,
+    // otherwise require a local version from the package we're compiling.
+    let babel = config.internal ? require('babel-core') : yield localRequire('babel-core', asset.name);
+
+    // TODO: support other versions of babel
+    if (parseInt(babel.version, 10) !== 6) {
+      throw new Error(`Unsupported babel version: ${babel.version}`);
+    }
+
+    let res = babel.transformFromAst(asset.ast, asset.contents, config);
+    if (!res.ignored) {
+      asset.ast = res.ast;
+      asset.isAstDirty = true;
+    }
+  });
+
+  return function babelTransform(_x) {
+    return _ref.apply(this, arguments);
+  };
+})();
+
+let getConfig = (() => {
+  var _ref2 = _asyncToGenerator(function* (asset) {
+    let config = yield getBabelConfig(asset);
+    if (config) {
+      config.code = false;
+      config.filename = asset.name;
+      config.babelrc = false;
+
+      // Hide the internal property from babel
+      let internal = config.internal;
+      delete config.internal;
+      Object.defineProperty(config, 'internal', {
+        value: internal,
+        configurable: true
+      });
+    }
+
+    return config;
+  });
+
+  return function getConfig(_x2) {
+    return _ref2.apply(this, arguments);
+  };
+})();
+
+let getBabelConfig = (() => {
+  var _ref3 = _asyncToGenerator(function* (asset) {
+    // If asset is marked as an ES6 modules, this is a second pass after dependencies are extracted.
+    // Just compile modules to CommonJS.
+    if (asset.isES6Module) {
+      return {
+        internal: true,
+        plugins: [require('babel-plugin-transform-es2015-modules-commonjs')]
+      };
+    }
+
+    if (asset.babelConfig) {
+      return asset.babelConfig;
+    }
+
+    // Consider the module source code rather than precompiled if the resolver
+    // used the `source` field, or it is not in node_modules.
+    let isSource = !!(asset.package && asset.package.source) || !asset.name.includes(NODE_MODULES);
+
+    // Try to resolve a .babelrc file. If one is found, consider the module source code.
+    let babelrc = yield getBabelRc(asset, isSource);
+    isSource = isSource || !!babelrc;
+
+    let envConfig = yield getEnvConfig(asset, isSource);
+    let jsxConfig = getJSXConfig(asset, isSource);
+
+    // Merge the babel-preset-env config and the babelrc if needed
+    if (babelrc && !shouldIgnoreBabelrc(asset.name, babelrc)) {
+      if (envConfig) {
+        // Filter out presets that are already applied by babel-preset-env
+        if (Array.isArray(babelrc.presets)) {
+          babelrc.presets = babelrc.presets.filter(function (preset) {
+            return !ENV_PRESETS[getPluginName(preset)];
+          });
+        }
+
+        // Filter out plugins that are already applied by babel-preset-env
+        if (Array.isArray(babelrc.plugins)) {
+          babelrc.plugins = babelrc.plugins.filter(function (plugin) {
+            return !ENV_PLUGINS[getPluginName(plugin)];
+          });
+        }
+
+        // Add plugins generated by babel-preset-env to get to the app's target engines.
+        mergeConfigs(babelrc, envConfig);
+      }
+
+      // Add JSX config if it isn't already specified in the babelrc
+      let hasReact = hasPlugin(babelrc.presets, 'react') || hasPlugin(babelrc.plugins, 'transform-react-jsx');
+
+      if (!hasReact) {
+        mergeConfigs(babelrc, jsxConfig);
+      }
+
+      return babelrc;
+    }
+
+    // If there is a babel-preset-env config, and it isn't empty use that
+    if (envConfig && (envConfig.plugins.length > 0 || jsxConfig)) {
+      mergeConfigs(envConfig, jsxConfig);
+      return envConfig;
+    }
+
+    // If there is a JSX config, return that
+    if (jsxConfig) {
+      return jsxConfig;
+    }
+
+    // Otherwise, don't run babel at all
+    return null;
+  });
+
+  return function getBabelConfig(_x3) {
+    return _ref3.apply(this, arguments);
+  };
+})();
+
+/**
+ * Finds a .babelrc for an asset. By default, .babelrc files inside node_modules are not used.
+ * However, there are some exceptions:
+ *   - if `browserify.transforms` includes "babelify" in package.json (for legacy module compat)
+ *   - the `source` field in package.json is used by the resolver
+ */
+let getBabelRc = (() => {
+  var _ref4 = _asyncToGenerator(function* (asset, isSource) {
+    // Support legacy browserify packages
+    let browserify = asset.package && asset.package.browserify;
+    if (browserify && Array.isArray(browserify.transform)) {
+      // Look for babelify in the browserify transform list
+      let babelify = browserify.transform.find(function (t) {
+        return (Array.isArray(t) ? t[0] : t) === 'babelify';
+      });
+
+      // If specified as an array, override the config with the one specified
+      if (Array.isArray(babelify) && babelify[1]) {
+        return babelify[1];
+      }
+
+      // Otherwise, return the .babelrc if babelify was found
+      return babelify ? yield findBabelRc(asset) : null;
+    }
+
+    // If this asset is not in node_modules, always use the .babelrc
+    if (isSource) {
+      return yield findBabelRc(asset);
+    }
+
+    // Otherwise, don't load .babelrc for node_modules.
+    // See https://github.com/parcel-bundler/parcel/issues/13.
+    return null;
+  });
+
+  return function getBabelRc(_x4, _x5) {
+    return _ref4.apply(this, arguments);
+  };
+})();
+
+let findBabelRc = (() => {
+  var _ref5 = _asyncToGenerator(function* (asset) {
+    if (asset.package && asset.package.babel) {
+      return asset.package.babel;
+    }
+
+    return yield asset.getConfig(['.babelrc', '.babelrc.js']);
+  });
+
+  return function findBabelRc(_x6) {
+    return _ref5.apply(this, arguments);
+  };
+})();
+
+/**
+ * Generates a babel-preset-env config for an asset.
+ * This is done by finding the source module's target engines, and the app's
+ * target engines, and doing a diff to include only the necessary plugins.
+ */
+let getEnvConfig = (() => {
+  var _ref6 = _asyncToGenerator(function* (asset, isSourceModule) {
+    // Load the target engines for the app and generate a babel-preset-env config
+    let targetEngines = yield getTargetEngines(asset, true);
+    let targetEnv = yield getEnvPlugins(targetEngines, true);
+    if (!targetEnv) {
+      return null;
+    }
+
+    // If this is the app module, the source and target will be the same, so just compile everything.
+    // Otherwise, load the source engines and generate a babel-present-env config.
+    if (!isSourceModule) {
+      let sourceEngines = yield getTargetEngines(asset, false);
+      let sourceEnv = (yield getEnvPlugins(sourceEngines, false)) || targetEnv;
+
+      // Do a diff of the returned plugins. We only need to process the remaining plugins to get to the app target.
+      let sourcePlugins = new Set(sourceEnv.map(function (p) {
+        return p[0];
+      }));
+      targetEnv = targetEnv.filter(function (plugin) {
+        return !sourcePlugins.has(plugin[0]);
+      });
+    }
+
+    return { plugins: targetEnv, internal: true };
+  });
+
+  return function getEnvConfig(_x7, _x8) {
+    return _ref6.apply(this, arguments);
+  };
+})();
+
+let getEnvPlugins = (() => {
+  var _ref7 = _asyncToGenerator(function* (targets, useBuiltIns = false) {
+    if (!targets) {
+      return null;
+    }
+
+    let key = JSON.stringify(targets);
+    if (envCache.has(key)) {
+      return envCache.get(key);
+    }
+
+    let plugins = presetEnv.default({}, { targets, modules: false, useBuiltIns: useBuiltIns ? 'entry' : false }).plugins;
+    envCache.set(key, plugins);
+    return plugins;
+  });
+
+  return function getEnvPlugins(_x9) {
+    return _ref7.apply(this, arguments);
+  };
+})();
+
+/**
+ * Generates a babel config for JSX. Attempts to detect react or react-like libraries
+ * and changes the pragma accordingly.
+ */
+
+
+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 presetEnv = require('babel-preset-env');
+const getTargetEngines = require('../utils/getTargetEngines');
+const localRequire = require('../utils/localRequire');
+const path = require('path');
+
+var _require = require('babel-core');
+
+const babelUtils = _require.util;
+
+
+const NODE_MODULES = `${path.sep}node_modules${path.sep}`;
+const ENV_PLUGINS = require('babel-preset-env/data/plugins');
+const ENV_PRESETS = {
+  es2015: true,
+  es2016: true,
+  es2017: true,
+  latest: true,
+  env: true
+};
+
+const JSX_EXTENSIONS = {
+  '.jsx': true,
+  '.tsx': true
+};
+
+const JSX_PRAGMA = {
+  react: 'React.createElement',
+  preact: 'h',
+  nervjs: 'Nerv.createElement',
+  hyperapp: 'h'
+};
+
+module.exports = babelTransform;
+
+babelTransform.getConfig = getConfig;
+
+function mergeConfigs(a, b) {
+  if (b) {
+    a.presets = (a.presets || []).concat(b.presets || []);
+    a.plugins = (a.plugins || []).concat(b.plugins || []);
+  }
+
+  return a;
+}
+
+function hasPlugin(arr, plugin) {
+  return Array.isArray(arr) && arr.some(p => getPluginName(p) === plugin);
+}
+
+function getPluginName(p) {
+  return Array.isArray(p) ? p[0] : p;
+}
+
+function shouldIgnoreBabelrc(filename, babelrc) {
+  // Determine if we should ignore this babelrc file. We do this here instead of
+  // letting babel-core handle it because this config might be merged with our
+  // autogenerated one later which shouldn't be ignored.
+  let ignore = babelUtils.arrayify(babelrc.ignore, babelUtils.regexify);
+  let only = babelrc.only && babelUtils.arrayify(babelrc.only, babelUtils.regexify);
+  return babelUtils.shouldIgnore(filename, ignore, only);
+}
+
+const envCache = new Map();
+
+function getJSXConfig(asset, isSourceModule) {
+  // Don't enable JSX in node_modules
+  if (!isSourceModule) {
+    return null;
+  }
+
+  // Find a dependency that we can map to a JSX pragma
+  let pragma = null;
+  for (let dep in JSX_PRAGMA) {
+    let pkg = asset.package;
+    if (pkg && (pkg.dependencies && pkg.dependencies[dep] || pkg.devDependencies && pkg.devDependencies[dep])) {
+      pragma = JSX_PRAGMA[dep];
+      break;
+    }
+  }
+
+  if (pragma || JSX_EXTENSIONS[path.extname(asset.name)]) {
+    return {
+      plugins: [[require('babel-plugin-transform-react-jsx'), { pragma }]],
+      internal: true
+    };
+  }
+}

VISUALIZACION/node_modules/parcel-bundler/lib/transforms/concat.js

@@ -0,0 +1,218 @@
+'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"); } }; }();
+
+const babylon = require('babylon');
+const t = require('babel-types');
+const traverse = require('babel-traverse').default;
+const generate = require('babel-generator').default;
+
+const EXPORTS_RE = /^\$([\d]+)\$exports$/;
+const EXPORT_RE = /^\$([\d]+)\$export\$(.+)$/;
+
+// TODO: minify
+// TODO: source-map
+
+module.exports = (code, exports, moduleMap, wildcards) => {
+  let ast = babylon.parse(code);
+  let addedExports = new Set();
+  let commentedBindings = new Set();
+
+  let resolveModule = (id, name) => {
+    let module = moduleMap.get(id);
+    return module.depAssets.get(module.dependencies.get(name)).id;
+  };
+
+  function replaceExportNode(id, name, path) {
+    path = getOuterStatement(path);
+
+    let node = tail(id, id => `$${id}$export$${name}`);
+
+    if (!node) {
+      // if there is no named export then lookup for a CommonJS export
+      node = tail(id, id => `$${id}$exports`) || t.identifier(`$${id}$exports`);
+
+      // if there is a CommonJS export return $id$exports.name
+      if (node) {
+        return t.memberExpression(node, t.identifier(name));
+      }
+    }
+
+    return node;
+
+    function tail(id, symbol) {
+      let computedSymbol = symbol(id);
+
+      // if the symbol is in the scope there is not need to remap it
+      if (path.scope.hasBinding(computedSymbol)) {
+        return t.identifier(computedSymbol);
+      }
+
+      if (exports.has(computedSymbol)) {
+        return t.identifier(exports.get(computedSymbol));
+      }
+
+      // if there is a wildcard for the module
+      // default exports are excluded from wildcard exports
+      if (wildcards.has(id) && name !== 'default') {
+        /* recursively lookup the symbol
+         * this is needed when there is deep export wildcards, like in the following:
+         * - a.js
+         *   > export * from './b'
+         * - b.js
+         *   > export * from './c'
+         * - c.js in es6
+         *   > export * from 'lodash'
+         * - c.js in cjs
+         *   > module.exports = require('lodash')
+         */
+        let node = null;
+
+        wildcards.get(id).find(name => node = tail(resolveModule(id, name), symbol));
+
+        return node;
+      }
+
+      return null;
+    }
+  }
+
+  traverse(ast, {
+    CallExpression(path) {
+      var _path$node = path.node;
+      let args = _path$node.arguments,
+          callee = _path$node.callee;
+
+      // each require('module') call gets replaced with $parcel$require(id, 'module')
+
+      if (t.isIdentifier(callee, { name: '$parcel$require' })) {
+        var _args = _slicedToArray(args, 2);
+
+        let id = _args[0],
+            name = _args[1];
+
+
+        if (args.length !== 2 || !t.isNumericLiteral(id) || !t.isStringLiteral(name)) {
+          throw new Error('invariant: invalid signature, expected : $parcel$require(number, string)');
+        }
+
+        const mod = resolveModule(id.value, name.value);
+
+        if (typeof mod === 'undefined') {
+          throw new Error(`Cannot find module "${name.value}"`);
+        }
+
+        path.replaceWith(t.identifier(`$${mod}$exports`));
+      }
+    },
+    MemberExpression(path) {
+      if (!path.isReferenced()) {
+        return;
+      }
+
+      var _path$node2 = path.node;
+      let object = _path$node2.object,
+          property = _path$node2.property;
+
+      if (!t.isIdentifier(object) || !t.isIdentifier(property)) {
+        return;
+      }
+
+      let match = object.name.match(EXPORTS_RE);
+      if (match) {
+        let exportName = '$' + match[1] + '$export$' + property.name;
+        if (path.scope.hasBinding(exportName)) {
+          path.replaceWith(t.identifier(exportName));
+        }
+      }
+    },
+    Identifier(path) {
+      let name = path.node.name;
+
+
+      if (typeof name !== 'string') {
+        return;
+      }
+
+      let match = name.match(EXPORTS_RE);
+
+      if (match) {
+        if (!path.scope.hasBinding(name) && !addedExports.has(name)) {
+          let moduleExports = moduleMap.get(+match[1]).cacheData.exports;
+
+          addedExports.add(name);
+
+          getOuterStatement(path).insertBefore(t.variableDeclaration('var', [t.variableDeclarator(t.identifier(name), t.objectExpression(Object.keys(moduleExports).map(key => {
+            let binding = path.scope.getBinding(exports.get(key) || key);
+            if (!binding) {
+              return null;
+            }
+
+            let exportName = key.match(EXPORT_RE)[2];
+            let expr = replaceExportNode(+match[1], exportName, path);
+
+            if (expr === null) {
+              return null;
+            }
+
+            if (binding.constant) {
+              return t.objectProperty(t.identifier(exportName), expr);
+            } else {
+              if (!commentedBindings.has(binding)) {
+                commentedBindings.add(binding);
+                binding.constantViolations.forEach(path => path.getFunctionParent().addComment('leading', ` bailout: mutates ${generate(expr).code}`, '\n'));
+              }
+
+              return t.objectMethod('get', t.identifier(exportName), [], t.blockStatement([t.returnStatement(expr)]));
+            }
+          }).filter(property => property !== null)))]));
+        }
+
+        return;
+      }
+
+      match = name.match(EXPORT_RE);
+
+      if (match && !path.scope.hasBinding(name) && !addedExports.has(name)) {
+        let id = Number(match[1]);
+        let exportName = match[2];
+        let node = replaceExportNode(id, exportName, path);
+
+        addedExports.add(name);
+
+        if (node) {
+          path.replaceWith(node);
+        }
+      }
+    }
+  });
+
+  return generate(ast, code).code;
+};
+
+function getOuterStatement(path) {
+  if (validate(path)) {
+    return path;
+  }
+
+  return path.findParent(validate);
+
+  function validate(path) {
+    if (!t.isStatement(path.node) || t.isBlockStatement(path.node)) {
+      return false;
+    }
+
+    // TODO: use scope?
+    let outerBlocks = 0;
+
+    path.findParent(parent => {
+      if (t.isBlockStatement(parent.node)) {
+        outerBlocks++;
+      }
+
+      return false;
+    });
+
+    return outerBlocks === 1;
+  }
+}

VISUALIZACION/node_modules/parcel-bundler/lib/transforms/htmlnano.js

@@ -0,0 +1,25 @@
+'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 posthtml = require('posthtml');
+const htmlnano = require('htmlnano');
+
+module.exports = (() => {
+  var _ref = _asyncToGenerator(function* (asset) {
+    yield asset.parseIfNeeded();
+
+    const htmlNanoConfig = asset.package.htmlnano || (yield asset.getConfig(['.htmlnanorc', '.htmlnanorc.js'])) || {};
+
+    let res = yield posthtml([htmlnano(htmlNanoConfig)]).process(asset.ast, {
+      skipParse: true
+    });
+
+    asset.ast = res.tree;
+    asset.isAstDirty = true;
+  });
+
+  return function (_x) {
+    return _ref.apply(this, arguments);
+  };
+})();

VISUALIZACION/node_modules/parcel-bundler/lib/transforms/postcss.js

@@ -0,0 +1,76 @@
+'use strict';
+
+let getConfig = (() => {
+  var _ref2 = _asyncToGenerator(function* (asset) {
+    let config = asset.package.postcss || (yield asset.getConfig(['.postcssrc', '.postcssrc.js', 'postcss.config.js']));
+
+    let enableModules = asset.options.rendition && asset.options.rendition.modules;
+    if (!config && !asset.options.minify && !enableModules) {
+      return;
+    }
+
+    config = Object.assign({}, config);
+
+    let postcssModulesConfig = {
+      getJSON: function getJSON(filename, json) {
+        return asset.cssModules = json;
+      }
+    };
+
+    if (config.plugins && config.plugins['postcss-modules']) {
+      postcssModulesConfig = Object.assign(config.plugins['postcss-modules'], postcssModulesConfig);
+      delete config.plugins['postcss-modules'];
+    }
+
+    config.plugins = yield loadPlugins(config.plugins, asset.name);
+
+    if (config.modules || enableModules) {
+      let postcssModules = yield localRequire('postcss-modules', asset.name);
+      config.plugins.push(postcssModules(postcssModulesConfig));
+    }
+
+    if (asset.options.minify) {
+      config.plugins.push(cssnano((yield asset.getConfig(['cssnano.config.js'])) || {
+        // Only enable safe css transforms by default.
+        // See: https://github.com/parcel-bundler/parcel/issues/698
+        // Note: Remove when upgrading cssnano to v4
+        // See: https://github.com/ben-eb/cssnano/releases/tag/v4.0.0-rc.0
+        safe: true
+      }));
+    }
+
+    config.from = asset.name;
+    config.to = asset.name;
+    return config;
+  });
+
+  return function getConfig(_x2) {
+    return _ref2.apply(this, arguments);
+  };
+})();
+
+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 localRequire = require('../utils/localRequire');
+const loadPlugins = require('../utils/loadPlugins');
+const postcss = require('postcss');
+const cssnano = require('cssnano');
+
+module.exports = (() => {
+  var _ref = _asyncToGenerator(function* (asset) {
+    let config = yield getConfig(asset);
+    if (!config) {
+      return;
+    }
+
+    yield asset.parseIfNeeded();
+    let res = yield postcss(config.plugins).process(asset.getCSSAst(), config);
+
+    asset.ast.css = res.css;
+    asset.ast.dirty = false;
+  });
+
+  return function (_x) {
+    return _ref.apply(this, arguments);
+  };
+})();

VISUALIZACION/node_modules/parcel-bundler/lib/transforms/posthtml.js

@@ -0,0 +1,43 @@
+'use strict';
+
+let getConfig = (() => {
+  var _ref2 = _asyncToGenerator(function* (asset) {
+    let config = asset.package.posthtml || (yield asset.getConfig(['.posthtmlrc', '.posthtmlrc.js', 'posthtml.config.js']));
+    if (!config && !asset.options.minify) {
+      return;
+    }
+
+    config = Object.assign({}, config);
+    config.plugins = yield loadPlugins(config.plugins, asset.name);
+    config.skipParse = true;
+    return config;
+  });
+
+  return function getConfig(_x2) {
+    return _ref2.apply(this, arguments);
+  };
+})();
+
+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 loadPlugins = require('../utils/loadPlugins');
+const posthtml = require('posthtml');
+
+module.exports = (() => {
+  var _ref = _asyncToGenerator(function* (asset) {
+    let config = yield getConfig(asset);
+    if (!config) {
+      return;
+    }
+
+    yield asset.parseIfNeeded();
+    let res = yield posthtml(config.plugins).process(asset.ast, config);
+
+    asset.ast = res.tree;
+    asset.isAstDirty = true;
+  });
+
+  return function (_x) {
+    return _ref.apply(this, arguments);
+  };
+})();

VISUALIZACION/node_modules/parcel-bundler/lib/transforms/uglify.js

@@ -0,0 +1,76 @@
+'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"); }); }; }
+
+var _require = require('uglify-es');
+
+const minify = _require.minify;
+
+const SourceMap = require('../SourceMap');
+
+module.exports = (() => {
+  var _ref = _asyncToGenerator(function* (asset) {
+    yield asset.parseIfNeeded();
+
+    // Convert AST into JS
+    let source = (yield asset.generate()).js;
+
+    let customConfig = yield asset.getConfig(['.uglifyrc']);
+    let options = {
+      warnings: true,
+      mangle: {
+        toplevel: true
+      }
+    };
+
+    let sourceMap;
+    if (asset.options.sourceMap) {
+      sourceMap = new SourceMap();
+      options.output = {
+        source_map: {
+          add(source, gen_line, gen_col, orig_line, orig_col, name) {
+            sourceMap.addMapping({
+              source,
+              name,
+              original: {
+                line: orig_line,
+                column: orig_col
+              },
+              generated: {
+                line: gen_line,
+                column: gen_col
+              }
+            });
+          }
+        }
+      };
+    }
+
+    if (customConfig) {
+      options = Object.assign(options, customConfig);
+    }
+
+    let result = minify(source, options);
+
+    if (result.error) {
+      throw result.error;
+    }
+
+    if (sourceMap) {
+      if (asset.sourceMap) {
+        asset.sourceMap = yield new SourceMap().extendSourceMap(asset.sourceMap, sourceMap);
+      } else {
+        asset.sourceMap = sourceMap;
+      }
+    }
+
+    // babel-generator did our code generation for us, so remove the old AST
+    asset.ast = null;
+    asset.outputCode = result.code;
+    asset.isAstDirty = false;
+  });
+
+  return function (_x) {
+    return _ref.apply(this, arguments);
+  };
+})();

VISUALIZACION/node_modules/parcel-bundler/lib/utils/PromiseQueue.js

@@ -0,0 +1,100 @@
+"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"); }); }; }
+
+class PromiseQueue {
+  constructor(callback, options = {}) {
+    this.process = callback;
+    this.maxConcurrent = options.maxConcurrent || Infinity;
+    this.retry = options.retry !== false;
+    this.queue = [];
+    this.processing = new Set();
+    this.processed = new Set();
+    this.numRunning = 0;
+    this.runPromise = null;
+    this.resolve = null;
+    this.reject = null;
+  }
+
+  add(job, ...args) {
+    if (this.processing.has(job)) {
+      return;
+    }
+
+    if (this.runPromise && this.numRunning < this.maxConcurrent) {
+      this._runJob(job, args);
+    } else {
+      this.queue.push([job, args]);
+    }
+
+    this.processing.add(job);
+  }
+
+  run() {
+    if (this.runPromise) {
+      return this.runPromise;
+    }
+
+    const runPromise = new Promise((resolve, reject) => {
+      this.resolve = resolve;
+      this.reject = reject;
+    });
+
+    this.runPromise = runPromise;
+    this._next();
+
+    return runPromise;
+  }
+
+  _runJob(job, args) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      try {
+        _this.numRunning++;
+        yield _this.process(job, ...args);
+        _this.processing.delete(job);
+        _this.processed.add(job);
+        _this.numRunning--;
+        _this._next();
+      } catch (err) {
+        _this.numRunning--;
+        if (_this.retry) {
+          _this.queue.push([job, args]);
+        } else {
+          _this.processing.delete(job);
+        }
+
+        if (_this.reject) {
+          _this.reject(err);
+        }
+
+        _this._reset();
+      }
+    })();
+  }
+
+  _next() {
+    if (!this.runPromise) {
+      return;
+    }
+
+    if (this.queue.length > 0) {
+      while (this.queue.length > 0 && this.numRunning < this.maxConcurrent) {
+        this._runJob(...this.queue.shift());
+      }
+    } else if (this.processing.size === 0) {
+      this.resolve(this.processed);
+      this._reset();
+    }
+  }
+
+  _reset() {
+    this.processed = new Set();
+    this.runPromise = null;
+    this.resolve = null;
+    this.reject = null;
+  }
+}
+
+module.exports = PromiseQueue;

VISUALIZACION/node_modules/parcel-bundler/lib/utils/bundleReport.js

@@ -0,0 +1,140 @@
+'use strict';
+
+const path = require('path');
+const prettifyTime = require('./prettifyTime');
+const logger = require('../Logger');
+const emoji = require('./emoji');
+const filesize = require('filesize');
+
+const LARGE_BUNDLE_SIZE = 1024 * 1024;
+const NUM_LARGE_ASSETS = 10;
+const COLUMNS = [{ align: 'left' }, // name
+{ align: 'right' }, // size
+{ align: 'right' // time
+}];
+
+function bundleReport(mainBundle, detailed = false) {
+  // Get a list of bundles sorted by size
+  let bundles = Array.from(iterateBundles(mainBundle)).sort((a, b) => b.totalSize - a.totalSize);
+  let rows = [];
+
+  var _iteratorNormalCompletion = true;
+  var _didIteratorError = false;
+  var _iteratorError = undefined;
+
+  try {
+    for (var _iterator = bundles[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      let bundle = _step.value;
+
+      // Add a row for the bundle
+      rows.push([formatFilename(bundle.name, logger.chalk.cyan.bold), logger.chalk.bold(prettifySize(bundle.totalSize, bundle.totalSize > LARGE_BUNDLE_SIZE)), logger.chalk.green.bold(prettifyTime(bundle.bundleTime))]);
+
+      // If detailed, generate a list of the top 10 largest assets in the bundle
+      if (detailed && bundle.assets.size > 1) {
+        let assets = Array.from(bundle.assets).filter(a => a.type === bundle.type).sort((a, b) => b.bundledSize - a.bundledSize);
+
+        let largestAssets = assets.slice(0, NUM_LARGE_ASSETS);
+        var _iteratorNormalCompletion2 = true;
+        var _didIteratorError2 = false;
+        var _iteratorError2 = undefined;
+
+        try {
+          for (var _iterator2 = largestAssets[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+            let asset = _step2.value;
+
+            // Add a row for the asset.
+            rows.push([(asset == assets[assets.length - 1] ? '└── ' : '├── ') + formatFilename(asset.name, logger.chalk.reset), logger.chalk.dim(prettifySize(asset.bundledSize)), logger.chalk.dim(logger.chalk.green(prettifyTime(asset.buildTime)))]);
+          }
+
+          // Show how many more assets there are
+        } catch (err) {
+          _didIteratorError2 = true;
+          _iteratorError2 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion2 && _iterator2.return) {
+              _iterator2.return();
+            }
+          } finally {
+            if (_didIteratorError2) {
+              throw _iteratorError2;
+            }
+          }
+        }
+
+        if (assets.length > largestAssets.length) {
+          rows.push(['└── ' + logger.chalk.dim(`+ ${assets.length - largestAssets.length} more assets`)]);
+        }
+
+        // If this isn't the last bundle, add an empty row before the next one
+        if (bundle !== bundles[bundles.length - 1]) {
+          rows.push([]);
+        }
+      }
+    }
+
+    // Render table
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+
+  logger.log('');
+  logger.table(COLUMNS, rows);
+}
+
+module.exports = bundleReport;
+
+function* iterateBundles(bundle) {
+  if (!bundle.isEmpty) {
+    yield bundle;
+  }
+
+  var _iteratorNormalCompletion3 = true;
+  var _didIteratorError3 = false;
+  var _iteratorError3 = undefined;
+
+  try {
+    for (var _iterator3 = bundle.childBundles[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+      let child = _step3.value;
+
+      yield* iterateBundles(child);
+    }
+  } catch (err) {
+    _didIteratorError3 = true;
+    _iteratorError3 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion3 && _iterator3.return) {
+        _iterator3.return();
+      }
+    } finally {
+      if (_didIteratorError3) {
+        throw _iteratorError3;
+      }
+    }
+  }
+}
+
+function prettifySize(size, isLarge) {
+  let res = filesize(size);
+  if (isLarge) {
+    return logger.chalk.yellow(emoji.warning + '  ' + res);
+  }
+  return logger.chalk.magenta(res);
+}
+
+function formatFilename(filename, color = logger.chalk.reset) {
+  let dir = path.relative(process.cwd(), path.dirname(filename));
+  return logger.chalk.dim(dir + (dir ? path.sep : '')) + color(path.basename(filename));
+}

VISUALIZACION/node_modules/parcel-bundler/lib/utils/config.js

@@ -0,0 +1,94 @@
+'use strict';
+
+let resolve = (() => {
+  var _ref = _asyncToGenerator(function* (filepath, filenames, root = path.parse(filepath).root) {
+    filepath = path.dirname(filepath);
+
+    // Don't traverse above the module root
+    if (filepath === root || path.basename(filepath) === 'node_modules') {
+      return null;
+    }
+
+    var _iteratorNormalCompletion = true;
+    var _didIteratorError = false;
+    var _iteratorError = undefined;
+
+    try {
+      for (var _iterator = filenames[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        const filename = _step.value;
+
+        let file = path.join(filepath, filename);
+        let exists = existsCache.has(file) ? existsCache.get(file) : yield fs.exists(file);
+        if (exists) {
+          existsCache.set(file, true);
+          return file;
+        }
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+
+    return resolve(filepath, filenames, root);
+  });
+
+  return function resolve(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+})();
+
+let load = (() => {
+  var _ref2 = _asyncToGenerator(function* (filepath, filenames, root = path.parse(filepath).root) {
+    let configFile = yield resolve(filepath, filenames, root);
+    if (configFile) {
+      try {
+        let extname = path.extname(configFile).slice(1);
+        if (extname === 'js') {
+          return require(configFile);
+        }
+
+        let configContent = (yield fs.readFile(configFile)).toString();
+        let parse = PARSERS[extname] || PARSERS.json;
+        return configContent ? parse(configContent) : null;
+      } catch (err) {
+        if (err.code === 'MODULE_NOT_FOUND' || err.code === 'ENOENT') {
+          existsCache.delete(configFile);
+          return null;
+        }
+
+        throw err;
+      }
+    }
+
+    return null;
+  });
+
+  return function load(_x3, _x4) {
+    return _ref2.apply(this, arguments);
+  };
+})();
+
+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 PARSERS = {
+  json: require('json5').parse,
+  toml: require('toml').parse
+};
+
+const existsCache = new Map();
+
+exports.resolve = resolve;
+exports.load = load;

VISUALIZACION/node_modules/parcel-bundler/lib/utils/customErrors.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const serverErrorList = {
+  EACCES: "You don't have access to bind the server to port {port}.",
+  EADDRINUSE: 'There is already a process listening on port {port}.'
+};
+
+function serverErrors(err, port) {
+  let desc = `Error: ${err.code} occurred while setting up server on port ${port}.`;
+
+  if (serverErrorList[err.code]) {
+    desc = serverErrorList[err.code].replace(/{port}/g, port);
+  }
+
+  return desc;
+}
+
+module.exports.serverErrors = serverErrors;

VISUALIZACION/node_modules/parcel-bundler/lib/utils/deferred.js

@@ -0,0 +1,14 @@
+"use strict";
+
+module.exports = function deferred() {
+  let resolve, reject;
+  let promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+
+  promise.resolve = resolve;
+  promise.reject = reject;
+
+  return promise;
+};

VISUALIZACION/node_modules/parcel-bundler/lib/utils/emoji.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const supportsEmoji = process.platform !== 'win32' || process.env.TERM === 'xterm-256color';
+
+// Fallback symbols for Windows from https://en.wikipedia.org/wiki/Code_page_437
+exports.progress = supportsEmoji ? '⏳' : '∞';
+exports.success = supportsEmoji ? '✨' : '√';
+exports.error = supportsEmoji ? '🚨' : '×';
+exports.warning = supportsEmoji ? '⚠️' : '‼';

VISUALIZACION/node_modules/parcel-bundler/lib/utils/env.js

@@ -0,0 +1,36 @@
+'use strict';
+
+let loadEnv = (() => {
+  var _ref = _asyncToGenerator(function* (filepath) {
+    const NODE_ENV = process.env.NODE_ENV || 'development';
+    const dotenvFiles = [`.env.${NODE_ENV}.local`, `.env.${NODE_ENV}`,
+    // Don't include `.env.local` for `test` environment
+    // since normally you expect tests to produce the same
+    // results for everyone
+    NODE_ENV !== 'test' && '.env.local', '.env'].filter(Boolean);
+
+    yield Promise.all(dotenvFiles.map((() => {
+      var _ref2 = _asyncToGenerator(function* (dotenvFile) {
+        const envPath = yield config.resolve(filepath, [dotenvFile]);
+        if (envPath) {
+          dotenv.config({ path: envPath });
+        }
+      });
+
+      return function (_x2) {
+        return _ref2.apply(this, arguments);
+      };
+    })()));
+  });
+
+  return function loadEnv(_x) {
+    return _ref.apply(this, arguments);
+  };
+})();
+
+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 config = require('./config');
+const dotenv = require('dotenv');
+
+module.exports = loadEnv;

VISUALIZACION/node_modules/parcel-bundler/lib/utils/fs.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const promisify = require('./promisify');
+const fs = require('fs');
+const mkdirp = require('mkdirp');
+
+exports.readFile = promisify(fs.readFile);
+exports.writeFile = promisify(fs.writeFile);
+exports.stat = promisify(fs.stat);
+exports.readdir = promisify(fs.readdir);
+exports.unlink = promisify(fs.unlink);
+exports.realpath = promisify(fs.realpath);
+
+exports.exists = function (filename) {
+  return new Promise(resolve => {
+    fs.exists(filename, resolve);
+  });
+};
+
+exports.mkdirp = promisify(mkdirp);

VISUALIZACION/node_modules/parcel-bundler/lib/utils/generateCertificate.js

@@ -0,0 +1,114 @@
+'use strict';
+
+const forge = require('node-forge');
+const fs = require('fs');
+const mkdirp = require('mkdirp');
+const path = require('path');
+const logger = require('../Logger');
+
+function generateCertificate(options = {}) {
+  const privateKeyPath = path.join(options.cacheDir, 'private.pem');
+  const certPath = path.join(options.cacheDir, 'primary.crt');
+  if (options.cache) {
+    const cachedKey = fs.existsSync(privateKeyPath) && fs.readFileSync(privateKeyPath);
+    const cachedCert = fs.existsSync(certPath) && fs.readFileSync(certPath);
+
+    if (cachedKey && cachedCert) {
+      return {
+        key: cachedKey,
+        cert: cachedCert
+      };
+    }
+  }
+
+  logger.log('Generating SSL Certificate...');
+
+  const pki = forge.pki;
+  const keys = pki.rsa.generateKeyPair(2048);
+  const cert = pki.createCertificate();
+
+  cert.publicKey = keys.publicKey;
+  cert.serialNumber = '01';
+  cert.validity.notBefore = new Date();
+  cert.validity.notAfter = new Date();
+  cert.validity.notAfter.setFullYear(cert.validity.notBefore.getFullYear() + 1);
+
+  const attrs = [{
+    name: 'commonName',
+    value: 'parceljs.org'
+  }, {
+    name: 'countryName',
+    value: 'US'
+  }, {
+    shortName: 'ST',
+    value: 'Virginia'
+  }, {
+    name: 'localityName',
+    value: 'Blacksburg'
+  }, {
+    name: 'organizationName',
+    value: 'parcelBundler'
+  }, {
+    shortName: 'OU',
+    value: 'Test'
+  }];
+
+  cert.setSubject(attrs);
+  cert.setIssuer(attrs);
+  cert.setExtensions([{
+    name: 'basicConstraints',
+    cA: true
+  }, {
+    name: 'keyUsage',
+    keyCertSign: true,
+    digitalSignature: true,
+    nonRepudiation: true,
+    keyEncipherment: true,
+    dataEncipherment: true
+  }, {
+    name: 'extKeyUsage',
+    serverAuth: true,
+    clientAuth: true,
+    codeSigning: true,
+    emailProtection: true,
+    timeStamping: true
+  }, {
+    name: 'nsCertType',
+    client: true,
+    server: true,
+    email: true,
+    objsign: true,
+    sslCA: true,
+    emailCA: true,
+    objCA: true
+  }, {
+    name: 'subjectAltName',
+    altNames: [{
+      type: 6, // URI
+      value: 'http://example.org/webid#me'
+    }, {
+      type: 7, // IP
+      ip: '127.0.0.1'
+    }]
+  }, {
+    name: 'subjectKeyIdentifier'
+  }]);
+
+  cert.sign(keys.privateKey, forge.md.sha256.create());
+
+  const privPem = pki.privateKeyToPem(keys.privateKey);
+  const certPem = pki.certificateToPem(cert);
+
+  if (options.cache) {
+    mkdirp.sync(options.cacheDir);
+    fs.writeFileSync(privateKeyPath, privPem);
+    fs.writeFileSync(certPath, certPem);
+  }
+
+  return {
+    key: privPem,
+    cert: certPem
+  };
+}
+
+module.exports = generateCertificate;

VISUALIZACION/node_modules/parcel-bundler/lib/utils/getCertificate.js

@@ -0,0 +1,23 @@
+'use strict';
+
+let getCertificate = (() => {
+  var _ref = _asyncToGenerator(function* (options) {
+    try {
+      let cert = yield fs.readFile(options.cert);
+      let key = yield fs.readFile(options.key);
+      return { key, cert };
+    } catch (err) {
+      throw new Error('Certificate and/or key not found');
+    }
+  });
+
+  return function getCertificate(_x) {
+    return _ref.apply(this, arguments);
+  };
+})();
+
+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');
+
+module.exports = getCertificate;

VISUALIZACION/node_modules/parcel-bundler/lib/utils/getRootDir.js

@@ -0,0 +1,54 @@
+'use strict';
+
+const path = require('path');
+
+function getRootDir(files) {
+  let cur = null;
+
+  var _iteratorNormalCompletion = true;
+  var _didIteratorError = false;
+  var _iteratorError = undefined;
+
+  try {
+    for (var _iterator = files[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      let file = _step.value;
+
+      let parsed = path.parse(file);
+      if (!cur) {
+        cur = parsed;
+      } else if (parsed.root !== cur.root) {
+        // bail out. there is no common root.
+        // this can happen on windows, e.g. C:\foo\bar vs. D:\foo\bar
+        return process.cwd();
+      } else {
+        // find the common path parts.
+        let curParts = cur.dir.split(path.sep);
+        let newParts = parsed.dir.split(path.sep);
+        let len = Math.min(curParts.length, newParts.length);
+        let i = 0;
+        while (i < len && curParts[i] === newParts[i]) {
+          i++;
+        }
+
+        cur.dir = i > 1 ? curParts.slice(0, i).join(path.sep) : cur.root;
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+
+  return cur ? cur.dir : process.cwd();
+}
+
+module.exports = getRootDir;

VISUALIZACION/node_modules/parcel-bundler/lib/utils/getTargetEngines.js

@@ -0,0 +1,135 @@
+'use strict';
+
+/**
+ * Loads target node and browser versions from the following locations:
+ *   - package.json engines field
+ *   - package.json browserslist field
+ *   - browserslist or .browserslistrc files
+ *   - .babelrc or .babelrc.js files with babel-preset-env
+ */
+let getTargetEngines = (() => {
+  var _ref = _asyncToGenerator(function* (asset, isTargetApp) {
+    let targets = {};
+    let path = isTargetApp ? Path.join(asset.options.rootDir, 'index') : asset.name;
+    let compileTarget = asset.options.target === 'browser' ? 'browsers' : asset.options.target;
+    let pkg = yield asset.getConfig(['package.json'], { path });
+    let engines = pkg && pkg.engines;
+    let nodeVersion = engines && getMinSemver(engines.node);
+
+    if (compileTarget === 'node') {
+      // Use package.engines.node by default if we are compiling for node.
+      if (typeof nodeVersion === 'string') {
+        targets.node = nodeVersion;
+      }
+    } else {
+      if (engines && (typeof engines.browsers === 'string' || Array.isArray(engines.browsers))) {
+        targets.browsers = engines.browsers;
+      } else if (pkg && pkg.browserslist) {
+        targets.browsers = pkg.browserslist;
+      } else {
+        let browserslist = yield loadBrowserslist(asset, path);
+        if (browserslist) {
+          targets.browsers = browserslist;
+        } else {
+          let babelTargets = yield loadBabelrc(asset, path);
+          if (babelTargets && babelTargets.browsers) {
+            targets.browsers = babelTargets.browsers;
+          } else if (babelTargets && babelTargets.node && !nodeVersion) {
+            nodeVersion = babelTargets.node;
+          }
+        }
+      }
+
+      // Fall back to package.engines.node for node_modules without any browser target info.
+      if (!isTargetApp && !targets.browsers && typeof nodeVersion === 'string') {
+        targets.node = nodeVersion;
+      }
+    }
+
+    // If we didn't find any targets, set some default engines for the target app.
+    if (isTargetApp && !targets[compileTarget] && DEFAULT_ENGINES[compileTarget]) {
+      targets[compileTarget] = DEFAULT_ENGINES[compileTarget];
+    }
+
+    // Parse browser targets
+    if (targets.browsers) {
+      if (typeof targets.browsers === 'object' && !Array.isArray(targets.browsers)) {
+        let env = asset.options.production ? 'production' : process.env.NODE_ENV || 'development';
+        targets.browsers = targets.browsers[env] || targets.browsers.defaults;
+      }
+
+      if (targets.browsers) {
+        targets.browsers = browserslist(targets.browsers).sort();
+      }
+    }
+
+    // Dont compile if we couldn't find any targets
+    if (Object.keys(targets).length === 0) {
+      return null;
+    }
+
+    return targets;
+  });
+
+  return function getTargetEngines(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+})();
+
+let loadBrowserslist = (() => {
+  var _ref2 = _asyncToGenerator(function* (asset, path) {
+    let config = yield asset.getConfig(['browserslist', '.browserslistrc'], {
+      path,
+      load: false
+    });
+
+    if (config) {
+      return browserslist.readConfig(config);
+    }
+  });
+
+  return function loadBrowserslist(_x3, _x4) {
+    return _ref2.apply(this, arguments);
+  };
+})();
+
+let loadBabelrc = (() => {
+  var _ref3 = _asyncToGenerator(function* (asset, path) {
+    let config = yield asset.getConfig(['.babelrc', '.babelrc.js'], { path });
+    if (config && config.presets) {
+      let env = config.presets.find(function (plugin) {
+        return Array.isArray(plugin) && (plugin[0] === 'env' || plugin[0] === '@babel/env');
+      });
+      if (env && env[1] && env[1].targets) {
+        return env[1].targets;
+      }
+    }
+  });
+
+  return function loadBabelrc(_x5, _x6) {
+    return _ref3.apply(this, arguments);
+  };
+})();
+
+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 browserslist = require('browserslist');
+const semver = require('semver');
+const Path = require('path');
+
+const DEFAULT_ENGINES = {
+  browsers: ['> 0.25%'],
+  node: '6'
+};
+
+function getMinSemver(version) {
+  try {
+    let range = new semver.Range(version);
+    let sorted = range.set.sort((a, b) => a[0].semver.compare(b[0].semver));
+    return sorted[0][0].semver.version;
+  } catch (err) {
+    return null;
+  }
+}
+
+module.exports = getTargetEngines;

VISUALIZACION/node_modules/parcel-bundler/lib/utils/installPackage.js

@@ -0,0 +1,141 @@
+'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"); } }; }();
+
+let install = (() => {
+  var _ref = _asyncToGenerator(function* (modules, filepath, options = {}) {
+    var _options$installPeers = options.installPeers;
+    let installPeers = _options$installPeers === undefined ? true : _options$installPeers;
+    var _options$saveDev = options.saveDev;
+    let saveDev = _options$saveDev === undefined ? true : _options$saveDev,
+        packageManager = options.packageManager;
+
+
+    logger.status(emoji.progress, `Installing ${modules.join(', ')}...`);
+
+    let packageLocation = yield config.resolve(filepath, ['package.json']);
+    let cwd = packageLocation ? path.dirname(packageLocation) : process.cwd();
+
+    if (!packageManager) {
+      packageManager = yield determinePackageManager(filepath);
+    }
+
+    let commandToUse = packageManager === 'npm' ? 'install' : 'add';
+    let args = [commandToUse, ...modules];
+    if (saveDev) {
+      args.push('-D');
+    } else if (packageManager === 'npm') {
+      args.push('--save');
+    }
+
+    // npm doesn't auto-create a package.json when installing,
+    // so create an empty one if needed.
+    if (packageManager === 'npm' && !packageLocation) {
+      yield fs.writeFile(path.join(cwd, 'package.json'), '{}');
+    }
+
+    try {
+      yield pipeSpawn(packageManager, args, { cwd });
+    } catch (err) {
+      throw new Error(`Failed to install ${modules.join(', ')}.`);
+    }
+
+    if (installPeers) {
+      yield Promise.all(modules.map(function (m) {
+        return installPeerDependencies(filepath, m, options);
+      }));
+    }
+  });
+
+  return function install(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+})();
+
+let installPeerDependencies = (() => {
+  var _ref2 = _asyncToGenerator(function* (filepath, name, options) {
+    let basedir = path.dirname(filepath);
+
+    var _ref3 = yield resolve(name, { basedir }),
+        _ref4 = _slicedToArray(_ref3, 1);
+
+    const resolved = _ref4[0];
+
+    const pkg = yield config.load(resolved, ['package.json']);
+    const peers = pkg.peerDependencies || {};
+
+    const modules = [];
+    for (const peer in peers) {
+      modules.push(`${peer}@${peers[peer]}`);
+    }
+
+    if (modules.length) {
+      yield install(modules, filepath, Object.assign({}, options, { installPeers: false }));
+    }
+  });
+
+  return function installPeerDependencies(_x3, _x4, _x5) {
+    return _ref2.apply(this, arguments);
+  };
+})();
+
+let determinePackageManager = (() => {
+  var _ref5 = _asyncToGenerator(function* (filepath) {
+    let configFile = yield config.resolve(filepath, ['yarn.lock', 'package-lock.json']);
+    let hasYarn = yield checkForYarnCommand();
+
+    // If Yarn isn't available, or there is a package-lock.json file, use npm.
+    let configName = configFile && path.basename(configFile);
+    if (!hasYarn || configName === 'package-lock.json') {
+      return 'npm';
+    }
+
+    return 'yarn';
+  });
+
+  return function determinePackageManager(_x6) {
+    return _ref5.apply(this, arguments);
+  };
+})();
+
+let checkForYarnCommand = (() => {
+  var _ref6 = _asyncToGenerator(function* () {
+    if (hasYarn != null) {
+      return hasYarn;
+    }
+
+    try {
+      hasYarn = yield commandExists('yarn');
+    } catch (err) {
+      hasYarn = false;
+    }
+
+    return hasYarn;
+  });
+
+  return function checkForYarnCommand() {
+    return _ref6.apply(this, arguments);
+  };
+})();
+
+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 config = require('./config');
+const promisify = require('./promisify');
+const resolve = promisify(require('resolve'));
+const commandExists = require('command-exists');
+const logger = require('../Logger');
+const emoji = require('./emoji');
+const pipeSpawn = require('./pipeSpawn');
+const PromiseQueue = require('./PromiseQueue');
+const path = require('path');
+const fs = require('./fs');
+
+let hasYarn = null;
+
+
+let queue = new PromiseQueue(install, { maxConcurrent: 1, retry: false });
+module.exports = function (...args) {
+  queue.add(...args);
+  return queue.run();
+};

VISUALIZACION/node_modules/parcel-bundler/lib/utils/is-url.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const isURL = require('is-url');
+
+// Matches anchor (ie: #raptors)
+const ANCHOR_REGEXP = /^#/;
+
+// Matches scheme (ie: tel:, mailto:, data:, itms-apps:)
+const SCHEME_REGEXP = /^[a-z][a-z0-9\-+.]*:/i;
+
+module.exports = function (url) {
+  return isURL(url) || ANCHOR_REGEXP.test(url) || SCHEME_REGEXP.test(url);
+};

VISUALIZACION/node_modules/parcel-bundler/lib/utils/lineCounter.js

@@ -0,0 +1,14 @@
+'use strict';
+
+function lineCounter(string) {
+  let lines = 1;
+  for (let i = 0; i < string.length; i++) {
+    if (string.charAt(i) === '\n') {
+      lines++;
+    }
+  }
+
+  return lines;
+}
+
+module.exports = lineCounter;

VISUALIZACION/node_modules/parcel-bundler/lib/utils/loadPlugins.js

@@ -0,0 +1,65 @@
+'use strict';
+
+let loadPlugin = (() => {
+  var _ref4 = _asyncToGenerator(function* (plugin, relative, options) {
+    if (typeof plugin === 'string') {
+      plugin = yield localRequire(plugin, relative);
+      plugin = plugin.default || plugin;
+
+      if (typeof options !== 'object') {
+        options = {};
+      }
+
+      if (Object.keys(options).length > 0) {
+        plugin = plugin(options);
+      }
+
+      plugin = plugin.default || plugin;
+    }
+
+    return plugin;
+  });
+
+  return function loadPlugin(_x5, _x6, _x7) {
+    return _ref4.apply(this, arguments);
+  };
+})();
+
+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 localRequire = require('./localRequire');
+
+module.exports = (() => {
+  var _ref = _asyncToGenerator(function* (plugins, relative) {
+    if (Array.isArray(plugins)) {
+      return yield Promise.all(plugins.map((() => {
+        var _ref2 = _asyncToGenerator(function* (p) {
+          return yield loadPlugin(p, relative);
+        });
+
+        return function (_x3) {
+          return _ref2.apply(this, arguments);
+        };
+      })()).filter(Boolean));
+    } else if (typeof plugins === 'object') {
+      let mapPlugins = yield Promise.all(Object.keys(plugins).map((() => {
+        var _ref3 = _asyncToGenerator(function* (p) {
+          return yield loadPlugin(p, relative, plugins[p]);
+        });
+
+        return function (_x4) {
+          return _ref3.apply(this, arguments);
+        };
+      })()));
+      return mapPlugins.filter(Boolean);
+    } else {
+      return [];
+    }
+  });
+
+  function loadPlugins(_x, _x2) {
+    return _ref.apply(this, arguments);
+  }
+
+  return loadPlugins;
+})();

VISUALIZACION/node_modules/parcel-bundler/lib/utils/localRequire.js

@@ -0,0 +1,43 @@
+'use strict';
+
+let localRequire = (() => {
+  var _ref = _asyncToGenerator(function* (name, path, triedInstall = false) {
+    let basedir = dirname(path);
+    let key = basedir + ':' + name;
+    let resolved = cache.get(key);
+    if (!resolved) {
+      try {
+        resolved = resolve.sync(name, { basedir });
+      } catch (e) {
+        if (e.code === 'MODULE_NOT_FOUND' && !triedInstall) {
+          yield worker.addCall({
+            location: require.resolve('./installPackage.js'),
+            args: [[name], path]
+          });
+          return localRequire(name, path, true);
+        }
+        throw e;
+      }
+      cache.set(key, resolved);
+    }
+
+    return require(resolved);
+  });
+
+  return function localRequire(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+})();
+
+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"); }); }; }
+
+var _require = require('path');
+
+const dirname = _require.dirname;
+
+const resolve = require('resolve');
+const worker = require('../worker');
+
+const cache = new Map();
+
+module.exports = localRequire;

VISUALIZACION/node_modules/parcel-bundler/lib/utils/md5.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+
+function md5(string) {
+  return crypto.createHash('md5').update(string).digest('hex');
+}
+
+md5.file = function (filename) {
+  return new Promise((resolve, reject) => {
+    fs.createReadStream(filename).pipe(crypto.createHash('md5').setEncoding('hex')).on('finish', function () {
+      resolve(this.read());
+    }).on('error', reject);
+  });
+};
+
+module.exports = md5;

VISUALIZACION/node_modules/parcel-bundler/lib/utils/objectHash.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const crypto = require('crypto');
+
+function objectHash(object) {
+  let hash = crypto.createHash('md5');
+  var _iteratorNormalCompletion = true;
+  var _didIteratorError = false;
+  var _iteratorError = undefined;
+
+  try {
+    for (var _iterator = Object.keys(object).sort()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      let key = _step.value;
+
+      let val = object[key];
+      if (typeof val === 'object' && val) {
+        hash.update(key + objectHash(val));
+      } else {
+        hash.update(key + val);
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+
+  return hash.digest('hex');
+}
+
+module.exports = objectHash;

VISUALIZACION/node_modules/parcel-bundler/lib/utils/openInBrowser.js

@@ -0,0 +1,24 @@
+'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 opn = require('opn');
+
+const openInBrowser = (() => {
+  var _ref = _asyncToGenerator(function* (url, browser) {
+    try {
+      const options = typeof browser === 'string' ? { app: browser } : undefined;
+
+      yield opn(url, options);
+    } catch (err) {
+      console.error(`Unexpected error while opening in browser: ${browser}`);
+      console.error(err);
+    }
+  });
+
+  return function openInBrowser(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+})();
+
+module.exports = openInBrowser;

VISUALIZACION/node_modules/parcel-bundler/lib/utils/pipeSpawn.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const spawn = require('cross-spawn');
+const logger = require('../Logger');
+
+function pipeSpawn(cmd, params, opts) {
+  const cp = spawn(cmd, params, Object.assign({
+    env: Object.assign({
+      FORCE_COLOR: logger.color,
+      npm_config_color: logger.color ? 'always' : '',
+      npm_config_progress: true
+    }, process.env)
+  }, opts));
+
+  cp.stdout.setEncoding('utf8').on('data', d => logger.writeRaw(d));
+  cp.stderr.setEncoding('utf8').on('data', d => logger.writeRaw(d));
+
+  return new Promise((resolve, reject) => {
+    cp.on('error', reject);
+    cp.on('close', function (code) {
+      if (code !== 0) {
+        return reject(new Error(cmd + ' failed.'));
+      }
+
+      logger.clear();
+      return resolve();
+    });
+  });
+}
+
+module.exports = pipeSpawn;