flow like the river

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

@@ -0,0 +1,287 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _toArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toArray"));
+
+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 SourceMap = require('../SourceMap');
+
+const loadSourceMap = require('../utils/loadSourceMap');
+
+const path = require('path');
+
+const urlJoin = require('../utils/urlJoin');
+
+const isURL = require('../utils/is-url');
+
+const URL_RE = /url\s*\("?(?![a-z]+:)/;
+const IMPORT_RE = /@import/;
+const COMPOSES_RE = /composes:.+from\s*("|').*("|')\s*;?/;
+const FROM_IMPORT_RE = /.+from\s*(?:"|')(.*)(?:"|')\s*;?/;
+const PROTOCOL_RE = /^[a-z]+:/;
+
+class CSSAsset extends Asset {
+  constructor(name, options) {
+    super(name, options);
+    this.type = 'css';
+    this.previousSourceMap = this.options.rendition ? this.options.rendition.map : null;
+  }
+
+  mightHaveDependencies() {
+    return !/\.css$/.test(this.name) || IMPORT_RE.test(this.contents) || COMPOSES_RE.test(this.contents) || URL_RE.test(this.contents);
+  }
+
+  parse(code) {
+    let root = postcss.parse(code, {
+      from: this.name
+    });
+    return new CSSAst(code, root);
+  }
+
+  collectDependencies() {
+    this.ast.root.walkAtRules('import', rule => {
+      let params = valueParser(rule.params);
+
+      let _params$nodes = (0, _toArray2.default)(params.nodes),
+          name = _params$nodes[0],
+          media = _params$nodes.slice(1);
+
+      let dep;
+
+      if (name.type === 'function' && name.value === 'url' && name.nodes.length) {
+        name = name.nodes[0];
+      }
+
+      dep = name.value;
+
+      if (!dep) {
+        throw new Error('Could not find import name for ' + rule);
+      }
+
+      if (PROTOCOL_RE.test(dep)) {
+        return;
+      } // If this came from an inline <style> tag, don't inline the imported file. Replace with the correct URL instead.
+      // TODO: run CSSPackager on inline style tags.
+
+
+      let inlineHTML = this.options.rendition && this.options.rendition.inlineHTML;
+
+      if (inlineHTML) {
+        name.value = this.addURLDependency(dep, {
+          loc: rule.source.start
+        });
+        rule.params = params.toString();
+      } else {
+        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
+            });
+
+            if (!isURL(url)) {
+              url = urlJoin(this.options.publicURL, url);
+            }
+
+            dirty = node.nodes[0].value !== url;
+            node.nodes[0].value = url;
+          }
+        });
+
+        if (dirty) {
+          decl.value = parsed.toString();
+          this.ast.dirty = true;
+        }
+      }
+
+      if (decl.prop === 'composes' && FROM_IMPORT_RE.test(decl.value)) {
+        let parsed = valueParser(decl.value);
+        parsed.walk(node => {
+          if (node.type === 'string') {
+            const _FROM_IMPORT_RE$exec = FROM_IMPORT_RE.exec(decl.value),
+                  _FROM_IMPORT_RE$exec2 = (0, _slicedToArray2.default)(_FROM_IMPORT_RE$exec, 2),
+                  importPath = _FROM_IMPORT_RE$exec2[1];
+
+            this.addURLDependency(importPath, {
+              dynamic: false,
+              loc: decl.source.start
+            });
+          }
+        });
+      }
+    });
+  }
+
+  pretransform() {
+    var _this = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      if (_this.options.sourceMaps && !_this.previousSourceMap) {
+        _this.previousSourceMap = yield loadSourceMap(_this);
+      }
+    })();
+  }
+
+  transform() {
+    var _this2 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      yield postcssTransform(_this2);
+    })();
+  }
+
+  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(this.name));
+    }
+
+    return this.ast.root;
+  }
+
+  generate() {
+    var _this3 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      let css;
+
+      if (_this3.ast) {
+        let result = _this3.ast.render(_this3.name);
+
+        css = result.css;
+        if (result.map) _this3.sourceMap = result.map;
+      } else {
+        css = _this3.contents;
+      }
+
+      let js = '';
+
+      if (_this3.options.hmr) {
+        _this3.addDependency('_css_loader');
+
+        js = `
+        var reloadCSS = require('_css_loader');
+        module.hot.dispose(reloadCSS);
+        module.hot.accept(reloadCSS);
+      `;
+      }
+
+      if (_this3.cssModules) {
+        js += 'module.exports = ' + JSON.stringify(_this3.cssModules, null, 2) + ';';
+      }
+
+      if (_this3.options.sourceMaps) {
+        if (_this3.sourceMap) {
+          _this3.sourceMap = yield new SourceMap().addMap(_this3.sourceMap);
+        }
+
+        if (_this3.previousSourceMap) {
+          _this3.previousSourceMap.sources = _this3.previousSourceMap.sources.map(v => path.join(path.dirname(_this3.relativeName), _this3.previousSourceMap.sourceRoot || '', v));
+
+          if (_this3.sourceMap) {
+            _this3.sourceMap = yield new SourceMap().extendSourceMap(_this3.previousSourceMap, _this3.sourceMap);
+          } else {
+            _this3.sourceMap = yield new SourceMap().addMap(_this3.previousSourceMap);
+          }
+        } else if (!_this3.sourceMap) {
+          _this3.sourceMap = new SourceMap().generateEmptyMap(_this3.relativeName, css);
+        }
+      }
+
+      return [{
+        type: 'css',
+        value: css,
+        cssModules: _this3.cssModules,
+        map: _this3.sourceMap
+      }, {
+        type: 'js',
+        value: js,
+        hasDependencies: false
+      }];
+    })();
+  }
+
+  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(name) {
+    if (this.dirty) {
+      let _this$root$toResult = this.root.toResult({
+        to: name,
+        map: {
+          inline: false,
+          annotation: false,
+          sourcesContent: true
+        }
+      }),
+          css = _this$root$toResult.css,
+          map = _this$root$toResult.map;
+
+      this.css = css;
+      return {
+        css: this.css,
+        map: map ? map.toJSON() : null
+      };
+    }
+
+    return {
+      css: this.css
+    };
+  }
+
+}
+
+module.exports = CSSAsset;

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

@@ -0,0 +1,45 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+const Asset = require('../Asset');
+
+const localRequire = require('../utils/localRequire');
+
+class CoffeeScriptAsset extends Asset {
+  constructor(name, options) {
+    super(name, options);
+    this.type = 'js';
+  }
+
+  generate() {
+    var _this = this;
+
+    return (0, _asyncToGenerator2.default)(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,
+        map: sourceMap
+      }];
+    })();
+  }
+
+}
+
+module.exports = CoffeeScriptAsset;

BACK_BACK/node_modules/parcel-bundler/lib/assets/ElmAsset.js

