save me

node_modules/babel-loader/lib/fs-cache.js

@@ -0,0 +1,106 @@
+"use strict";
+
+var crypto = require("crypto");
+var mkdirp = require("mkdirp");
+var findCacheDir = require("find-cache-dir");
+var fs = require("fs");
+var os = require("os");
+var path = require("path");
+var zlib = require("zlib");
+
+var defaultCacheDirectory = null;
+var read = function read(filename, callback) {
+  return fs.readFile(filename, function (err, data) {
+    if (err) {
+      return callback(err);
+    }
+
+    return zlib.gunzip(data, function (err, content) {
+      var result = {};
+
+      if (err) {
+        return callback(err);
+      }
+
+      try {
+        result = JSON.parse(content);
+      } catch (e) {
+        return callback(e);
+      }
+
+      return callback(null, result);
+    });
+  });
+};
+
+var write = function write(filename, result, callback) {
+  var content = JSON.stringify(result);
+
+  return zlib.gzip(content, function (err, data) {
+    if (err) {
+      return callback(err);
+    }
+
+    return fs.writeFile(filename, data, callback);
+  });
+};
+
+var filename = function filename(source, identifier, options) {
+  var hash = crypto.createHash("SHA1");
+  var contents = JSON.stringify({
+    source: source,
+    options: options,
+    identifier: identifier
+  });
+
+  hash.end(contents);
+
+  return hash.read().toString("hex") + ".json.gz";
+};
+
+var handleCache = function handleCache(directory, params, callback) {
+  var source = params.source;
+  var options = params.options || {};
+  var transform = params.transform;
+  var identifier = params.identifier;
+  var shouldFallback = typeof params.directory !== "string" && directory !== os.tmpdir();
+
+  mkdirp(directory, function (err) {
+    if (err) return shouldFallback ? handleCache(os.tmpdir(), params, callback) : callback(err);
+
+    var file = path.join(directory, filename(source, identifier, options));
+
+    return read(file, function (err, content) {
+      var result = {};
+
+      if (!err) return callback(null, content);
+
+      try {
+        result = transform(source, options);
+      } catch (error) {
+        return callback(error);
+      }
+
+      return write(file, result, function (err) {
+        if (err) return shouldFallback ? handleCache(os.tmpdir(), params, callback) : callback(err);
+
+        callback(null, result);
+      });
+    });
+  });
+};
+
+module.exports = function (params, callback) {
+  var directory = void 0;
+
+  if (typeof params.directory === "string") {
+    directory = params.directory;
+  } else {
+    if (defaultCacheDirectory === null) {
+      defaultCacheDirectory = findCacheDir({ name: "babel-loader" }) || os.tmpdir();
+    }
+    directory = defaultCacheDirectory;
+  }
+
+  handleCache(directory, params, callback);
+};

node_modules/babel-loader/lib/index.js

