flow like the river

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;

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

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function (time) {
+  return time < 1000 ? `${time}ms` : `${(time / 1000).toFixed(2)}s`;
+};

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

@@ -0,0 +1,26 @@
+'use strict';
+
+module.exports = function (err, opts = {}) {
+  let message = typeof err === 'string' ? err : err.message;
+  if (!message) {
+    message = 'Unknown error';
+  }
+
+  if (err.fileName) {
+    let fileName = err.fileName;
+    if (err.loc) {
+      fileName += `:${err.loc.line}:${err.loc.column}`;
+    }
+
+    message = `${fileName}: ${message}`;
+  }
+
+  let stack;
+  if (err.codeFrame) {
+    stack = opts.color && err.highlightedCodeFrame || err.codeFrame;
+  } else if (err.stack) {
+    stack = err.stack.slice(err.stack.indexOf('\n') + 1);
+  }
+
+  return { message, stack };
+};

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

@@ -0,0 +1,15 @@
+"use strict";
+
+module.exports = function (fn) {
+  return function (...args) {
+    return new Promise(function (resolve, reject) {
+      fn(...args, function (err, ...res) {
+        if (err) return reject(err);
+
+        if (res.length === 1) return resolve(res[0]);
+
+        resolve(res);
+      });
+    });
+  };
+};

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

@@ -0,0 +1,27 @@
+'use strict';
+
+var _require = require('uglify-es');
+
+const minify = _require.minify;
+
+var _require2 = require('serialize-to-js');
+
+const serialize = _require2.serialize;
+
+
+function serializeObject(obj, shouldMinify = false) {
+  let code = `module.exports = ${serialize(obj)};`;
+
+  if (shouldMinify) {
+    let minified = minify(code);
+    if (minified.error) {
+      throw minified.error;
+    }
+
+    code = minified.code;
+  }
+
+  return code;
+}
+
+module.exports = serializeObject;

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

@@ -0,0 +1,30 @@
+'use strict';
+
+const deasync = require('deasync');
+
+/**
+ * Synchronously waits for a promise to return by
+ * yielding to the node event loop as needed.
+ */
+function syncPromise(promise) {
+  let isDone = false;
+  let res, err;
+
+  promise.then(value => {
+    res = value;
+    isDone = true;
+  }, error => {
+    err = error;
+    isDone = true;
+  });
+
+  deasync.loopWhile(() => !isDone);
+
+  if (err) {
+    throw err;
+  }
+
+  return res;
+}
+
+module.exports = syncPromise;

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

@@ -0,0 +1,17 @@
+'use strict';
+
+const URL = require('url');
+const path = require('path');
+
+/**
+ * Joins a path onto a URL, and normalizes Windows paths
+ * e.g. from \path\to\res.js to /path/to/res.js.
+ */
+module.exports = function (publicURL, assetPath) {
+  const url = URL.parse(publicURL, false, true);
+  const assetUrl = URL.parse(assetPath);
+  url.pathname = path.posix.join(url.pathname, assetUrl.pathname);
+  url.search = assetUrl.search;
+  url.hash = assetUrl.hash;
+  return URL.format(url);
+};