@@ -0,0 +1,172 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+const Asset = require('../Asset');
+
+const commandExists = require('command-exists');
+
+const localRequire = require('../utils/localRequire');
+
+const _require = require('terser'),
+      minify = _require.minify;
+
+const path = require('path');
+
+const spawn = require('cross-spawn');
+
+class ElmAsset extends Asset {
+  constructor(name, options) {
+    super(name, options);
+    this.type = 'js';
+  }
+
+  parse() {
+    var _this = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      let options = {
+        cwd: path.dirname(_this.name)
+      }; // If elm is not installed globally, install it locally.
+
+      try {
+        yield commandExists('elm');
+      } catch (err) {
+        yield localRequire('elm', _this.name);
+        options.pathToElm = path.join(path.dirname(require.resolve('elm')), 'bin', 'elm');
+      }
+
+      _this.elm = yield localRequire('node-elm-compiler', _this.name); // Ensure that an elm.json file exists, and initialize one if not.
+
+      let elmConfig = yield _this.getConfig(['elm.json'], {
+        load: false
+      });
+
+      if (!elmConfig) {
+        yield _this.createElmConfig(options); // Ensure we are watching elm.json for changes
+
+        yield _this.getConfig(['elm.json'], {
+          load: false
+        });
+      }
+
+      options.debug = !_this.options.production;
+
+      if (_this.options.minify) {
+        options.optimize = true;
+      }
+
+      _this.elmOpts = options;
+    })();
+  }
+
+  collectDependencies() {
+    var _this2 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      let dependencies = yield _this2.elm.findAllDependencies(_this2.name);
+
+      var _iterator = _createForOfIteratorHelper(dependencies),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          let dependency = _step.value;
+
+          _this2.addDependency(dependency, {
+            includedInParent: true
+          });
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    })();
+  }
+
+  createElmConfig(options) {
+    return (0, _asyncToGenerator2.default)(function* () {
+      let cp = spawn(options.pathToElm || 'elm', ['init']);
+      cp.stdin.write('y\n');
+      return new Promise((resolve, reject) => {
+        cp.on('error', reject);
+        cp.on('close', function (code) {
+          if (code !== 0) {
+            return reject(new Error('elm init failed.'));
+          }
+
+          return resolve();
+        });
+      });
+    })();
+  }
+
+  generate() {
+    var _this3 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      let compiled = yield _this3.elm.compileToString(_this3.name, _this3.elmOpts);
+      _this3.contents = compiled.toString();
+
+      if (_this3.options.hmr) {
+        let _yield$localRequire = yield localRequire('elm-hot', _this3.name),
+            inject = _yield$localRequire.inject;
+
+        _this3.contents = inject(_this3.contents);
+      }
+
+      let output = _this3.contents;
+
+      if (_this3.options.minify) {
+        output = pack(output);
+      }
+
+      return {
+        [_this3.type]: output
+      }; // Recommended minification
+      // Based on:
+      // - http://elm-lang.org/0.19.0/optimize
+
+      function pack(source) {
+        let options = {
+          compress: {
+            keep_fargs: false,
+            passes: 2,
+            pure_funcs: ['F2', 'F3', 'F4', 'F5', 'F6', 'F7', 'F8', 'F9', 'A2', 'A3', 'A4', 'A5', 'A6', 'A7', 'A8', 'A9'],
+            pure_getters: true,
+            unsafe: true,
+            unsafe_comps: true
+          },
+          mangle: true,
+          rename: false
+        };
+        let result = minify(source, options);
+
+        if (result.error) {
+          throw result.error;
+        }
+
+        return result.code;
+      }
+    })();
+  }
+
+  generateErrorMessage(err) {
+    // The generated stack is not useful, but other code may
+    // expect it and try to print it, so make it an empty string.
+    err.stack = '';
+    return err;
+  }
+
+}
+
+module.exports = ElmAsset;

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

@@ -0,0 +1,100 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+const Asset = require('../Asset');
+
+const localRequire = require('../utils/localRequire');
+
+const path = require('path');
+
+const _require = require('@parcel/utils'),
+      promisify = _require.promisify;
+
+const Resolver = require('../Resolver');
+
+class GLSLAsset extends Asset {
+  constructor(name, options) {
+    super(name, options);
+    this.type = 'js';
+  }
+
+  parse() {
+    var _this = this;
+
+    return (0, _asyncToGenerator2.default)(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 aliases, 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: function () {
+          var _resolve = (0, _asyncToGenerator2.default)(function* (target, opts, next) {
+            try {
+              let res = yield resolver.resolve(target, path.join(opts.basedir, 'index'));
+              next(null, res.path);
+            } catch (err) {
+              next(err);
+            }
+          });
+
+          function resolve(_x, _x2, _x3) {
+            return _resolve.apply(this, arguments);
+          }
+
+          return resolve;
+        }()
+      });
+      return promisify(depper.inline.bind(depper))(_this.contents, cwd);
+    })();
+  }
+
+  collectDependencies() {
+    var _iterator = _createForOfIteratorHelper(this.ast),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        let dep = _step.value;
+
+        if (!dep.entry) {
+          this.addDependency(dep.file, {
+            includedInParent: true
+          });
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+
+  generate() {
+    var _this2 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      // Generate the bundled glsl file
+      const glslifyBundle = yield localRequire('glslify-bundle', _this2.name);
+      let glsl = glslifyBundle(_this2.ast);
+      return `module.exports=${JSON.stringify(glsl)};`;
+    })();
+  }
+
+}
+
+module.exports = GLSLAsset;

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

@@ -0,0 +1,109 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+const Asset = require('../Asset');
+
+const micromatch = require('micromatch');
+
+const path = require('path');
+
+const _require = require('../utils/glob'),
+      glob = _require.glob;
+
+class GlobAsset extends Asset {
+  constructor(name, options) {
+    super(name, options);
+    this.type = null; // allows this asset to be included in any type bundle
+  }
+
+  load() {
+    var _this = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      let regularExpressionSafeName = _this.name;
+      if (process.platform === 'win32') regularExpressionSafeName = regularExpressionSafeName.replace(/\\/g, '/');
+      let files = yield glob(regularExpressionSafeName, {
+        onlyFiles: true
+      });
+      let re = micromatch.makeRe(regularExpressionSafeName, {
+        capture: true
+      });
+      let matches = {};
+
+      var _iterator = _createForOfIteratorHelper(files),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          let file = _step.value;
+          let match = file.match(re);
+          let parts = match.slice(1).filter(Boolean).reduce((a, p) => a.concat(p.split('/')), []);
+          let relative = './' + path.relative(path.dirname(_this.name), file.normalize('NFC'));
+          set(matches, parts, relative);
+
+          _this.addDependency(relative);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+
+      return matches;
+    })();
+  }
+
+  generate() {
+    return [{
+      type: 'js',
+      value: '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;

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

@@ -0,0 +1,100 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+const Asset = require('../Asset');
+
+const localRequire = require('../utils/localRequire');
+
+const Resolver = require('../Resolver');
+
+const fs = require('@parcel/fs');
+
+const os = require('os');
+
+const IMPORT_RE = /^# *import +['"](.*)['"] *;? *$/;
+
+class GraphqlAsset extends Asset {
+  constructor(name, options) {
+    super(name, options);
+    this.type = 'js';
+    this.gqlMap = new Map();
+    this.gqlResolver = new Resolver(Object.assign({}, this.options, {
+      extensions: ['.gql', '.graphql']
+    }));
+  }
+
+  traverseImports(name, code) {
+    var _this = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      _this.gqlMap.set(name, code);
+
+      yield Promise.all(code.split(/\r\n?|\n/).map(line => line.match(IMPORT_RE)).filter(match => !!match).map( /*#__PURE__*/function () {
+        var _ref = (0, _asyncToGenerator2.default)(function* ([, importName]) {
+          let _yield$_this$gqlResol = yield _this.gqlResolver.resolve(importName, name),
+              resolved = _yield$_this$gqlResol.path;
+
+          if (_this.gqlMap.has(resolved)) {
+            return;
+          }
+
+          let code = yield fs.readFile(resolved, 'utf8');
+          yield _this.traverseImports(resolved, code);
+        });
+
+        return function (_x) {
+          return _ref.apply(this, arguments);
+        };
+      }()));
+    })();
+  }
+
+  collectDependencies() {
+    var _iterator = _createForOfIteratorHelper(this.gqlMap),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        let _step$value = (0, _slicedToArray2.default)(_step.value, 1),
+            path = _step$value[0];
+
+        this.addDependency(path, {
+          includedInParent: true
+        });
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+
+  parse(code) {
+    var _this2 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      let gql = yield localRequire('graphql-tag', _this2.name);
+      yield _this2.traverseImports(_this2.name, code);
+      const allCodes = [..._this2.gqlMap.values()].join(os.EOL);
+      return gql(allCodes);
+    })();
+  }
+
+  generate() {
+    return `module.exports=${JSON.stringify(this.ast, null, 2)};`;
+  }
+
+}
+
+module.exports = GraphqlAsset;

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

