diff --git a/lib/common/asar.js b/lib/common/asar.js
index e3996a193ace..262412813221 100644
--- a/lib/common/asar.js
+++ b/lib/common/asar.js
@@ -1,70 +1,71 @@
 (function () {
-  const asar = process.binding('atom_common_asar');
-  const child_process = require('child_process');
-  const path = require('path');
-  const util = require('util');
+  const asar = process.binding('atom_common_asar')
+  const child_process = require('child_process')
+  const path = require('path')
+  const util = require('util')
 
-  var hasProp = {}.hasOwnProperty;
+  var hasProp = {}.hasOwnProperty
 
   // Cache asar archive objects.
-  var cachedArchives = {};
+  var cachedArchives = {}
 
-  var getOrCreateArchive = function(p) {
-    var archive;
-    archive = cachedArchives[p];
+  var getOrCreateArchive = function (p) {
+    var archive
+    archive = cachedArchives[p]
     if (archive != null) {
-      return archive;
+      return archive
     }
-    archive = asar.createArchive(p);
+    archive = asar.createArchive(p)
     if (!archive) {
-      return false;
+      return false
     }
-    return cachedArchives[p] = archive;
-  };
+    cachedArchives[p] = archive
+    return archive
+  }
 
   // Clean cache on quit.
-  process.on('exit', function() {
-    var archive, p;
+  process.on('exit', function () {
+    var archive, p
     for (p in cachedArchives) {
-      if (!hasProp.call(cachedArchives, p)) continue;
-      archive = cachedArchives[p];
-      archive.destroy();
+      if (!hasProp.call(cachedArchives, p)) continue
+      archive = cachedArchives[p]
+      archive.destroy()
     }
-  });
+  })
 
   // Separate asar package's path from full path.
-  var splitPath = function(p) {
-    var index;
+  var splitPath = function (p) {
+    var index
 
     // shortcut to disable asar.
     if (process.noAsar) {
-      return [false];
+      return [false]
     }
 
     if (typeof p !== 'string') {
-      return [false];
+      return [false]
     }
     if (p.substr(-5) === '.asar') {
-      return [true, p, ''];
+      return [true, p, '']
     }
-    p = path.normalize(p);
-    index = p.lastIndexOf(".asar" + path.sep);
+    p = path.normalize(p)
+    index = p.lastIndexOf('.asar' + path.sep)
     if (index === -1) {
-      return [false];
+      return [false]
     }
-    return [true, p.substr(0, index + 5), p.substr(index + 6)];
-  };
+    return [true, p.substr(0, index + 5), p.substr(index + 6)]
+  }
 
   // Convert asar archive's Stats object to fs's Stats object.
-  var nextInode = 0;
+  var nextInode = 0
 
-  var uid = process.getuid != null ? process.getuid() : 0;
+  var uid = process.getuid != null ? process.getuid() : 0
 
-  var gid = process.getgid != null ? process.getgid() : 0;
+  var gid = process.getgid != null ? process.getgid() : 0
 
-  var fakeTime = new Date();
+  var fakeTime = new Date()
 
-  var asarStatsToFsStats = function(stats) {
+  var asarStatsToFsStats = function (stats) {
     return {
       dev: 1,
       ino: ++nextInode,
@@ -78,521 +79,521 @@
       mtime: stats.mtime || fakeTime,
       ctime: stats.ctime || fakeTime,
       size: stats.size,
-      isFile: function() {
-        return stats.isFile;
+      isFile: function () {
+        return stats.isFile
       },
-      isDirectory: function() {
-        return stats.isDirectory;
+      isDirectory: function () {
+        return stats.isDirectory
       },
-      isSymbolicLink: function() {
-        return stats.isLink;
+      isSymbolicLink: function () {
+        return stats.isLink
       },
-      isBlockDevice: function() {
-        return false;
+      isBlockDevice: function () {
+        return false
       },
-      isCharacterDevice: function() {
-        return false;
+      isCharacterDevice: function () {
+        return false
       },
-      isFIFO: function() {
-        return false;
+      isFIFO: function () {
+        return false
       },
-      isSocket: function() {
-        return false;
+      isSocket: function () {
+        return false
       }
-    };
-  };
+    }
+  }
 
   // Create a ENOENT error.
-  var notFoundError = function(asarPath, filePath, callback) {
-    var error;
-    error = new Error("ENOENT, " + filePath + " not found in " + asarPath);
-    error.code = "ENOENT";
-    error.errno = -2;
+  var notFoundError = function (asarPath, filePath, callback) {
+    var error
+    error = new Error(`ENOENT, ${filePath} not found in ${asarPath}`)
+    error.code = 'ENOENT'
+    error.errno = -2
     if (typeof callback !== 'function') {
-      throw error;
+      throw error
     }
-    return process.nextTick(function() {
-      return callback(error);
-    });
-  };
+    return process.nextTick(function () {
+      return callback(error)
+    })
+  }
 
   // Create a ENOTDIR error.
-  var notDirError = function(callback) {
-    var error;
-    error = new Error('ENOTDIR, not a directory');
-    error.code = 'ENOTDIR';
-    error.errno = -20;
+  var notDirError = function (callback) {
+    var error
+    error = new Error('ENOTDIR, not a directory')
+    error.code = 'ENOTDIR'
+    error.errno = -20
     if (typeof callback !== 'function') {
-      throw error;
+      throw error
     }
-    return process.nextTick(function() {
-      return callback(error);
-    });
-  };
+    return process.nextTick(function () {
+      return callback(error)
+    })
+  }
 
   // Create invalid archive error.
-  var invalidArchiveError = function(asarPath, callback) {
-    var error;
-    error = new Error("Invalid package " + asarPath);
+  var invalidArchiveError = function (asarPath, callback) {
+    var error
+    error = new Error(`Invalid package ${asarPath}`)
     if (typeof callback !== 'function') {
-      throw error;
+      throw error
     }
-    return process.nextTick(function() {
-      return callback(error);
-    });
-  };
+    return process.nextTick(function () {
+      return callback(error)
+    })
+  }
 
   // Override APIs that rely on passing file path instead of content to C++.
-  var overrideAPISync = function(module, name, arg) {
-    var old;
+  var overrideAPISync = function (module, name, arg) {
+    var old
     if (arg == null) {
-      arg = 0;
+      arg = 0
     }
-    old = module[name];
-    return module[name] = function() {
-      var archive, newPath, p;
-      p = arguments[arg];
-      const [isAsar, asarPath, filePath] = splitPath(p);
+    old = module[name]
+    module[name] = function () {
+      var archive, newPath, p
+      p = arguments[arg]
+      const [isAsar, asarPath, filePath] = splitPath(p)
       if (!isAsar) {
-        return old.apply(this, arguments);
+        return old.apply(this, arguments)
       }
-      archive = getOrCreateArchive(asarPath);
+      archive = getOrCreateArchive(asarPath)
       if (!archive) {
-        invalidArchiveError(asarPath);
+        invalidArchiveError(asarPath)
       }
-      newPath = archive.copyFileOut(filePath);
+      newPath = archive.copyFileOut(filePath)
       if (!newPath) {
-        notFoundError(asarPath, filePath);
+        notFoundError(asarPath, filePath)
       }
-      arguments[arg] = newPath;
-      return old.apply(this, arguments);
-    };
-  };
+      arguments[arg] = newPath
+      return old.apply(this, arguments)
+    }
+  }
 
-  var overrideAPI = function(module, name, arg) {
-    var old;
+  var overrideAPI = function (module, name, arg) {
+    var old
     if (arg == null) {
-      arg = 0;
+      arg = 0
     }
-    old = module[name];
-    return module[name] = function() {
-      var archive, callback, newPath, p;
-      p = arguments[arg];
-      const [isAsar, asarPath, filePath] = splitPath(p);
+    old = module[name]
+    module[name] = function () {
+      var archive, callback, newPath, p
+      p = arguments[arg]
+      const [isAsar, asarPath, filePath] = splitPath(p)
       if (!isAsar) {
-        return old.apply(this, arguments);
+        return old.apply(this, arguments)
       }
-      callback = arguments[arguments.length - 1];
+      callback = arguments[arguments.length - 1]
       if (typeof callback !== 'function') {
-        return overrideAPISync(module, name, arg);
+        return overrideAPISync(module, name, arg)
       }
-      archive = getOrCreateArchive(asarPath);
+      archive = getOrCreateArchive(asarPath)
       if (!archive) {
-        return invalidArchiveError(asarPath, callback);
+        return invalidArchiveError(asarPath, callback)
       }
-      newPath = archive.copyFileOut(filePath);
+      newPath = archive.copyFileOut(filePath)
       if (!newPath) {
-        return notFoundError(asarPath, filePath, callback);
+        return notFoundError(asarPath, filePath, callback)
       }
-      arguments[arg] = newPath;
-      return old.apply(this, arguments);
-    };
-  };
+      arguments[arg] = newPath
+      return old.apply(this, arguments)
+    }
+  }
 
   // Override fs APIs.
-  exports.wrapFsWithAsar = function(fs) {
-    var exists, existsSync, internalModuleReadFile, internalModuleStat, lstat, lstatSync, mkdir, mkdirSync, readFile, readFileSync, readdir, readdirSync, realpath, realpathSync, stat, statSync, statSyncNoException, logFDs, logASARAccess;
+  exports.wrapFsWithAsar = function (fs) {
+    var exists, existsSync, internalModuleReadFile, internalModuleStat, lstat, lstatSync, mkdir, mkdirSync, readFile, readFileSync, readdir, readdirSync, realpath, realpathSync, stat, statSync, statSyncNoException, logFDs, logASARAccess
 
-    logFDs = {};
-    logASARAccess = function(asarPath, filePath, offset) {
+    logFDs = {}
+    logASARAccess = function (asarPath, filePath, offset) {
       if (!process.env.ELECTRON_LOG_ASAR_READS) {
-        return;
+        return
       }
       if (!logFDs[asarPath]) {
-        var logFilename, logPath;
-        const path = require('path');
-        logFilename = path.basename(asarPath, '.asar') + '-access-log.txt';
-        logPath = path.join(require('os').tmpdir(), logFilename);
-        logFDs[asarPath] = fs.openSync(logPath, 'a');
-        console.log('Logging ' + asarPath + ' access to ' + logPath);
+        var logFilename, logPath
+        const path = require('path')
+        logFilename = path.basename(asarPath, '.asar') + '-access-log.txt'
+        logPath = path.join(require('os').tmpdir(), logFilename)
+        logFDs[asarPath] = fs.openSync(logPath, 'a')
+        console.log('Logging ' + asarPath + ' access to ' + logPath)
       }
-      fs.writeSync(logFDs[asarPath], offset + ': ' + filePath + '\n');
-    };
+      fs.writeSync(logFDs[asarPath], offset + ': ' + filePath + '\n')
+    }
 
-    lstatSync = fs.lstatSync;
-    fs.lstatSync = function(p) {
-      var archive, stats;
-      const [isAsar, asarPath, filePath] = splitPath(p);
+    lstatSync = fs.lstatSync
+    fs.lstatSync = function (p) {
+      var archive, stats
+      const [isAsar, asarPath, filePath] = splitPath(p)
       if (!isAsar) {
-        return lstatSync(p);
+        return lstatSync(p)
       }
-      archive = getOrCreateArchive(asarPath);
+      archive = getOrCreateArchive(asarPath)
       if (!archive) {
-        invalidArchiveError(asarPath);
+        invalidArchiveError(asarPath)
       }
-      stats = archive.stat(filePath);
+      stats = archive.stat(filePath)
       if (!stats) {
-        notFoundError(asarPath, filePath);
+        notFoundError(asarPath, filePath)
       }
-      return asarStatsToFsStats(stats);
-    };
-    lstat = fs.lstat;
-    fs.lstat = function(p, callback) {
-      var archive, stats;
-      const [isAsar, asarPath, filePath] = splitPath(p);
+      return asarStatsToFsStats(stats)
+    }
+    lstat = fs.lstat
+    fs.lstat = function (p, callback) {
+      var archive, stats
+      const [isAsar, asarPath, filePath] = splitPath(p)
       if (!isAsar) {
-        return lstat(p, callback);
+        return lstat(p, callback)
       }
-      archive = getOrCreateArchive(asarPath);
+      archive = getOrCreateArchive(asarPath)
       if (!archive) {
-        return invalidArchiveError(asarPath, callback);
+        return invalidArchiveError(asarPath, callback)
       }
-      stats = getOrCreateArchive(asarPath).stat(filePath);
+      stats = getOrCreateArchive(asarPath).stat(filePath)
       if (!stats) {
-        return notFoundError(asarPath, filePath, callback);
+        return notFoundError(asarPath, filePath, callback)
       }
-      return process.nextTick(function() {
-        return callback(null, asarStatsToFsStats(stats));
-      });
-    };
-    statSync = fs.statSync;
-    fs.statSync = function(p) {
-      const [isAsar] = splitPath(p);
+      return process.nextTick(function () {
+        return callback(null, asarStatsToFsStats(stats))
+      })
+    }
+    statSync = fs.statSync
+    fs.statSync = function (p) {
+      const [isAsar] = splitPath(p)
       if (!isAsar) {
-        return statSync(p);
+        return statSync(p)
       }
 
       // Do not distinguish links for now.
-      return fs.lstatSync(p);
-    };
-    stat = fs.stat;
-    fs.stat = function(p, callback) {
-      const [isAsar] = splitPath(p);
+      return fs.lstatSync(p)
+    }
+    stat = fs.stat
+    fs.stat = function (p, callback) {
+      const [isAsar] = splitPath(p)
       if (!isAsar) {
-        return stat(p, callback);
+        return stat(p, callback)
       }
 
       // Do not distinguish links for now.
-      return process.nextTick(function() {
-        return fs.lstat(p, callback);
-      });
-    };
-    statSyncNoException = fs.statSyncNoException;
-    fs.statSyncNoException = function(p) {
-      var archive, stats;
-      const [isAsar, asarPath, filePath] = splitPath(p);
+      return process.nextTick(function () {
+        return fs.lstat(p, callback)
+      })
+    }
+    statSyncNoException = fs.statSyncNoException
+    fs.statSyncNoException = function (p) {
+      var archive, stats
+      const [isAsar, asarPath, filePath] = splitPath(p)
       if (!isAsar) {
-        return statSyncNoException(p);
+        return statSyncNoException(p)
       }
-      archive = getOrCreateArchive(asarPath);
+      archive = getOrCreateArchive(asarPath)
       if (!archive) {
-        return false;
+        return false
       }
-      stats = archive.stat(filePath);
+      stats = archive.stat(filePath)
       if (!stats) {
-        return false;
+        return false
       }
-      return asarStatsToFsStats(stats);
-    };
-    realpathSync = fs.realpathSync;
-    fs.realpathSync = function(p) {
-      var archive, real;
-      const [isAsar, asarPath, filePath] = splitPath(p);
+      return asarStatsToFsStats(stats)
+    }
+    realpathSync = fs.realpathSync
+    fs.realpathSync = function (p) {
+      var archive, real
+      const [isAsar, asarPath, filePath] = splitPath(p)
       if (!isAsar) {
-        return realpathSync.apply(this, arguments);
+        return realpathSync.apply(this, arguments)
       }
-      archive = getOrCreateArchive(asarPath);
+      archive = getOrCreateArchive(asarPath)
       if (!archive) {
-        invalidArchiveError(asarPath);
+        invalidArchiveError(asarPath)
       }
-      real = archive.realpath(filePath);
+      real = archive.realpath(filePath)
       if (real === false) {
-        notFoundError(asarPath, filePath);
+        notFoundError(asarPath, filePath)
       }
-      return path.join(realpathSync(asarPath), real);
-    };
-    realpath = fs.realpath;
-    fs.realpath = function(p, cache, callback) {
-      var archive, real;
-      const [isAsar, asarPath, filePath] = splitPath(p);
+      return path.join(realpathSync(asarPath), real)
+    }
+    realpath = fs.realpath
+    fs.realpath = function (p, cache, callback) {
+      var archive, real
+      const [isAsar, asarPath, filePath] = splitPath(p)
       if (!isAsar) {
-        return realpath.apply(this, arguments);
+        return realpath.apply(this, arguments)
       }
       if (typeof cache === 'function') {
-        callback = cache;
-        cache = void 0;
+        callback = cache
+        cache = void 0
       }
-      archive = getOrCreateArchive(asarPath);
+      archive = getOrCreateArchive(asarPath)
       if (!archive) {
-        return invalidArchiveError(asarPath, callback);
+        return invalidArchiveError(asarPath, callback)
       }
-      real = archive.realpath(filePath);
+      real = archive.realpath(filePath)
       if (real === false) {
-        return notFoundError(asarPath, filePath, callback);
+        return notFoundError(asarPath, filePath, callback)
       }
-      return realpath(asarPath, function(err, p) {
+      return realpath(asarPath, function (err, p) {
         if (err) {
-          return callback(err);
+          return callback(err)
         }
-        return callback(null, path.join(p, real));
-      });
-    };
-    exists = fs.exists;
-    fs.exists = function(p, callback) {
-      var archive;
-      const [isAsar, asarPath, filePath] = splitPath(p);
+        return callback(null, path.join(p, real))
+      })
+    }
+    exists = fs.exists
+    fs.exists = function (p, callback) {
+      var archive
+      const [isAsar, asarPath, filePath] = splitPath(p)
       if (!isAsar) {
-        return exists(p, callback);
+        return exists(p, callback)
       }
-      archive = getOrCreateArchive(asarPath);
+      archive = getOrCreateArchive(asarPath)
       if (!archive) {
-        return invalidArchiveError(asarPath, callback);
+        return invalidArchiveError(asarPath, callback)
       }
-      return process.nextTick(function() {
-        return callback(archive.stat(filePath) !== false);
-      });
-    };
-    existsSync = fs.existsSync;
-    fs.existsSync = function(p) {
-      var archive;
-      const [isAsar, asarPath, filePath] = splitPath(p);
+      return process.nextTick(function () {
+        return callback(archive.stat(filePath) !== false)
+      })
+    }
+    existsSync = fs.existsSync
+    fs.existsSync = function (p) {
+      var archive
+      const [isAsar, asarPath, filePath] = splitPath(p)
       if (!isAsar) {
-        return existsSync(p);
+        return existsSync(p)
       }
-      archive = getOrCreateArchive(asarPath);
+      archive = getOrCreateArchive(asarPath)
       if (!archive) {
-        return false;
+        return false
       }
-      return archive.stat(filePath) !== false;
-    };
-    readFile = fs.readFile;
-    fs.readFile = function(p, options, callback) {
-      var archive, buffer, encoding, fd, info, realPath;
-      const [isAsar, asarPath, filePath] = splitPath(p);
+      return archive.stat(filePath) !== false
+    }
+    readFile = fs.readFile
+    fs.readFile = function (p, options, callback) {
+      var archive, buffer, encoding, fd, info, realPath
+      const [isAsar, asarPath, filePath] = splitPath(p)
       if (!isAsar) {
-        return readFile.apply(this, arguments);
+        return readFile.apply(this, arguments)
       }
       if (typeof options === 'function') {
-        callback = options;
-        options = void 0;
+        callback = options
+        options = void 0
       }
-      archive = getOrCreateArchive(asarPath);
+      archive = getOrCreateArchive(asarPath)
       if (!archive) {
-        return invalidArchiveError(asarPath, callback);
+        return invalidArchiveError(asarPath, callback)
       }
-      info = archive.getFileInfo(filePath);
+      info = archive.getFileInfo(filePath)
       if (!info) {
-        return notFoundError(asarPath, filePath, callback);
+        return notFoundError(asarPath, filePath, callback)
       }
       if (info.size === 0) {
-        return process.nextTick(function() {
-          return callback(null, new Buffer(0));
-        });
+        return process.nextTick(function () {
+          return callback(null, new Buffer(0))
+        })
       }
       if (info.unpacked) {
-        realPath = archive.copyFileOut(filePath);
-        return fs.readFile(realPath, options, callback);
+        realPath = archive.copyFileOut(filePath)
+        return fs.readFile(realPath, options, callback)
       }
       if (!options) {
         options = {
           encoding: null
-        };
+        }
       } else if (util.isString(options)) {
         options = {
           encoding: options
-        };
+        }
       } else if (!util.isObject(options)) {
-        throw new TypeError('Bad arguments');
+        throw new TypeError('Bad arguments')
       }
-      encoding = options.encoding;
-      buffer = new Buffer(info.size);
-      fd = archive.getFd();
+      encoding = options.encoding
+      buffer = new Buffer(info.size)
+      fd = archive.getFd()
       if (!(fd >= 0)) {
-        return notFoundError(asarPath, filePath, callback);
+        return notFoundError(asarPath, filePath, callback)
       }
-      logASARAccess(asarPath, filePath, info.offset);
-      return fs.read(fd, buffer, 0, info.size, info.offset, function(error) {
-        return callback(error, encoding ? buffer.toString(encoding) : buffer);
-      });
-    };
-    readFileSync = fs.readFileSync;
-    fs.readFileSync = function(p, opts) {
+      logASARAccess(asarPath, filePath, info.offset)
+      return fs.read(fd, buffer, 0, info.size, info.offset, function (error) {
+        return callback(error, encoding ? buffer.toString(encoding) : buffer)
+      })
+    }
+    readFileSync = fs.readFileSync
+    fs.readFileSync = function (p, opts) {
       // this allows v8 to optimize this function
-      var archive, buffer, encoding, fd, info, options, realPath;
-      options = opts;
-      const [isAsar, asarPath, filePath] = splitPath(p);
+      var archive, buffer, encoding, fd, info, options, realPath
+      options = opts
+      const [isAsar, asarPath, filePath] = splitPath(p)
       if (!isAsar) {
-        return readFileSync.apply(this, arguments);
+        return readFileSync.apply(this, arguments)
       }
-      archive = getOrCreateArchive(asarPath);
+      archive = getOrCreateArchive(asarPath)
       if (!archive) {
-        invalidArchiveError(asarPath);
+        invalidArchiveError(asarPath)
       }
-      info = archive.getFileInfo(filePath);
+      info = archive.getFileInfo(filePath)
       if (!info) {
-        notFoundError(asarPath, filePath);
+        notFoundError(asarPath, filePath)
       }
       if (info.size === 0) {
         if (options) {
-          return '';
+          return ''
         } else {
-          return new Buffer(0);
+          return new Buffer(0)
         }
       }
       if (info.unpacked) {
-        realPath = archive.copyFileOut(filePath);
-        return fs.readFileSync(realPath, options);
+        realPath = archive.copyFileOut(filePath)
+        return fs.readFileSync(realPath, options)
       }
       if (!options) {
         options = {
           encoding: null
-        };
+        }
       } else if (util.isString(options)) {
         options = {
           encoding: options
-        };
+        }
       } else if (!util.isObject(options)) {
-        throw new TypeError('Bad arguments');
+        throw new TypeError('Bad arguments')
       }
-      encoding = options.encoding;
-      buffer = new Buffer(info.size);
-      fd = archive.getFd();
+      encoding = options.encoding
+      buffer = new Buffer(info.size)
+      fd = archive.getFd()
       if (!(fd >= 0)) {
-        notFoundError(asarPath, filePath);
+        notFoundError(asarPath, filePath)
       }
-      logASARAccess(asarPath, filePath, info.offset);
-      fs.readSync(fd, buffer, 0, info.size, info.offset);
+      logASARAccess(asarPath, filePath, info.offset)
+      fs.readSync(fd, buffer, 0, info.size, info.offset)
       if (encoding) {
-        return buffer.toString(encoding);
+        return buffer.toString(encoding)
       } else {
-        return buffer;
+        return buffer
       }
-    };
-    readdir = fs.readdir;
-    fs.readdir = function(p, callback) {
-      var archive, files;
-      const [isAsar, asarPath, filePath] = splitPath(p);
+    }
+    readdir = fs.readdir
+    fs.readdir = function (p, callback) {
+      var archive, files
+      const [isAsar, asarPath, filePath] = splitPath(p)
       if (!isAsar) {
-        return readdir.apply(this, arguments);
+        return readdir.apply(this, arguments)
       }
-      archive = getOrCreateArchive(asarPath);
+      archive = getOrCreateArchive(asarPath)
       if (!archive) {
-        return invalidArchiveError(asarPath, callback);
+        return invalidArchiveError(asarPath, callback)
       }
-      files = archive.readdir(filePath);
+      files = archive.readdir(filePath)
       if (!files) {
-        return notFoundError(asarPath, filePath, callback);
+        return notFoundError(asarPath, filePath, callback)
       }
-      return process.nextTick(function() {
-        return callback(null, files);
-      });
-    };
-    readdirSync = fs.readdirSync;
-    fs.readdirSync = function(p) {
-      var archive, files;
-      const [isAsar, asarPath, filePath] = splitPath(p);
+      return process.nextTick(function () {
+        return callback(null, files)
+      })
+    }
+    readdirSync = fs.readdirSync
+    fs.readdirSync = function (p) {
+      var archive, files
+      const [isAsar, asarPath, filePath] = splitPath(p)
       if (!isAsar) {
-        return readdirSync.apply(this, arguments);
+        return readdirSync.apply(this, arguments)
       }
-      archive = getOrCreateArchive(asarPath);
+      archive = getOrCreateArchive(asarPath)
       if (!archive) {
-        invalidArchiveError(asarPath);
+        invalidArchiveError(asarPath)
       }
-      files = archive.readdir(filePath);
+      files = archive.readdir(filePath)
       if (!files) {
-        notFoundError(asarPath, filePath);
+        notFoundError(asarPath, filePath)
       }
-      return files;
-    };
-    internalModuleReadFile = process.binding('fs').internalModuleReadFile;
-    process.binding('fs').internalModuleReadFile = function(p) {
-      var archive, buffer, fd, info, realPath;
-      const [isAsar, asarPath, filePath] = splitPath(p);
+      return files
+    }
+    internalModuleReadFile = process.binding('fs').internalModuleReadFile
+    process.binding('fs').internalModuleReadFile = function (p) {
+      var archive, buffer, fd, info, realPath
+      const [isAsar, asarPath, filePath] = splitPath(p)
       if (!isAsar) {
-        return internalModuleReadFile(p);
+        return internalModuleReadFile(p)
       }
-      archive = getOrCreateArchive(asarPath);
+      archive = getOrCreateArchive(asarPath)
       if (!archive) {
-        return void 0;
+        return void 0
       }
-      info = archive.getFileInfo(filePath);
+      info = archive.getFileInfo(filePath)
       if (!info) {
-        return void 0;
+        return void 0
       }
       if (info.size === 0) {
-        return '';
+        return ''
       }
       if (info.unpacked) {
-        realPath = archive.copyFileOut(filePath);
+        realPath = archive.copyFileOut(filePath)
         return fs.readFileSync(realPath, {
           encoding: 'utf8'
-        });
+        })
       }
-      buffer = new Buffer(info.size);
-      fd = archive.getFd();
+      buffer = new Buffer(info.size)
+      fd = archive.getFd()
       if (!(fd >= 0)) {
-        return void 0;
+        return void 0
       }
-      logASARAccess(asarPath, filePath, info.offset);
-      fs.readSync(fd, buffer, 0, info.size, info.offset);
-      return buffer.toString('utf8');
-    };
-    internalModuleStat = process.binding('fs').internalModuleStat;
-    process.binding('fs').internalModuleStat = function(p) {
-      var archive, stats;
-      const [isAsar, asarPath, filePath] = splitPath(p);
+      logASARAccess(asarPath, filePath, info.offset)
+      fs.readSync(fd, buffer, 0, info.size, info.offset)
+      return buffer.toString('utf8')
+    }
+    internalModuleStat = process.binding('fs').internalModuleStat
+    process.binding('fs').internalModuleStat = function (p) {
+      var archive, stats
+      const [isAsar, asarPath, filePath] = splitPath(p)
       if (!isAsar) {
-        return internalModuleStat(p);
+        return internalModuleStat(p)
       }
-      archive = getOrCreateArchive(asarPath);
+      archive = getOrCreateArchive(asarPath)
 
       // -ENOENT
       if (!archive) {
-        return -34;
+        return -34
       }
-      stats = archive.stat(filePath);
+      stats = archive.stat(filePath)
 
       // -ENOENT
       if (!stats) {
-        return -34;
+        return -34
       }
       if (stats.isDirectory) {
-        return 1;
+        return 1
       } else {
-        return 0;
+        return 0
       }
-    };
+    }
 
     // Calling mkdir for directory inside asar archive should throw ENOTDIR
     // error, but on Windows it throws ENOENT.
     // This is to work around the recursive looping bug of mkdirp since it is
     // widely used.
     if (process.platform === 'win32') {
-      mkdir = fs.mkdir;
-      fs.mkdir = function(p, mode, callback) {
+      mkdir = fs.mkdir
+      fs.mkdir = function (p, mode, callback) {
         if (typeof mode === 'function') {
-          callback = mode;
+          callback = mode
         }
-        const [isAsar, , filePath] = splitPath(p);
+        const [isAsar, , filePath] = splitPath(p)
         if (isAsar && filePath.length) {
-          return notDirError(callback);
+          return notDirError(callback)
         }
-        return mkdir(p, mode, callback);
-      };
-      mkdirSync = fs.mkdirSync;
-      fs.mkdirSync = function(p, mode) {
-        const [isAsar, , filePath] = splitPath(p);
+        return mkdir(p, mode, callback)
+      }
+      mkdirSync = fs.mkdirSync
+      fs.mkdirSync = function (p, mode) {
+        const [isAsar, , filePath] = splitPath(p)
         if (isAsar && filePath.length) {
-          notDirError();
+          notDirError()
         }
-        return mkdirSync(p, mode);
-      };
+        return mkdirSync(p, mode)
+      }
     }
-    overrideAPI(fs, 'open');
-    overrideAPI(child_process, 'execFile');
-    overrideAPISync(process, 'dlopen', 1);
-    overrideAPISync(require('module')._extensions, '.node', 1);
-    overrideAPISync(fs, 'openSync');
-    return overrideAPISync(child_process, 'execFileSync');
-  };
-})();
+    overrideAPI(fs, 'open')
+    overrideAPI(child_process, 'execFile')
+    overrideAPISync(process, 'dlopen', 1)
+    overrideAPISync(require('module')._extensions, '.node', 1)
+    overrideAPISync(fs, 'openSync')
+    return overrideAPISync(child_process, 'execFileSync')
+  }
+})()