switch to vuepress

3 files changed, 335 insertions, 0 deletions

diff --git a/node_modules/uglifyjs-webpack-plugin/dist/uglify/Runner.js b/node_modules/uglifyjs-webpack-plugin/dist/uglify/Runner.js
new file mode 100644
index 00000000..8bf50307
--- /dev/null
+++ b/node_modules/uglifyjs-webpack-plugin/dist/uglify/Runner.js
@@ -0,0 +1,136 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _os = require('os');
+
+var _os2 = _interopRequireDefault(_os);
+
+var _cacache = require('cacache');
+
+var _cacache2 = _interopRequireDefault(_cacache);
+
+var _findCacheDir = require('find-cache-dir');
+
+var _findCacheDir2 = _interopRequireDefault(_findCacheDir);
+
+var _workerFarm = require('worker-farm');
+
+var _workerFarm2 = _interopRequireDefault(_workerFarm);
+
+var _serializeJavascript = require('serialize-javascript');
+
+var _serializeJavascript2 = _interopRequireDefault(_serializeJavascript);
+
+var _minify = require('./minify');
+
+var _minify2 = _interopRequireDefault(_minify);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var workerFile = require.resolve('./worker');
+
+try {
+  // run test
+  workerFile = require.resolve('../../dist/uglify/worker');
+} catch (e) {} // eslint-disable-line no-empty
+
+var Runner = function () {
+  function Runner() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    _classCallCheck(this, Runner);
+
+    var cache = options.cache,
+        parallel = options.parallel;
+
+    this.cacheDir = cache === true ? (0, _findCacheDir2.default)({ name: 'uglifyjs-webpack-plugin' }) : cache;
+    // In some cases cpus() returns undefined
+    // https://github.com/nodejs/node/issues/19022
+    var cpus = _os2.default.cpus() || { length: 1 };
+    this.maxConcurrentWorkers = parallel === true ? cpus.length - 1 : Math.min(Number(parallel) || 0, cpus.length - 1);
+  }
+
+  _createClass(Runner, [{
+    key: 'runTasks',
+    value: function runTasks(tasks, callback) {
+      var _this = this;
+
+      /* istanbul ignore if */
+      if (!tasks.length) {
+        callback(null, []);
+        return;
+      }
+
+      if (this.maxConcurrentWorkers > 1) {
+        var workerOptions = process.platform === 'win32' ? { maxConcurrentWorkers: this.maxConcurrentWorkers, maxConcurrentCallsPerWorker: 1 } : { maxConcurrentWorkers: this.maxConcurrentWorkers };
+        this.workers = (0, _workerFarm2.default)(workerOptions, workerFile);
+        this.boundWorkers = function (options, cb) {
+          return _this.workers((0, _serializeJavascript2.default)(options), cb);
+        };
+      } else {
+        this.boundWorkers = function (options, cb) {
+          try {
+            cb(null, (0, _minify2.default)(options));
+          } catch (error) {
+            cb(error);
+          }
+        };
+      }
+
+      var toRun = tasks.length;
+      var results = [];
+      var step = function step(index, data) {
+        toRun -= 1;
+        results[index] = data;
+
+        if (!toRun) {
+          callback(null, results);
+        }
+      };
+
+      tasks.forEach(function (task, index) {
+        var enqueue = function enqueue() {
+          _this.boundWorkers(task, function (error, data) {
+            var result = error ? { error } : data;
+            var done = function done() {
+              return step(index, result);
+            };
+
+            if (_this.cacheDir && !result.error) {
+              _cacache2.default.put(_this.cacheDir, (0, _serializeJavascript2.default)(task.cacheKeys), JSON.stringify(data)).then(done, done);
+            } else {
+              done();
+            }
+          });
+        };
+
+        if (_this.cacheDir) {
+          _cacache2.default.get(_this.cacheDir, (0, _serializeJavascript2.default)(task.cacheKeys)).then(function (_ref) {
+            var data = _ref.data;
+            return step(index, JSON.parse(data));
+          }, enqueue);
+        } else {
+          enqueue();
+        }
+      });
+    }
+  }, {
+    key: 'exit',
+    value: function exit() {
+      if (this.workers) {
+        _workerFarm2.default.end(this.workers);
+      }
+    }
+  }]);
+
+  return Runner;
+}();
+
+exports.default = Runner;
\ No newline at end of file
diff --git a/node_modules/uglifyjs-webpack-plugin/dist/uglify/minify.js b/node_modules/uglifyjs-webpack-plugin/dist/uglify/minify.js
new file mode 100644
index 00000000..0ff648c4
--- /dev/null
+++ b/node_modules/uglifyjs-webpack-plugin/dist/uglify/minify.js
@@ -0,0 +1,179 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _uglifyEs = require('uglify-es');
+
+var _uglifyEs2 = _interopRequireDefault(_uglifyEs);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var buildUglifyOptions = function buildUglifyOptions() {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      ecma = _ref.ecma,
+      warnings = _ref.warnings,
+      _ref$parse = _ref.parse,
+      parse = _ref$parse === undefined ? {} : _ref$parse,
+      _ref$compress = _ref.compress,
+      compress = _ref$compress === undefined ? {} : _ref$compress,
+      mangle = _ref.mangle,
+      output = _ref.output,
+      toplevel = _ref.toplevel,
+      nameCache = _ref.nameCache,
+      ie8 = _ref.ie8,
+      keep_classnames = _ref.keep_classnames,
+      keep_fnames = _ref.keep_fnames,
+      safari10 = _ref.safari10;
+
+  return {
+    ecma,
+    warnings,
+    parse: Object.assign({}, parse),
+    compress: typeof compress === 'boolean' ? compress : Object.assign({}, compress),
+    // eslint-disable-next-line no-nested-ternary
+    mangle: mangle == null ? true : typeof mangle === 'boolean' ? mangle : Object.assign({}, mangle),
+    output: Object.assign({
+      shebang: true,
+      comments: false,
+      beautify: false,
+      semicolons: true
+    }, output),
+    // Ignoring sourceMap from options
+    sourceMap: null,
+    toplevel,
+    nameCache,
+    ie8,
+    keep_classnames,
+    keep_fnames,
+    safari10
+  };
+}; /* eslint-disable
+     arrow-body-style
+   */
+
+
+var buildComments = function buildComments(options, uglifyOptions, extractedComments) {
+  var condition = {};
+  var commentsOpts = uglifyOptions.output.comments;
+
+  // /^\**!|@preserve|@license|@cc_on/
+  if (typeof options.extractComments === 'boolean') {
+    condition.preserve = commentsOpts;
+    condition.extract = /^\**!|@preserve|@license|@cc_on/;
+  } else if (typeof options.extractComments === 'string' || options.extractComments instanceof RegExp) {
+    // extractComments specifies the extract condition and commentsOpts specifies the preserve condition
+    condition.preserve = commentsOpts;
+    condition.extract = options.extractComments;
+  } else if (typeof options.extractComments === 'function') {
+    condition.preserve = false;
+    condition.extract = options.extractComments;
+  } else if (Object.prototype.hasOwnProperty.call(options.extractComments, 'condition')) {
+    // Extract condition is given in extractComments.condition
+    condition.preserve = commentsOpts;
+    condition.extract = options.extractComments.condition;
+  } else {
+    // No extract condition is given. Extract comments that match commentsOpts instead of preserving them
+    condition.preserve = false;
+    condition.extract = commentsOpts;
+  }
+
+  // Ensure that both conditions are functions
+  ['preserve', 'extract'].forEach(function (key) {
+    var regexStr = void 0;
+    var regex = void 0;
+
+    switch (typeof condition[key]) {
+      case 'boolean':
+        condition[key] = condition[key] ? function () {
+          return true;
+        } : function () {
+          return false;
+        };
+
+        break;
+      case 'function':
+        break;
+      case 'string':
+        if (condition[key] === 'all') {
+          condition[key] = function () {
+            return true;
+          };
+
+          break;
+        }
+
+        if (condition[key] === 'some') {
+          condition[key] = function (astNode, comment) {
+            return comment.type === 'comment2' && /@preserve|@license|@cc_on/i.test(comment.value);
+          };
+
+          break;
+        }
+
+        regexStr = condition[key];
+
+        condition[key] = function (astNode, comment) {
+          return new RegExp(regexStr).test(comment.value);
+        };
+
+        break;
+      default:
+        regex = condition[key];
+
+        condition[key] = function (astNode, comment) {
+          return regex.test(comment.value);
+        };
+    }
+  });
+
+  // Redefine the comments function to extract and preserve
+  // comments according to the two conditions
+  return function (astNode, comment) {
+    if (condition.extract(astNode, comment)) {
+      extractedComments.push(comment.type === 'comment2' ? `/*${comment.value}*/` : `//${comment.value}`);
+    }
+
+    return condition.preserve(astNode, comment);
+  };
+};
+
+var minify = function minify(options) {
+  var file = options.file,
+      input = options.input,
+      inputSourceMap = options.inputSourceMap,
+      extractComments = options.extractComments,
+      minifyFn = options.minify;
+
+
+  if (minifyFn) {
+    return minifyFn({ [file]: input }, inputSourceMap);
+  }
+
+  // Copy uglify options
+  var uglifyOptions = buildUglifyOptions(options.uglifyOptions);
+
+  // Add source map data
+  if (inputSourceMap) {
+    uglifyOptions.sourceMap = {
+      content: inputSourceMap
+    };
+  }
+
+  var extractedComments = [];
+
+  if (extractComments) {
+    uglifyOptions.output.comments = buildComments(options, uglifyOptions, extractedComments);
+  }
+
+  var _uglify$minify = _uglifyEs2.default.minify({ [file]: input }, uglifyOptions),
+      error = _uglify$minify.error,
+      map = _uglify$minify.map,
+      code = _uglify$minify.code,
+      warnings = _uglify$minify.warnings;
+
+  return { error, map, code, warnings, extractedComments };
+};
+
+exports.default = minify;
\ No newline at end of file
diff --git a/node_modules/uglifyjs-webpack-plugin/dist/uglify/worker.js b/node_modules/uglifyjs-webpack-plugin/dist/uglify/worker.js
new file mode 100644
index 00000000..94493565
--- /dev/null
+++ b/node_modules/uglifyjs-webpack-plugin/dist/uglify/worker.js
@@ -0,0 +1,20 @@
+'use strict';
+
+var _minify = require('./minify');
+
+var _minify2 = _interopRequireDefault(_minify);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+module.exports = function (options, callback) {
+  try {
+    // 'use strict' => this === undefined (Clean Scope)
+    // Safer for possible security issues, albeit not critical at all here
+    // eslint-disable-next-line no-new-func, no-param-reassign
+    options = new Function('exports', 'require', 'module', '__filename', '__dirname', `'use strict'\nreturn ${options}`)(exports, require, module, __filename, __dirname);
+
+    callback(null, (0, _minify2.default)(options));
+  } catch (errors) {
+    callback(errors);
+  }
+};
\ No newline at end of file