@@ -0,0 +1,319 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+const Asset = require('../Asset');
+
+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', 'image'],
+  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', 'msapplication-config'],
+  itemprop: ['image', 'logo', 'screenshot', 'thumbnailUrl', 'contentUrl', 'downloadUrl']
+};
+const SCRIPT_TYPES = {
+  'application/javascript': 'js',
+  'text/javascript': 'js',
+  'application/json': false,
+  'application/ld+json': 'jsonld',
+  'text/html': false
+}; // 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, options) {
+    super(name, options);
+    this.type = 'html';
+    this.isAstDirty = false;
+    this.hmrPageReload = true;
+  }
+
+  parse(code) {
+    var _this = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      let res = yield posthtmlTransform.parse(code, _this);
+      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 _iterator = _createForOfIteratorHelper(srcset.split(',')),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        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) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    return newSources.join(',');
+  }
+
+  getAttrDepHandler(attr) {
+    if (attr === 'srcset') {
+      return this.collectSrcSetDependencies;
+    }
+
+    return this.processSingleDependency;
+  }
+
+  collectDependencies() {
+    let ast = this.ast; // Add bundled dependencies from plugins like posthtml-extend or posthtml-include, if any
+
+    if (ast.messages) {
+      ast.messages.forEach(message => {
+        if (message.type === 'dependency') {
+          this.addDependency(message.file, {
+            includedInParent: true
+          });
+        }
+      });
+    }
+
+    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]) && node.attrs.content !== '';
+          })) {
+            return node;
+          }
+        }
+
+        if (node.tag === 'link' && node.attrs.rel === 'manifest' && node.attrs.href) {
+          node.attrs.href = this.getAttrDepHandler('href').call(this, node.attrs.href, {
+            entry: true
+          });
+          this.isAstDirty = true;
+          return node;
+        }
+
+        for (let attr in node.attrs) {
+          const attrVal = node.attrs[attr];
+
+          if (!attrVal) {
+            continue;
+          } // Check for virtual paths
+
+
+          if (node.tag === 'a' && attrVal.lastIndexOf('.') < 1) {
+            continue;
+          }
+
+          let elements = ATTRS[attr];
+
+          if (elements && elements.includes(node.tag)) {
+            let depHandler = this.getAttrDepHandler(attr);
+            let options = OPTIONS[node.tag];
+            node.attrs[attr] = depHandler.call(this, attrVal, options && options[attr]);
+            this.isAstDirty = true;
+          }
+        }
+      }
+
+      return node;
+    });
+  }
+
+  pretransform() {
+    var _this2 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      yield posthtmlTransform.transform(_this2);
+    })();
+  }
+
+  transform() {
+    var _this3 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      if (_this3.options.minify) {
+        yield htmlnanoTransform(_this3);
+      }
+    })();
+  }
+
+  generate() {
+    var _this4 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      // Extract inline <script> and <style> tags for processing.
+      let parts = [];
+
+      if (_this4.ast) {
+        _this4.ast.walk(node => {
+          if (node.tag === 'script' || node.tag === 'style') {
+            let value = node.content && node.content.join('').trim();
+
+            if (value) {
+              let type;
+
+              if (node.tag === 'style') {
+                if (node.attrs && node.attrs.type) {
+                  type = node.attrs.type.split('/')[1];
+                } else {
+                  type = 'css';
+                }
+              } else if (node.attrs && node.attrs.type) {
+                // Skip JSON
+                if (SCRIPT_TYPES[node.attrs.type] === false) {
+                  return node;
+                }
+
+                if (SCRIPT_TYPES[node.attrs.type]) {
+                  type = SCRIPT_TYPES[node.attrs.type];
+                } else {
+                  type = node.attrs.type.split('/')[1];
+                }
+              } else {
+                type = 'js';
+              }
+
+              parts.push({
+                type,
+                value,
+                inlineHTML: true,
+                meta: {
+                  type: 'tag',
+                  node
+                }
+              });
+            }
+          } // Process inline style attributes.
+
+
+          if (node.attrs && node.attrs.style) {
+            parts.push({
+              type: 'css',
+              value: node.attrs.style,
+              meta: {
+                type: 'attr',
+                node
+              }
+            });
+          }
+
+          return node;
+        });
+      }
+
+      return parts;
+    })();
+  }
+
+  postProcess(generated) {
+    var _this5 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      // Replace inline scripts and styles with processed results.
+      var _iterator2 = _createForOfIteratorHelper(generated),
+          _step2;
+
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          let rendition = _step2.value;
+          let _rendition$meta = rendition.meta,
+              type = _rendition$meta.type,
+              node = _rendition$meta.node;
+
+          if (type === 'attr' && rendition.type === 'css') {
+            node.attrs.style = rendition.value;
+          } else if (type === 'tag') {
+            if (rendition.isMain) {
+              node.content = rendition.value;
+            } // Delete "type" attribute, since CSS and JS are the defaults.
+            // Unless it's application/ld+json
+
+
+            if (node.attrs && (node.tag === 'style' || node.attrs.type && SCRIPT_TYPES[node.attrs.type] === 'js')) {
+              delete node.attrs.type;
+            }
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+
+      return [{
+        type: 'html',
+        value: render(_this5.ast)
+      }];
+    })();
+  }
+
+}
+
+module.exports = HTMLAsset;

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

