switch to vuepress

5 files changed, 466 insertions, 0 deletions

diff --git a/node_modules/babel-loader/lib/Error.js b/node_modules/babel-loader/lib/Error.js
new file mode 100644
index 00000000..02b3fbc4
--- /dev/null
+++ b/node_modules/babel-loader/lib/Error.js
@@ -0,0 +1,36 @@
+"use strict";
+
+const STRIP_FILENAME_RE = /^[^:]+: /;
+
+const format = err => {
+  if (err instanceof SyntaxError) {
+    err.name = "SyntaxError";
+    err.message = err.message.replace(STRIP_FILENAME_RE, "");
+    err.hideStack = true;
+  } else if (err instanceof TypeError) {
+    err.name = null;
+    err.message = err.message.replace(STRIP_FILENAME_RE, "");
+    err.hideStack = true;
+  }
+
+  return err;
+};
+
+class LoaderError extends Error {
+  constructor(err) {
+    super();
+    const {
+      name,
+      message,
+      codeFrame,
+      hideStack
+    } = format(err);
+    this.name = "BabelLoaderError";
+    this.message = `${name ? `${name}: ` : ""}${message}\n\n${codeFrame}\n`;
+    this.hideStack = hideStack;
+    Error.captureStackTrace(this, this.constructor);
+  }
+
+}
+
+module.exports = LoaderError;
\ No newline at end of file
diff --git a/node_modules/babel-loader/lib/cache.js b/node_modules/babel-loader/lib/cache.js
new file mode 100644
index 00000000..c86ae60b
--- /dev/null
+++ b/node_modules/babel-loader/lib/cache.js
@@ -0,0 +1,218 @@
+"use strict";
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } } function _next(value) { step("next", value); } function _throw(err) { step("throw", err); } _next(); }); }; }
+
+/**
+ * Filesystem Cache
+ *
+ * Given a file and a transform function, cache the result into files
+ * or retrieve the previously cached files if the given file is already known.
+ *
+ * @see https://github.com/babel/babel-loader/issues/34
+ * @see https://github.com/babel/babel-loader/pull/41
+ */
+const fs = require("fs");
+
+const os = require("os");
+
+const path = require("path");
+
+const zlib = require("zlib");
+
+const crypto = require("crypto");
+
+const mkdirpOrig = require("mkdirp");
+
+const findCacheDir = require("find-cache-dir");
+
+const promisify = require("util.promisify");
+
+const transform = require("./transform"); // Lazily instantiated when needed
+
+
+let defaultCacheDirectory = null;
+const readFile = promisify(fs.readFile);
+const writeFile = promisify(fs.writeFile);
+const gunzip = promisify(zlib.gunzip);
+const gzip = promisify(zlib.gzip);
+const mkdirp = promisify(mkdirpOrig);
+/**
+ * Read the contents from the compressed file.
+ *
+ * @async
+ * @params {String} filename
+ */
+
+const read =
+/*#__PURE__*/
+function () {
+  var _ref = _asyncToGenerator(function* (filename) {
+    const data = yield readFile(filename);
+    const content = yield gunzip(data);
+    return JSON.parse(content);
+  });
+
+  return function read(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+/**
+ * Write contents into a compressed file.
+ *
+ * @async
+ * @params {String} filename
+ * @params {String} result
+ */
+
+
+const write =
+/*#__PURE__*/
+function () {
+  var _ref2 = _asyncToGenerator(function* (filename, result) {
+    const content = JSON.stringify(result);
+    const data = yield gzip(content);
+    return yield writeFile(filename, data);
+  });
+
+  return function write(_x2, _x3) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+/**
+ * Build the filename for the cached file
+ *
+ * @params {String} source  File source code
+ * @params {Object} options Options used
+ *
+ * @return {String}
+ */
+
+
+const filename = function (source, identifier, options) {
+  const hash = crypto.createHash("SHA1");
+  const contents = JSON.stringify({
+    source,
+    options,
+    identifier
+  });
+  hash.end(contents);
+  return hash.read().toString("hex") + ".json.gz";
+};
+/**
+ * Handle the cache
+ *
+ * @params {String} directory
+ * @params {Object} params
+ */
+
+
+const handleCache =
+/*#__PURE__*/
+function () {
+  var _ref3 = _asyncToGenerator(function* (directory, params) {
+    const {
+      source,
+      options = {},
+      cacheIdentifier,
+      cacheDirectory
+    } = params;
+    const fallback = typeof cacheDirectory !== "string" && directory !== os.tmpdir(); // Make sure the directory exists.
+
+    try {
+      yield mkdirp(directory);
+    } catch (err) {
+      if (fallback) {
+        return handleCache(os.tmpdir(), params);
+      }
+
+      throw err;
+    }
+
+    const file = path.join(directory, filename(source, cacheIdentifier, options));
+
+    try {
+      // No errors mean that the file was previously cached
+      // we just need to return it
+      return yield read(file);
+    } catch (err) {} // Otherwise just transform the file
+    // return it to the user asap and write it in cache
+
+
+    const result = yield transform(source, options);
+
+    try {
+      yield write(file, result);
+    } catch (err) {
+      if (fallback) {
+        // Fallback to tmpdir if node_modules folder not writable
+        return handleCache(os.tmpdir(), params);
+      }
+
+      throw err;
+    }
+
+    return result;
+  });
+
+  return function handleCache(_x4, _x5) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+/**
+ * Retrieve file from cache, or create a new one for future reads
+ *
+ * @async
+ * @param  {Object}   params
+ * @param  {String}   params.directory  Directory to store cached files
+ * @param  {String}   params.identifier Unique identifier to bust cache
+ * @param  {String}   params.source   Original contents of the file to be cached
+ * @param  {Object}   params.options  Options to be given to the transform fn
+ * @param  {Function} params.transform  Function that will transform the
+ *                                      original file and whose result will be
+ *                                      cached
+ *
+ * @example
+ *
+ *   cache({
+ *     directory: '.tmp/cache',
+ *     identifier: 'babel-loader-cachefile',
+ *     source: *source code from file*,
+ *     options: {
+ *       experimental: true,
+ *       runtime: true
+ *     },
+ *     transform: function(source, options) {
+ *       var content = *do what you need with the source*
+ *       return content;
+ *     }
+ *   }, function(err, result) {
+ *
+ *   });
+ */
+
+
+module.exports =
+/*#__PURE__*/
+function () {
+  var _ref4 = _asyncToGenerator(function* (params) {
+    let directory;
+
+    if (typeof params.cacheDirectory === "string") {
+      directory = params.cacheDirectory;
+    } else {
+      if (defaultCacheDirectory === null) {
+        defaultCacheDirectory = findCacheDir({
+          name: "babel-loader"
+        }) || os.tmpdir();
+      }
+
+      directory = defaultCacheDirectory;
+    }
+
+    return yield handleCache(directory, params);
+  });
+
+  return function (_x6) {
+    return _ref4.apply(this, arguments);
+  };
+}();
\ No newline at end of file
diff --git a/node_modules/babel-loader/lib/index.js b/node_modules/babel-loader/lib/index.js
new file mode 100644
index 00000000..e4928e7a
--- /dev/null
+++ b/node_modules/babel-loader/lib/index.js
@@ -0,0 +1,149 @@
+"use strict";
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } } function _next(value) { step("next", value); } function _throw(err) { step("throw", err); } _next(); }); }; }
+
+const babel = require("@babel/core");
+
+const pkg = require("../package.json");
+
+const cache = require("./cache");
+
+const transform = require("./transform");
+
+const relative = require("./utils/relative");
+
+const loaderUtils = require("loader-utils");
+
+function subscribe(subscriber, metadata, context) {
+  if (context[subscriber]) {
+    context[subscriber](metadata);
+  }
+}
+
+module.exports = makeLoader();
+module.exports.custom = makeLoader;
+
+function makeLoader(callback) {
+  const overrides = callback ? callback(babel) : undefined;
+  return function (source, inputSourceMap) {
+    // Make the loader async
+    const callback = this.async();
+    loader.call(this, source, inputSourceMap, overrides).then(args => callback(null, ...args), err => callback(err));
+  };
+}
+
+function loader(_x, _x2, _x3) {
+  return _loader.apply(this, arguments);
+}
+
+function _loader() {
+  _loader = _asyncToGenerator(function* (source, inputSourceMap, overrides) {
+    const filename = this.resourcePath;
+    let loaderOptions = loaderUtils.getOptions(this) || {};
+    let customOptions;
+
+    if (overrides && overrides.customOptions) {
+      const result = yield overrides.customOptions.call(this, loaderOptions);
+      customOptions = result.custom;
+      loaderOptions = result.loader;
+    } // Deprecation handling
+
+
+    if ("forceEnv" in loaderOptions) {
+      console.warn("The option `forceEnv` has been removed in favor of `envName` in Babel 7.");
+    }
+
+    if (typeof loaderOptions.babelrc === "string") {
+      console.warn("The option `babelrc` should not be set to a string anymore in the babel-loader config. " + "Please update your configuration and set `babelrc` to true or false.\n" + "If you want to specify a specific babel config file to inherit config from " + "please use the `extends` option.\nFor more information about this options see " + "https://babeljs.io/docs/core-packages/#options");
+    } // Set babel-loader's default options.
+
+
+    const {
+      sourceRoot = process.cwd(),
+      sourceMap = this.sourceMap,
+      sourceFileName = relative(sourceRoot, filename)
+    } = loaderOptions;
+    const programmaticOptions = Object.assign({}, loaderOptions, {
+      filename,
+      inputSourceMap: inputSourceMap || undefined,
+      sourceRoot,
+      sourceMap,
+      sourceFileName
+    }); // Remove loader related options
+
+    delete programmaticOptions.cacheDirectory;
+    delete programmaticOptions.cacheIdentifier;
+    delete programmaticOptions.metadataSubscribers;
+
+    if (!babel.loadPartialConfig) {
+      throw new Error(`babel-loader ^8.0.0-beta.3 requires @babel/core@7.0.0-beta.41, but ` + `you appear to be using "${babel.version}". Either update your ` + `@babel/core version, or pin you babel-loader version to 8.0.0-beta.2`);
+    }
+
+    const config = babel.loadPartialConfig(programmaticOptions);
+
+    if (config) {
+      let options = config.options;
+
+      if (overrides && overrides.config) {
+        options = yield overrides.config.call(this, config, {
+          source,
+          customOptions
+        });
+      }
+
+      const {
+        cacheDirectory = null,
+        cacheIdentifier = JSON.stringify({
+          options,
+          "@babel/core": transform.version,
+          "@babel/loader": pkg.version
+        }),
+        metadataSubscribers = []
+      } = loaderOptions;
+      let result;
+
+      if (cacheDirectory) {
+        result = yield cache({
+          source,
+          options,
+          transform,
+          cacheDirectory,
+          cacheIdentifier
+        });
+      } else {
+        result = yield transform(source, options);
+      } // TODO: Babel should really provide the full list of config files that
+      // were used so that this can also handle files loaded with 'extends'.
+
+
+      if (typeof config.babelrc === "string") {
+        this.addDependency(config.babelrc);
+      }
+
+      if (result) {
+        if (overrides && overrides.result) {
+          result = yield overrides.result.call(this, result, {
+            source,
+            customOptions,
+            config,
+            options
+          });
+        }
+
+        const {
+          code,
+          map,
+          metadata
+        } = result;
+        metadataSubscribers.forEach(subscriber => {
+          subscribe(subscriber, metadata, this);
+        });
+        return [code, map];
+      }
+    } // If the file was ignored, pass through the original content.
+
+
+    return [source, inputSourceMap];
+  });
+  return _loader.apply(this, arguments);
+}
\ No newline at end of file
diff --git a/node_modules/babel-loader/lib/transform.js b/node_modules/babel-loader/lib/transform.js
new file mode 100644
index 00000000..bc5011e3
--- /dev/null
+++ b/node_modules/babel-loader/lib/transform.js
@@ -0,0 +1,48 @@
+"use strict";
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } } function _next(value) { step("next", value); } function _throw(err) { step("throw", err); } _next(); }); }; }
+
+const babel = require("@babel/core");
+
+const promisify = require("util.promisify");
+
+const LoaderError = require("./Error");
+
+const transform = promisify(babel.transform);
+
+module.exports =
+/*#__PURE__*/
+function () {
+  var _ref = _asyncToGenerator(function* (source, options) {
+    let result;
+
+    try {
+      result = yield transform(source, options);
+    } catch (err) {
+      throw err.message && err.codeFrame ? new LoaderError(err) : err;
+    }
+
+    if (!result) return null;
+    const {
+      code,
+      map,
+      metadata
+    } = result;
+
+    if (map && (!map.sourcesContent || !map.sourcesContent.length)) {
+      map.sourcesContent = [source];
+    }
+
+    return {
+      code,
+      map,
+      metadata
+    };
+  });
+
+  return function (_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+module.exports.version = babel.version;
\ No newline at end of file
diff --git a/node_modules/babel-loader/lib/utils/relative.js b/node_modules/babel-loader/lib/utils/relative.js
new file mode 100644
index 00000000..e9e9a5b1
--- /dev/null
+++ b/node_modules/babel-loader/lib/utils/relative.js
@@ -0,0 +1,15 @@
+"use strict";
+
+const path = require("path");
+
+module.exports = function relative(root, file) {
+  const rootPath = root.replace(/\\/g, "/").split("/")[1];
+  const filePath = file.replace(/\\/g, "/").split("/")[1]; // If the file is in a completely different root folder
+  // use the absolute path of the file
+
+  if (rootPath && rootPath !== filePath) {
+    return file;
+  }
+
+  return path.relative(root, file);
+};
\ No newline at end of file