@@ -0,0 +1,173 @@
+"use strict";
+
+var assign = require("object-assign");
+var babel = require("babel-core");
+var loaderUtils = require("loader-utils");
+var path = require("path");
+var cache = require("./fs-cache.js");
+var exists = require("./utils/exists")();
+var relative = require("./utils/relative");
+var read = require("./utils/read")();
+var resolveRc = require("./resolve-rc.js");
+var pkg = require("./../package.json");
+
+function BabelLoaderError(name, message, codeFrame, hideStack, error) {
+  Error.call(this);
+  Error.captureStackTrace(this, BabelLoaderError);
+
+  this.name = "BabelLoaderError";
+  this.message = formatMessage(name, message, codeFrame);
+  this.hideStack = hideStack;
+  this.error = error;
+}
+
+BabelLoaderError.prototype = Object.create(Error.prototype);
+BabelLoaderError.prototype.constructor = BabelLoaderError;
+
+var STRIP_FILENAME_RE = /^[^:]+: /;
+
+var formatMessage = function formatMessage(name, message, codeFrame) {
+  return (name ? name + ": " : "") + message + "\n\n" + codeFrame + "\n";
+};
+
+var transpile = function transpile(source, options) {
+  var forceEnv = options.forceEnv;
+  var tmpEnv = void 0;
+
+  delete options.forceEnv;
+
+  if (forceEnv) {
+    tmpEnv = process.env.BABEL_ENV;
+    process.env.BABEL_ENV = forceEnv;
+  }
+
+  var result = void 0;
+  try {
+    result = babel.transform(source, options);
+  } catch (error) {
+    if (forceEnv) restoreBabelEnv(tmpEnv);
+    if (error.message && error.codeFrame) {
+      var message = error.message;
+      var name = void 0;
+      var hideStack = void 0;
+      if (error instanceof SyntaxError) {
+        message = message.replace(STRIP_FILENAME_RE, "");
+        name = "SyntaxError";
+        hideStack = true;
+      } else if (error instanceof TypeError) {
+        message = message.replace(STRIP_FILENAME_RE, "");
+        hideStack = true;
+      }
+      throw new BabelLoaderError(name, message, error.codeFrame, hideStack, error);
+    } else {
+      throw error;
+    }
+  }
+  var code = result.code;
+  var map = result.map;
+  var metadata = result.metadata;
+
+  if (map && (!map.sourcesContent || !map.sourcesContent.length)) {
+    map.sourcesContent = [source];
+  }
+
+  if (forceEnv) restoreBabelEnv(tmpEnv);
+
+  return {
+    code: code,
+    map: map,
+    metadata: metadata
+  };
+};
+
+function restoreBabelEnv(prevValue) {
+  if (prevValue === undefined) {
+    delete process.env.BABEL_ENV;
+  } else {
+    process.env.BABEL_ENV = prevValue;
+  }
+}
+
+function passMetadata(s, context, metadata) {
+  if (context[s]) {
+    context[s](metadata);
+  }
+}
+
+module.exports = function (source, inputSourceMap) {
+  var _this = this;
+
+  var webpackRemainingChain = loaderUtils.getRemainingRequest(this).split("!");
+  var filename = webpackRemainingChain[webpackRemainingChain.length - 1];
+
+  var globalOptions = this.options.babel || {};
+  var loaderOptions = loaderUtils.parseQuery(this.query);
+  var userOptions = assign({}, globalOptions, loaderOptions);
+  var defaultOptions = {
+    metadataSubscribers: [],
+    inputSourceMap: inputSourceMap,
+    sourceRoot: process.cwd(),
+    filename: filename,
+    cacheIdentifier: JSON.stringify({
+      "babel-loader": pkg.version,
+      "babel-core": babel.version,
+      babelrc: exists(userOptions.babelrc) ? read(userOptions.babelrc) : resolveRc(path.dirname(filename)),
+      env: userOptions.forceEnv || process.env.BABEL_ENV || process.env.NODE_ENV || "development"
+    })
+  };
+
+  var options = assign({}, defaultOptions, userOptions);
+
+  if (userOptions.sourceMap === undefined) {
+    options.sourceMap = this.sourceMap;
+  }
+
+  if (options.sourceFileName === undefined) {
+    options.sourceFileName = relative(options.sourceRoot, options.filename);
+  }
+
+  var cacheDirectory = options.cacheDirectory;
+  var cacheIdentifier = options.cacheIdentifier;
+  var metadataSubscribers = options.metadataSubscribers;
+
+  delete options.cacheDirectory;
+  delete options.cacheIdentifier;
+  delete options.metadataSubscribers;
+
+  this.cacheable();
+
+  if (cacheDirectory) {
+    var callback = this.async();
+    return cache({
+      directory: cacheDirectory,
+      identifier: cacheIdentifier,
+      source: source,
+      options: options,
+      transform: transpile
+    }, function (err) {
+      var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+          code = _ref.code,
+          map = _ref.map,
+          metadata = _ref.metadata;
+
+      if (err) return callback(err);
+
+      metadataSubscribers.forEach(function (s) {
+        return passMetadata(s, _this, metadata);
+      });
+
+      return callback(null, code, map);
+    });
+  }
+
+  var _transpile = transpile(source, options),
+      code = _transpile.code,
+      map = _transpile.map,
+      metadata = _transpile.metadata;
+
+  metadataSubscribers.forEach(function (s) {
+    return passMetadata(s, _this, metadata);
+  });
+
+  this.callback(null, code, map);
+};

node_modules/babel-loader/lib/resolve-rc.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var path = require("path");
+var exists = require("./utils/exists")({});
+var read = require("./utils/read")({});
+
+var cache = {};
+
+var find = function find(start, rel) {
+  var file = path.join(start, rel);
+
+  if (exists(file)) {
+    return read(file);
+  }
+
+  var up = path.dirname(start);
+  if (up !== start) {
+    return find(up, rel);
+  }
+};
+
+module.exports = function (loc, rel) {
+  rel = rel || ".babelrc";
+  var cacheKey = loc + "/" + rel;
+  if (!(cacheKey in cache)) {
+    cache[cacheKey] = find(loc, rel);
+  }
+  return cache[cacheKey];
+};

node_modules/babel-loader/lib/utils/exists.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var fs = require("fs");
+
+module.exports = function (cache) {
+  cache = cache || {};
+
+  return function (filename) {
+
+    if (!filename) {
+      return false;
+    }
+
+    cache[filename] = cache[filename] || fs.existsSync(filename);
+
+    return cache[filename];
+  };
+};

node_modules/babel-loader/lib/utils/read.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var fs = require("fs");
+
+module.exports = function (cache) {
+  cache = cache || {};
+
+  return function (filename) {
+
+    if (!filename) {
+      throw new Error("filename must be a string");
+    }
+
+    cache[filename] = cache[filename] || fs.readFileSync(filename, "utf8");
+
+    return cache[filename];
+  };
+};

node_modules/babel-loader/lib/utils/relative.js

@@ -0,0 +1,14 @@
+"use strict";
+
+var path = require("path");
+
+module.exports = function relative(sourceRoot, filename) {
+  var rootPath = sourceRoot.replace(/\\/g, "/").split("/")[1];
+  var fileRootPath = filename.replace(/\\/g, "/").split("/")[1];
+
+  if (rootPath && rootPath !== fileRootPath) {
+    return filename;
+  }
+
+  return path.relative(sourceRoot, filename);
+};