@@ -0,0 +1,253 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+const traverse = require('@babel/traverse').default;
+
+const codeFrame = require('@babel/code-frame').codeFrameColumns;
+
+const collectDependencies = require('../visitors/dependencies');
+
+const walk = require('babylon-walk');
+
+const Asset = require('../Asset');
+
+const babelParser = require('@babel/parser');
+
+const insertGlobals = require('../visitors/globals');
+
+const fsVisitor = require('../visitors/fs');
+
+const envVisitor = require('../visitors/env');
+
+const processVisitor = require('../visitors/process');
+
+const babel = require('../transforms/babel/transform');
+
+const babel7 = require('../transforms/babel/babel7');
+
+const generate = require('@babel/generator').default;
+
+const terser = require('../transforms/terser');
+
+const SourceMap = require('../SourceMap');
+
+const hoist = require('../scope-hoisting/hoist');
+
+const loadSourceMap = require('../utils/loadSourceMap');
+
+const isAccessedVarChanged = require('../utils/isAccessedVarChanged');
+
+const IMPORT_RE = /\b(?:import\b|export\b|require\s*\()/;
+const ENV_RE = /\b(?:process\.env)\b/;
+const BROWSER_RE = /\b(?:process\.browser)\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*(?:Shared)?Worker\s*\(/;
+
+class JSAsset extends Asset {
+  constructor(name, options) {
+    super(name, options);
+    this.type = 'js';
+    this.globals = new Map();
+    this.isAstDirty = false;
+    this.isES6Module = false;
+    this.outputCode = null;
+    this.cacheData.env = {};
+    this.rendition = options.rendition;
+    this.sourceMap = this.rendition ? this.rendition.map : null;
+  }
+
+  shouldInvalidate(cacheData) {
+    return isAccessedVarChanged(cacheData);
+  }
+
+  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);
+  }
+
+  parse(code) {
+    var _this = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      return babelParser.parse(code, {
+        filename: _this.name,
+        allowReturnOutsideFunction: true,
+        strictMode: false,
+        sourceType: 'module',
+        plugins: ['exportDefaultFrom', 'exportNamespaceFrom', 'dynamicImport']
+      });
+    })();
+  }
+
+  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 _this2 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      if (_this2.options.sourceMaps && !_this2.sourceMap) {
+        _this2.sourceMap = yield loadSourceMap(_this2);
+      }
+
+      yield babel(_this2); // Inline environment variables
+
+      if (_this2.options.target === 'browser' && ENV_RE.test(_this2.contents)) {
+        yield _this2.parseIfNeeded();
+
+        _this2.traverseFast(envVisitor);
+      } // Inline process.browser
+
+
+      if (_this2.options.target === 'browser' && BROWSER_RE.test(_this2.contents)) {
+        yield _this2.parseIfNeeded();
+
+        _this2.traverse(processVisitor);
+
+        _this2.isAstDirty = true;
+      }
+    })();
+  }
+
+  transform() {
+    var _this3 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      if (_this3.options.target === 'browser') {
+        if (_this3.dependencies.has('fs') && FS_RE.test(_this3.contents)) {
+          // Check if we should ignore fs calls
+          // See https://github.com/defunctzombie/node-browser-resolve#skip
+          let pkg = yield _this3.getPackage();
+          let ignore = pkg && pkg.browser && pkg.browser.fs === false;
+
+          if (!ignore) {
+            yield _this3.parseIfNeeded();
+
+            _this3.traverse(fsVisitor);
+          }
+        }
+
+        if (GLOBAL_RE.test(_this3.contents)) {
+          yield _this3.parseIfNeeded();
+          walk.ancestor(_this3.ast, insertGlobals, _this3);
+        }
+      }
+
+      if (_this3.options.scopeHoist) {
+        yield _this3.parseIfNeeded();
+        yield _this3.getPackage();
+
+        _this3.traverse(hoist);
+
+        _this3.isAstDirty = true;
+      } else {
+        if (_this3.isES6Module) {
+          yield babel7(_this3, {
+            internal: true,
+            config: {
+              plugins: [require('@babel/plugin-transform-modules-commonjs')]
+            }
+          });
+        }
+      }
+
+      if (_this3.options.minify) {
+        yield terser(_this3);
+      }
+    })();
+  }
+
+  generate() {
+    var _this4 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      let code;
+
+      if (_this4.isAstDirty) {
+        let opts = {
+          sourceMaps: _this4.options.sourceMaps,
+          sourceFileName: _this4.relativeName
+        };
+        let generated = generate(_this4.ast, opts, _this4.contents);
+
+        if (_this4.options.sourceMaps && generated.rawMappings) {
+          let rawMap = new SourceMap(generated.rawMappings, {
+            [_this4.relativeName]: _this4.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 (_this4.sourceMap) {
+            _this4.sourceMap = yield new SourceMap().extendSourceMap(_this4.sourceMap, rawMap);
+          } else {
+            _this4.sourceMap = rawMap;
+          }
+        }
+
+        code = generated.code;
+      } else {
+        code = _this4.outputCode != null ? _this4.outputCode : _this4.contents;
+      }
+
+      if (_this4.options.sourceMaps && !_this4.sourceMap) {
+        _this4.sourceMap = new SourceMap().generateEmptyMap(_this4.relativeName, _this4.contents);
+      }
+
+      if (_this4.globals.size > 0) {
+        code = Array.from(_this4.globals.values()).join('\n') + '\n' + code;
+
+        if (_this4.options.sourceMaps) {
+          if (!(_this4.sourceMap instanceof SourceMap)) {
+            _this4.sourceMap = yield new SourceMap().addMap(_this4.sourceMap);
+          }
+
+          _this4.sourceMap.offset(_this4.globals.size);
+        }
+      }
+
+      return [{
+        type: 'js',
+        value: code,
+        map: _this4.sourceMap
+      }];
+    })();
+  }
+
+  generateErrorMessage(err) {
+    const loc = err.loc;
+
+    if (loc) {
+      // Babel 7 adds its own code frame on the error message itself
+      // We need to remove it and pass it separately.
+      if (err.message.startsWith(this.name)) {
+        err.message = err.message.slice(this.name.length + 1, err.message.indexOf('\n')).trim();
+      }
+
+      err.codeFrame = codeFrame(this.contents, {
+        start: loc
+      });
+      err.highlightedCodeFrame = codeFrame(this.contents, {
+        start: loc
+      }, {
+        highlightCode: true
+      });
+    }
+
+    return err;
+  }
+
+}
+
+module.exports = JSAsset;

BACK_BACK/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');
+
+const _require = require('terser'),
+      minify = _require.minify;
+
+class JSONAsset extends Asset {
+  constructor(name, options) {
+    super(name, 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 && !this.options.scopeHoist) {
+      let minified = minify(code);
+
+      if (minified.error) {
+        throw minified.error;
+      }
+
+      code = minified.code;
+    }
+
+    return code;
+  }
+
+}
+
+module.exports = JSONAsset;

BACK_BACK/node_modules/parcel-bundler/lib/assets/JSONLDAsset.js

@@ -0,0 +1,76 @@
+"use strict";
+
+const urlJoin = require('../utils/urlJoin');
+
+const isURL = require('../utils/is-url');
+
+const Asset = require('../Asset');
+
+const logger = require('@parcel/logger'); // A list of all attributes in a schema that may produce a dependency
+// Based on https://schema.org/ImageObject
+// Section "Instances of ImageObject may appear as values for the following properties"
+
+
+const SCHEMA_ATTRS = ['logo', 'photo', 'image', 'thumbnail', 'screenshot', 'primaryImageOfPage', 'embedUrl', 'thumbnailUrl', 'video', 'contentUrl'];
+
+class JSONLDAsset extends Asset {
+  constructor(name, options) {
+    super(name, options);
+    this.type = 'jsonld';
+  }
+
+  parse(content) {
+    return JSON.parse(content.trim());
+  }
+
+  collectDependencies() {
+    if (!this.options.publicURL.startsWith('http')) {
+      logger.warn("Please specify a publicURL using --public-url, otherwise schema assets won't be collected");
+      return;
+    }
+
+    for (let schemaKey in this.ast) {
+      if (SCHEMA_ATTRS.includes(schemaKey)) {
+        this.collectFromKey(this.ast, schemaKey);
+        this.isAstDirty = true;
+      }
+    }
+  } // Auxiliary method for collectDependencies() to use for recursion
+
+
+  collectFromKey(schema, schemaKey) {
+    if (!schema.hasOwnProperty(schemaKey)) {
+      return;
+    } // values can be strings or objects
+    // if it's not a string, it should have a url
+
+
+    if (typeof schema[schemaKey] === 'string') {
+      let assetPath = this.addURLDependency(schema[schemaKey]);
+
+      if (!isURL(assetPath)) {
+        // paths aren't allowed, values must be urls
+        assetPath = urlJoin(this.options.publicURL, assetPath);
+      }
+
+      schema[schemaKey] = assetPath;
+    } else if (Array.isArray(schema[schemaKey])) {
+      Object.keys(schema[schemaKey]).forEach(i => {
+        this.collectFromKey(schema[schemaKey], i);
+      });
+    } else {
+      this.collectFromKey(schema[schemaKey], 'url');
+    }
+  }
+
+  generate() {
+    if (this.options.production) {
+      return JSON.stringify(this.ast);
+    } else {
+      return JSON.stringify(this.ast, null, 2);
+    }
+  }
+
+}
+
+module.exports = JSONLDAsset;

BACK_BACK/node_modules/parcel-bundler/lib/assets/KotlinAsset.js

@@ -0,0 +1,65 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+const Asset = require('../Asset');
+
+const localRequire = require('../utils/localRequire');
+
+const path = require('path');
+
+const fs = require('@parcel/fs');
+
+const os = require('os');
+
+class KotlinAsset extends Asset {
+  constructor(name, options) {
+    super(name, options);
+    this.type = 'js';
+  }
+
+  generate() {
+    var _this = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      // require kotlin
+      const kotlinCompiler = yield localRequire('@jetbrains/kotlinc-js-api', _this.name);
+      let id = Math.random().toString(36).slice(3);
+      let dir = path.join(os.tmpdir(), id);
+      let filename = path.join(dir, id + '.js');
+      yield fs.mkdirp(dir);
+      yield kotlinCompiler.compile({
+        output: filename,
+        sources: [_this.name],
+        moduleKind: 'commonjs',
+        noStdlib: false,
+        metaInfo: true,
+        sourceMaps: _this.options.sourceMaps
+      });
+      let source = yield fs.readFile(filename, 'utf8');
+      let sourceMap;
+
+      if (_this.options.sourceMaps) {
+        sourceMap = yield fs.readFile(filename + '.map', 'utf8');
+        sourceMap = JSON.parse(sourceMap);
+        sourceMap.sources = [_this.relativeName];
+        sourceMap.sourcesContent = [_this.contents]; // remove source map url
+
+        source = source.substring(0, source.lastIndexOf('//# sourceMappingURL'));
+      } // delete temp directory
+
+
+      yield fs.rimraf(dir);
+      return [{
+        type: 'js',
+        value: source,
+        sourceMap
+      }];
+    })();
+  }
+
+}
+
+module.exports = KotlinAsset;

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

@@ -0,0 +1,141 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+const Asset = require('../Asset');
+
+const localRequire = require('../utils/localRequire');
+
+const _require = require('@parcel/utils'),
+      promisify = _require.promisify;
+
+const Resolver = require('../Resolver');
+
+const fs = require('@parcel/fs');
+
+const path = require('path');
+
+const parseCSSImport = require('../utils/parseCSSImport');
+
+class LESSAsset extends Asset {
+  constructor(name, options) {
+    super(name, options);
+    this.type = 'css';
+  }
+
+  parse(code) {
+    var _this = this;
+
+    return (0, _asyncToGenerator2.default)(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 = (yield _this.getConfig(['.lessrc', '.lessrc.js'], {
+        packageKey: 'less'
+      })) || {};
+      opts.filename = _this.name;
+      opts.plugins = (opts.plugins || []).concat(urlPlugin(_this));
+
+      if (_this.options.sourceMaps) {
+        opts.sourceMap = {
+          outputSourceFiles: true
+        };
+      }
+
+      return render(code, opts);
+    })();
+  }
+
+  collectDependencies() {
+    var _iterator = _createForOfIteratorHelper(this.ast.imports),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        let dep = _step.value;
+        this.addDependency(dep, {
+          includedInParent: true
+        });
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+
+  generate() {
+    let map;
+
+    if (this.ast && this.ast.map) {
+      map = JSON.parse(this.ast.map.toString());
+      map.sources = map.sources.map(v => path.relative(this.options.rootDir, v));
+    }
+
+    return [{
+      type: 'css',
+      value: this.ast ? this.ast.css : '',
+      hasDependencies: false,
+      map
+    }];
+  }
+
+}
+
+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);
+      let LessFileManager = getFileManager(less, asset.options);
+      pluginManager.addFileManager(new LessFileManager());
+    }
+  };
+}
+
+function getFileManager(less, options) {
+  const resolver = new Resolver({
+    extensions: ['.css', '.less'],
+    rootDir: options.rootDir
+  });
+
+  class LessFileManager extends less.FileManager {
+    supports() {
+      return true;
+    }
+
+    supportsSync() {
+      return false;
+    }
+
+    loadFile(filename, currentDirectory) {
+      return (0, _asyncToGenerator2.default)(function* () {
+        filename = parseCSSImport(filename);
+        let resolved = yield resolver.resolve(filename, path.join(currentDirectory, 'index'));
+        return {
+          contents: yield fs.readFile(resolved.path, 'utf8'),
+          filename: resolved.path
+        };
+      })();
+    }
+
+  }
+
+  return LessFileManager;
+}
+
+module.exports = LESSAsset;

BACK_BACK/node_modules/parcel-bundler/lib/assets/MarkdownAsset.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+const localRequire = require('../utils/localRequire');
+
+const Asset = require('../Asset');
+
+class MarkdownAsset extends Asset {
+  constructor(name, options) {
+    super(name, options);
+    this.type = 'html';
+    this.hmrPageReload = true;
+  }
+
+  generate() {
+    var _this = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      let marked = yield localRequire('marked', _this.name);
+      return marked(_this.contents);
+    })();
+  }
+
+}
+
+module.exports = MarkdownAsset;

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

@@ -0,0 +1,68 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+const path = require('path');
+
+const Asset = require('../Asset');
+
+const localRequire = require('../utils/localRequire');
+
+class PugAsset extends Asset {
+  constructor(name, options) {
+    super(name, options);
+    this.type = 'html';
+    this.hmrPageReload = true;
+  }
+
+  generate() {
+    var _this = this;
+
+    return (0, _asyncToGenerator2.default)(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: config.pretty || false,
+        templateName: path.basename(_this.basename, path.extname(_this.basename)),
+        filters: config.filters,
+        filterOptions: config.filterOptions,
+        filterAliases: config.filterAliases
+      });
+
+      if (compiled.dependencies) {
+        var _iterator = _createForOfIteratorHelper(compiled.dependencies),
+            _step;
+
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            let item = _step.value;
+
+            _this.addDependency(item, {
+              includedInParent: true
+            });
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      }
+
+      return compiled(config.locals);
+    })();
+  }
+
+}
+
+module.exports = PugAsset;

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

@@ -0,0 +1,41 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+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 [{
+      type: 'js',
+      value: `module.exports=${JSON.stringify(pathToAsset)};`
+    }];
+  }
+
+  generateHash() {
+    var _this = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      return md5.file(_this.name);
+    })();
+  }
+
+}
+
+module.exports = RawAsset;

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

@@ -0,0 +1,43 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+const Asset = require('../Asset');
+
+const fs = require('@parcel/fs');
+
+const localRequire = require('../utils/localRequire');
+
+class ReasonAsset extends Asset {
+  constructor(name, options) {
+    super(name, options);
+    this.type = 'js';
+  }
+
+  generate() {
+    var _this = this;
+
+    return (0, _asyncToGenerator2.default)(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;

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

@@ -0,0 +1,236 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+const path = require('path');
+
+const commandExists = require('command-exists');
+
+const childProcess = require('child_process');
+
+const _require = require('@parcel/utils'),
+      promisify = _require.promisify;
+
+const exec = promisify(childProcess.execFile);
+
+const toml = require('@iarna/toml');
+
+const fs = require('@parcel/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;
+
+class RustAsset extends Asset {
+  constructor(name, options) {
+    super(name, 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 (0, _asyncToGenerator2.default)(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(file => 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();
+      }
+    })();
+  }
+
+  installRust() {
+    return (0, _asyncToGenerator2.default)(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
+
+
+      let _yield$exec = yield exec('rustup', ['show']),
+          _yield$exec2 = (0, _slicedToArray2.default)(_yield$exec, 1),
+          stdout = _yield$exec2[0];
+
+      if (!stdout.includes('nightly')) {
+        yield pipeSpawn('rustup', ['update']);
+        yield pipeSpawn('rustup', ['toolchain', 'install', 'nightly']);
+      } // Ensure wasm target is installed
+
+
+      var _yield$exec3 = yield exec('rustup', ['target', 'list', '--toolchain', 'nightly']);
+
+      var _yield$exec4 = (0, _slicedToArray2.default)(_yield$exec3, 1);
+
+      stdout = _yield$exec4[0];
+
+      if (!stdout.includes(RUST_TARGET + ' (installed)')) {
+        yield pipeSpawn('rustup', ['target', 'add', RUST_TARGET, '--toolchain', 'nightly']);
+      }
+
+      rustInstalled = true;
+    })();
+  }
+
+  cargoBuild(cargoConfig, cargoDir) {
+    var _this2 = this;
+
+    return (0, _asyncToGenerator2.default)(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'), toml.stringify(cargoConfig));
+      } // Run cargo
+
+
+      let args = ['+nightly', 'build', '--target', RUST_TARGET, '--release'];
+      yield exec('cargo', args, {
+        cwd: cargoDir
+      }); // Get output file paths
+
+      let _yield$exec5 = yield exec('cargo', ['metadata', '--format-version', '1'], {
+        cwd: cargoDir
+      }),
+          _yield$exec6 = (0, _slicedToArray2.default)(_yield$exec5, 1),
+          stdout = _yield$exec6[0];
+
+      const cargoMetadata = JSON.parse(stdout);
+      const cargoTargetDir = cargoMetadata.target_directory;
+      let outDir = path.join(cargoTargetDir, 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 (0, _asyncToGenerator2.default)(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];
+      const minifyArgs = _this3.options.minify ? ['-Clink-arg=-s'] : [];
+      yield exec('rustc', [...args, ...minifyArgs]); // 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 (0, _asyncToGenerator2.default)(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 _iterator = _createForOfIteratorHelper(deps),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          let dep = _step.value;
+          dep = path.resolve(dir, dep.slice(0, dep.indexOf(': ')));
+
+          if (dep !== _this4.name) {
+            _this4.addDependency(dep, {
+              includedInParent: true
+            });
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    })();
+  }
+
+  generate() {
+    var _this5 = this;
+
+    return (0, _asyncToGenerator2.default)(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;

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

@@ -0,0 +1,155 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+const Asset = require('../Asset');
+
+const localRequire = require('../utils/localRequire');
+
+const _require = require('@parcel/utils'),
+      promisify = _require.promisify;
+
+const path = require('path');
+
+const os = require('os');
+
+const Resolver = require('../Resolver');
+
+const parseCSSImport = require('../utils/parseCSSImport');
+
+class SASSAsset extends Asset {
+  constructor(name, options) {
+    super(name, options);
+    this.type = 'css';
+  }
+
+  parse(code) {
+    var _this = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      // node-sass or dart-sass should be installed locally in the module that's being required
+      let sass = yield getSassRuntime(_this.name);
+      let render = promisify(sass.render.bind(sass));
+      const resolver = new Resolver({
+        extensions: ['.scss', '.sass'],
+        rootDir: _this.options.rootDir
+      });
+      let opts = (yield _this.getConfig(['.sassrc', '.sassrc.js'], {
+        packageKey: 'sass'
+      })) || {};
+      opts.includePaths = (opts.includePaths ? opts.includePaths.map(includePath => path.resolve(includePath)) : []).concat(path.dirname(_this.name));
+      opts.data = opts.data ? opts.data + os.EOL + code : code;
+      let type = _this.options.rendition ? _this.options.rendition.type : path.extname(_this.name).toLowerCase().replace('.', '');
+      opts.indentedSyntax = typeof opts.indentedSyntax === 'boolean' ? opts.indentedSyntax : type === 'sass';
+      opts.importer = opts.importer || [];
+      opts.importer = Array.isArray(opts.importer) ? opts.importer : [opts.importer];
+      opts.importer.push((url, prev, done) => {
+        url = url.replace(/^file:\/\//, '');
+        url = parseCSSImport(url);
+        resolver.resolve(url, prev === 'stdin' ? _this.name : prev).then(resolved => resolved.path).catch(() => url).then(file => done({
+          file
+        })).catch(err => done(normalizeError(err)));
+      });
+
+      if (_this.options.sourceMaps) {
+        opts.sourceMap = true;
+        opts.file = _this.name;
+        opts.outFile = _this.name;
+        opts.omitSourceMapUrl = true;
+        opts.sourceMapContents = true;
+      }
+
+      try {
+        return yield render(opts);
+      } catch (err) {
+        // Format the error so it can be handled by parcel's prettyError
+        if (err.formatted) {
+          throw sassToCodeFrame(err);
+        } // Throw original error if there is no codeFrame
+
+
+        throw err;
+      }
+    })();
+  }
+
+  collectDependencies() {
+    var _iterator = _createForOfIteratorHelper(this.ast.stats.includedFiles),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        let dep = _step.value;
+        this.addDependency(dep, {
+          includedInParent: true
+        });
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+
+  generate() {
+    return [{
+      type: 'css',
+      value: this.ast ? this.ast.css.toString() : '',
+      map: this.ast && this.ast.map ? JSON.parse(this.ast.map.toString()) : undefined
+    }];
+  }
+
+}
+
+module.exports = SASSAsset;
+
+function getSassRuntime(_x) {
+  return _getSassRuntime.apply(this, arguments);
+}
+
+function _getSassRuntime() {
+  _getSassRuntime = (0, _asyncToGenerator2.default)(function* (searchPath) {
+    try {
+      return yield localRequire('node-sass', searchPath, true);
+    } catch (e) {
+      // If node-sass is not used locally, install dart-sass, as this causes no freezing issues
+      return localRequire('sass', searchPath);
+    }
+  });
+  return _getSassRuntime.apply(this, arguments);
+}
+
+function sassToCodeFrame(err) {
+  let error = new Error(err.message);
+  error.codeFrame = err.formatted;
+  error.stack = err.stack;
+  error.fileName = err.file;
+  error.loc = {
+    line: err.line,
+    column: err.column
+  };
+  return error;
+} // Ensures an error inherits from Error
+
+
+function normalizeError(err) {
+  let message = 'Unknown error';
+
+  if (err) {
+    if (err instanceof Error) {
+      return err;
+    }
+
+    message = err.stack || err.message || err;
+  }
+
+  return new Error(message);
+}

BACK_BACK/node_modules/parcel-bundler/lib/assets/SSSAsset.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+const postcss = require('postcss');
+
+const localRequire = require('../utils/localRequire');
+
+const Asset = require('../Asset');
+
+class SSSAsset extends Asset {
+  constructor(name, options) {
+    super(name, options);
+    this.type = 'css';
+  }
+
+  generate() {
+    var _this = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      let sugarss = yield localRequire('sugarss', _this.name);
+      yield _this.loadIfNeeded();
+
+      let _yield$postcss$proces = yield postcss().process(_this.contents, {
+        from: _this.name,
+        to: _this.name,
+        parser: sugarss
+      }),
+          css = _yield$postcss$proces.css;
+
+      return [{
+        type: 'css',
+        value: css
+      }];
+    })();
+  }
+
+}
+
+module.exports = SSSAsset;

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

@@ -0,0 +1,280 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+// const CSSAsset = require('./CSSAsset');
+const Asset = require('../Asset');
+
+const localRequire = require('../utils/localRequire');
+
+const Resolver = require('../Resolver');
+
+const fs = require('@parcel/fs');
+
+const _require = require('path'),
+      dirname = _require.dirname,
+      resolve = _require.resolve,
+      relative = _require.relative;
+
+const _require2 = require('../utils/glob'),
+      isGlob = _require2.isGlob,
+      glob = _require2.glob;
+
+const URL_RE = /^(?:url\s*\(\s*)?['"]?(?:[#/]|(?:https?:)?\/\/)/i;
+
+class StylusAsset extends Asset {
+  constructor(name, options) {
+    super(name, options);
+    this.type = 'css';
+  }
+
+  parse(code) {
+    var _this = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      // stylus should be installed locally in the module that's being required
+      let stylus = yield localRequire('stylus', _this.name);
+      let opts = yield _this.getConfig(['.stylusrc', '.stylusrc.js'], {
+        packageKey: 'stylus'
+      });
+      let style = stylus(code, opts);
+      style.set('filename', _this.name);
+      style.set('include css', true); // Setup a handler for the URL function so we add dependencies for linked assets.
+
+      style.define('url', node => {
+        let filename = _this.addURLDependency(node.val, node.filename);
+
+        return new stylus.nodes.Literal(`url(${JSON.stringify(filename)})`);
+      });
+      style.set('Evaluator', yield createEvaluator(code, _this, style.options));
+      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;
+  }
+
+}
+
+function getDependencies(_x, _x2, _x3, _x4) {
+  return _getDependencies.apply(this, arguments);
+}
+
+function _getDependencies() {
+  _getDependencies = (0, _asyncToGenerator2.default)(function* (code, filepath, asset, options, seen = new Set()) {
+    seen.add(filepath);
+
+    const _yield$Promise$all = yield Promise.all(['parser', 'visitor/deps-resolver', 'nodes', 'utils'].map(dep => localRequire('stylus/lib/' + dep, filepath))),
+          _yield$Promise$all2 = (0, _slicedToArray2.default)(_yield$Promise$all, 4),
+          Parser = _yield$Promise$all2[0],
+          DepsResolver = _yield$Promise$all2[1],
+          nodes = _yield$Promise$all2[2],
+          utils = _yield$Promise$all2[3];
+
+    nodes.filename = asset.name;
+    let parser = new Parser(code, options);
+    let ast = parser.parse();
+    let deps = new Map();
+    let resolver = new Resolver(Object.assign({}, asset.options, {
+      extensions: ['.styl', '.css']
+    }));
+
+    class ImportVisitor extends DepsResolver {
+      visitImport(imported) {
+        let path = imported.path.first.string;
+
+        if (!deps.has(path)) {
+          if (isGlob(path)) {
+            deps.set(path, glob(resolve(dirname(filepath), path), {
+              onlyFiles: true
+            }).then(entries => Promise.all(entries.map(entry => resolver.resolve('./' + relative(dirname(filepath), entry), filepath)))));
+          } else {
+            deps.set(path, resolver.resolve(path, filepath));
+          }
+        }
+      }
+
+    }
+
+    new ImportVisitor(ast, options).visit(ast); // Recursively process depdendencies, and return a map with all resolved paths.
+
+    let res = new Map();
+    yield Promise.all(Array.from(deps.entries()).map( /*#__PURE__*/function () {
+      var _ref = (0, _asyncToGenerator2.default)(function* ([path, resolved]) {
+        try {
+          resolved = yield resolved;
+          resolved = Array.isArray(resolved) ? resolved.map(r => r.path) : resolved.path;
+        } catch (err) {
+          resolved = null;
+        }
+
+        let found;
+
+        if (resolved) {
+          found = Array.isArray(resolved) ? resolved : [resolved];
+          res.set(path, resolved);
+        } else {
+          // 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
+          let originalPath = path;
+
+          if (!/\.styl$/i.test(path)) {
+            path += '.styl';
+          }
+
+          let paths = (options.paths || []).concat(dirname(filepath || '.'));
+          found = utils.find(path, paths, filepath);
+
+          if (!found) {
+            found = utils.lookupIndex(originalPath, paths, filepath);
+          }
+
+          if (!found) {
+            throw new Error('failed to locate file ' + originalPath);
+          }
+        } // Recursively process resolved files as well to get nested deps
+
+
+        var _iterator2 = _createForOfIteratorHelper(found),
+            _step2;
+
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            let resolved = _step2.value;
+
+            if (!seen.has(resolved)) {
+              asset.addDependency(resolved, {
+                includedInParent: true
+              });
+              let code = yield fs.readFile(resolved, 'utf8');
+
+              var _iterator3 = _createForOfIteratorHelper(yield getDependencies(code, resolved, asset, options, seen)),
+                  _step3;
+
+              try {
+                for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                  let _step3$value = (0, _slicedToArray2.default)(_step3.value, 2),
+                      path = _step3$value[0],
+                      resolvedPath = _step3$value[1];
+
+                  res.set(path, resolvedPath);
+                }
+              } catch (err) {
+                _iterator3.e(err);
+              } finally {
+                _iterator3.f();
+              }
+            }
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+      });
+
+      return function (_x8) {
+        return _ref.apply(this, arguments);
+      };
+    }()));
+    return res;
+  });
+  return _getDependencies.apply(this, arguments);
+}
+
+function createEvaluator(_x5, _x6, _x7) {
+  return _createEvaluator.apply(this, arguments);
+}
+/**
+ * Puts the content of all given node blocks into the first one, essentially merging them.
+ */
+
+
+function _createEvaluator() {
+  _createEvaluator = (0, _asyncToGenerator2.default)(function* (code, asset, options) {
+    const deps = yield getDependencies(code, asset.name, asset, options);
+    const Evaluator = yield localRequire('stylus/lib/visitor/evaluator', asset.name); // 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)) {
+          let resolved = deps.get(path); // 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.
+
+          if (resolved) {
+            if (!Array.isArray(resolved)) {
+              node.string = resolved;
+            } else {
+              // If the import resolves to multiple files (i.e. glob),
+              // replace it with a separate import node for each file
+              return mergeBlocks(resolved.map(resolvedPath => {
+                node.string = resolvedPath;
+                return super.visitImport(imported.clone());
+              }));
+            }
+          }
+        } // Done. Let stylus do its thing.
+
+
+        return super.visitImport(imported);
+      }
+
+    }
+
+    return CustomEvaluator;
+  });
+  return _createEvaluator.apply(this, arguments);
+}
+
+function mergeBlocks(blocks) {
+  let finalBlock;
+
+  var _iterator = _createForOfIteratorHelper(blocks),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      const block = _step.value;
+      if (!finalBlock) finalBlock = block;else {
+        block.nodes.forEach(node => finalBlock.push(node));
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return finalBlock;
+}
+
+module.exports = StylusAsset;

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

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

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

@@ -0,0 +1,71 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+const Asset = require('../Asset');
+
+const localRequire = require('../utils/localRequire');
+
+const isAccessedVarChanged = require('../utils/isAccessedVarChanged');
+
+class TypeScriptAsset extends Asset {
+  constructor(name, options) {
+    super(name, options);
+    this.type = 'js';
+    this.cacheData.env = {};
+  }
+
+  shouldInvalidate(cacheData) {
+    return isAccessedVarChanged(cacheData);
+  }
+
+  generate() {
+    var _this = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      // require typescript, installed locally in the app
+      let typescript = yield localRequire('typescript', _this.name);
+      let transpilerOptions = {
+        compilerOptions: {
+          module: _this.options.scopeHoist ? typescript.ModuleKind.ESNext : 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,
+        map: sourceMap
+      }];
+    })();
+  }
+
+}
+
+module.exports = TypeScriptAsset;

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

@@ -0,0 +1,325 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+const Asset = require('../Asset');
+
+const localRequire = require('../utils/localRequire');
+
+const md5 = require('../utils/md5');
+
+const _require = require('terser'),
+      minify = _require.minify;
+
+const t = require('@babel/types');
+
+class VueAsset extends Asset {
+  constructor(name, options) {
+    super(name, options);
+    this.type = 'js';
+  }
+
+  parse(code) {
+    var _this = this;
+
+    return (0, _asyncToGenerator2.default)(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
+        compiler: _this.vueTemplateCompiler
+      });
+    })();
+  }
+
+  generate() {
+    var _this2 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      let descriptor = _this2.ast;
+      let parts = [];
+
+      if (descriptor.script) {
+        parts.push({
+          type: descriptor.script.lang || 'js',
+          value: descriptor.script.content,
+          map: descriptor.script.map
+        });
+      }
+
+      if (descriptor.template) {
+        parts.push({
+          type: descriptor.template.lang || 'html',
+          value: descriptor.template.content.trim()
+        });
+      }
+
+      if (descriptor.styles) {
+        var _iterator = _createForOfIteratorHelper(descriptor.styles),
+            _step;
+
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            let style = _step.value;
+            parts.push({
+              type: style.lang || 'css',
+              value: style.content.trim(),
+              modules: !!style.module
+            });
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      }
+
+      return parts;
+    })();
+  }
+
+  postProcess(generated) {
+    var _this3 = this;
+
+    return (0, _asyncToGenerator2.default)(function* () {
+      let result = [];
+
+      let hasScoped = _this3.ast.styles.some(s => 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 = ''; // TODO: make it possible to process this code with the normal scope hoister
+
+      if (_this3.options.scopeHoist) {
+        optsVar = `$${t.toIdentifier(_this3.id)}$export$default`;
+
+        if (!js.includes(optsVar)) {
+          optsVar = `$${t.toIdentifier(_this3.id)}$exports`;
+
+          if (!js.includes(optsVar)) {
+            supplemental += `
+            var ${optsVar} = {};
+          `;
+            _this3.cacheData.isCommonJS = true;
+          }
+        }
+      } else {
+        supplemental += `
+        var ${optsVar} = exports.default || module.exports;
+      `;
+      }
+
+      supplemental += `
+      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 && !_this3.options.scopeHoist) {
+        let _minify = minify(supplemental, {
+          toplevel: true
+        }),
+            code = _minify.code,
+            error = _minify.error;
+
+        if (error) {
+          throw error;
+        }
+
+        supplemental = code;
+
+        if (supplemental) {
+          supplemental = `\n(function(){${supplemental}})();`;
+        }
+      }
+
+      js += supplemental;
+
+      if (js) {
+        result.push({
+          type: 'js',
+          value: js,
+          map: _this3.options.sourceMaps && _this3.ast.script && generated[0].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) {
+        let _this$vue$compileStyl = this.vue.compileStyle({
+          source: css,
+          filename: this.relativeName,
+          id: scopeId,
+          scoped
+        }),
+            code = _this$vue$compileStyl.code,
+            errors = _this$vue$compileStyl.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;

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

@@ -0,0 +1,65 @@
+"use strict";
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+const Asset = require('../Asset');
+
+class WebManifestAsset extends Asset {
+  constructor(name, options) {
+    super(name, options);
+    this.type = 'webmanifest';
+  }
+
+  parse(content) {
+    return JSON.parse(content);
+  }
+
+  collectDependencies() {
+    if (Array.isArray(this.ast.icons)) {
+      var _iterator = _createForOfIteratorHelper(this.ast.icons),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          let icon = _step.value;
+          icon.src = this.addURLDependency(icon.src);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+
+    if (Array.isArray(this.ast.screenshots)) {
+      var _iterator2 = _createForOfIteratorHelper(this.ast.screenshots),
+          _step2;
+
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          let shot = _step2.value;
+          shot.src = this.addURLDependency(shot.src);
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    }
+
+    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;

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

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