coc-sonarlint 0.0.2 → 0.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/lib/index.js +315 -296
  2. package/package.json +1 -1
package/lib/index.js CHANGED
@@ -49,10 +49,10 @@ var require_which = __commonJS({
49
49
  module2.exports = which;
50
50
  which.sync = whichSync;
51
51
  var path3 = require("path");
52
- var fs3;
52
+ var fs4;
53
53
  var COLON = process.platform === "win32" ? ";" : ":";
54
54
  var isExe;
55
- var fs3 = require("fs");
55
+ var fs4 = require("fs");
56
56
  if (process.platform == "win32") {
57
57
  isExe = function isExe2() {
58
58
  return true;
@@ -82,7 +82,7 @@ var require_which = __commonJS({
82
82
  if (ii === ll)
83
83
  return F(i + 1, l);
84
84
  var ext = pathExt[ii];
85
- fs3.stat(p + ext, function(er, stat) {
85
+ fs4.stat(p + ext, function(er, stat) {
86
86
  if (!er && stat && stat.isFile() && isExe(stat.mode, stat.uid, stat.gid)) {
87
87
  return cb(null, p + ext);
88
88
  }
@@ -107,7 +107,7 @@ var require_which = __commonJS({
107
107
  var cur = p + pathExt[j];
108
108
  var stat;
109
109
  try {
110
- stat = fs3.statSync(cur);
110
+ stat = fs4.statSync(cur);
111
111
  } catch (ex) {
112
112
  }
113
113
  if (stat && stat.isFile() && isExe(stat.mode, stat.uid, stat.gid))
@@ -761,7 +761,7 @@ var require_dist = __commonJS({
761
761
  var __importDefault = exports && exports.__importDefault || function(mod) {
762
762
  return mod && mod.__esModule ? mod : { "default": mod };
763
763
  };
764
- var fs3 = __importStar(require("fs"));
764
+ var fs4 = __importStar(require("fs"));
765
765
  var path3 = __importStar(require("path"));
766
766
  var cp2 = __importStar(require("child_process"));
767
767
  var child_process_1 = require("child_process");
@@ -852,10 +852,10 @@ var require_dist = __commonJS({
852
852
  console.error(ex);
853
853
  }
854
854
  }
855
- proposed = fs3.realpathSync(proposed);
855
+ proposed = fs4.realpathSync(proposed);
856
856
  proposed = path3.dirname(proposed);
857
857
  var macUtility = path3.resolve(proposed, "java_home");
858
- if (fs3.existsSync(macUtility)) {
858
+ if (fs4.existsSync(macUtility)) {
859
859
  var buffer = void 0;
860
860
  try {
861
861
  buffer = cp2.execSync(macUtility, { cwd: proposed });
@@ -944,7 +944,7 @@ var require_dist = __commonJS({
944
944
  });
945
945
  }
946
946
  function dirIsJavaHome(dir, javaFilename) {
947
- return fs3.existsSync("" + dir) && fs3.statSync(dir).isDirectory() && fs3.existsSync(path3.resolve(dir, "bin", javaFilename));
947
+ return fs4.existsSync("" + dir) && fs4.statSync(dir).isDirectory() && fs4.existsSync(path3.resolve(dir, "bin", javaFilename));
948
948
  }
949
949
  module2.exports = findJavaHome2;
950
950
  }
@@ -1010,56 +1010,56 @@ var require_polyfills = __commonJS({
1010
1010
  }
1011
1011
  var chdir;
1012
1012
  module2.exports = patch;
1013
- function patch(fs3) {
1013
+ function patch(fs4) {
1014
1014
  if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
1015
- patchLchmod(fs3);
1016
- }
1017
- if (!fs3.lutimes) {
1018
- patchLutimes(fs3);
1019
- }
1020
- fs3.chown = chownFix(fs3.chown);
1021
- fs3.fchown = chownFix(fs3.fchown);
1022
- fs3.lchown = chownFix(fs3.lchown);
1023
- fs3.chmod = chmodFix(fs3.chmod);
1024
- fs3.fchmod = chmodFix(fs3.fchmod);
1025
- fs3.lchmod = chmodFix(fs3.lchmod);
1026
- fs3.chownSync = chownFixSync(fs3.chownSync);
1027
- fs3.fchownSync = chownFixSync(fs3.fchownSync);
1028
- fs3.lchownSync = chownFixSync(fs3.lchownSync);
1029
- fs3.chmodSync = chmodFixSync(fs3.chmodSync);
1030
- fs3.fchmodSync = chmodFixSync(fs3.fchmodSync);
1031
- fs3.lchmodSync = chmodFixSync(fs3.lchmodSync);
1032
- fs3.stat = statFix(fs3.stat);
1033
- fs3.fstat = statFix(fs3.fstat);
1034
- fs3.lstat = statFix(fs3.lstat);
1035
- fs3.statSync = statFixSync(fs3.statSync);
1036
- fs3.fstatSync = statFixSync(fs3.fstatSync);
1037
- fs3.lstatSync = statFixSync(fs3.lstatSync);
1038
- if (fs3.chmod && !fs3.lchmod) {
1039
- fs3.lchmod = function(path3, mode, cb) {
1015
+ patchLchmod(fs4);
1016
+ }
1017
+ if (!fs4.lutimes) {
1018
+ patchLutimes(fs4);
1019
+ }
1020
+ fs4.chown = chownFix(fs4.chown);
1021
+ fs4.fchown = chownFix(fs4.fchown);
1022
+ fs4.lchown = chownFix(fs4.lchown);
1023
+ fs4.chmod = chmodFix(fs4.chmod);
1024
+ fs4.fchmod = chmodFix(fs4.fchmod);
1025
+ fs4.lchmod = chmodFix(fs4.lchmod);
1026
+ fs4.chownSync = chownFixSync(fs4.chownSync);
1027
+ fs4.fchownSync = chownFixSync(fs4.fchownSync);
1028
+ fs4.lchownSync = chownFixSync(fs4.lchownSync);
1029
+ fs4.chmodSync = chmodFixSync(fs4.chmodSync);
1030
+ fs4.fchmodSync = chmodFixSync(fs4.fchmodSync);
1031
+ fs4.lchmodSync = chmodFixSync(fs4.lchmodSync);
1032
+ fs4.stat = statFix(fs4.stat);
1033
+ fs4.fstat = statFix(fs4.fstat);
1034
+ fs4.lstat = statFix(fs4.lstat);
1035
+ fs4.statSync = statFixSync(fs4.statSync);
1036
+ fs4.fstatSync = statFixSync(fs4.fstatSync);
1037
+ fs4.lstatSync = statFixSync(fs4.lstatSync);
1038
+ if (fs4.chmod && !fs4.lchmod) {
1039
+ fs4.lchmod = function(path3, mode, cb) {
1040
1040
  if (cb)
1041
1041
  process.nextTick(cb);
1042
1042
  };
1043
- fs3.lchmodSync = function() {
1043
+ fs4.lchmodSync = function() {
1044
1044
  };
1045
1045
  }
1046
- if (fs3.chown && !fs3.lchown) {
1047
- fs3.lchown = function(path3, uid, gid, cb) {
1046
+ if (fs4.chown && !fs4.lchown) {
1047
+ fs4.lchown = function(path3, uid, gid, cb) {
1048
1048
  if (cb)
1049
1049
  process.nextTick(cb);
1050
1050
  };
1051
- fs3.lchownSync = function() {
1051
+ fs4.lchownSync = function() {
1052
1052
  };
1053
1053
  }
1054
1054
  if (platform === "win32") {
1055
- fs3.rename = typeof fs3.rename !== "function" ? fs3.rename : function(fs$rename) {
1055
+ fs4.rename = typeof fs4.rename !== "function" ? fs4.rename : function(fs$rename) {
1056
1056
  function rename(from, to, cb) {
1057
1057
  var start = Date.now();
1058
1058
  var backoff = 0;
1059
1059
  fs$rename(from, to, function CB(er) {
1060
1060
  if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
1061
1061
  setTimeout(function() {
1062
- fs3.stat(to, function(stater, st) {
1062
+ fs4.stat(to, function(stater, st) {
1063
1063
  if (stater && stater.code === "ENOENT")
1064
1064
  fs$rename(from, to, CB);
1065
1065
  else
@@ -1077,9 +1077,9 @@ var require_polyfills = __commonJS({
1077
1077
  if (Object.setPrototypeOf)
1078
1078
  Object.setPrototypeOf(rename, fs$rename);
1079
1079
  return rename;
1080
- }(fs3.rename);
1080
+ }(fs4.rename);
1081
1081
  }
1082
- fs3.read = typeof fs3.read !== "function" ? fs3.read : function(fs$read) {
1082
+ fs4.read = typeof fs4.read !== "function" ? fs4.read : function(fs$read) {
1083
1083
  function read(fd, buffer, offset, length, position, callback_) {
1084
1084
  var callback;
1085
1085
  if (callback_ && typeof callback_ === "function") {
@@ -1087,23 +1087,23 @@ var require_polyfills = __commonJS({
1087
1087
  callback = function(er, _, __) {
1088
1088
  if (er && er.code === "EAGAIN" && eagCounter < 10) {
1089
1089
  eagCounter++;
1090
- return fs$read.call(fs3, fd, buffer, offset, length, position, callback);
1090
+ return fs$read.call(fs4, fd, buffer, offset, length, position, callback);
1091
1091
  }
1092
1092
  callback_.apply(this, arguments);
1093
1093
  };
1094
1094
  }
1095
- return fs$read.call(fs3, fd, buffer, offset, length, position, callback);
1095
+ return fs$read.call(fs4, fd, buffer, offset, length, position, callback);
1096
1096
  }
1097
1097
  if (Object.setPrototypeOf)
1098
1098
  Object.setPrototypeOf(read, fs$read);
1099
1099
  return read;
1100
- }(fs3.read);
1101
- fs3.readSync = typeof fs3.readSync !== "function" ? fs3.readSync : function(fs$readSync) {
1100
+ }(fs4.read);
1101
+ fs4.readSync = typeof fs4.readSync !== "function" ? fs4.readSync : function(fs$readSync) {
1102
1102
  return function(fd, buffer, offset, length, position) {
1103
1103
  var eagCounter = 0;
1104
1104
  while (true) {
1105
1105
  try {
1106
- return fs$readSync.call(fs3, fd, buffer, offset, length, position);
1106
+ return fs$readSync.call(fs4, fd, buffer, offset, length, position);
1107
1107
  } catch (er) {
1108
1108
  if (er.code === "EAGAIN" && eagCounter < 10) {
1109
1109
  eagCounter++;
@@ -1113,10 +1113,10 @@ var require_polyfills = __commonJS({
1113
1113
  }
1114
1114
  }
1115
1115
  };
1116
- }(fs3.readSync);
1117
- function patchLchmod(fs4) {
1118
- fs4.lchmod = function(path3, mode, callback) {
1119
- fs4.open(
1116
+ }(fs4.readSync);
1117
+ function patchLchmod(fs5) {
1118
+ fs5.lchmod = function(path3, mode, callback) {
1119
+ fs5.open(
1120
1120
  path3,
1121
1121
  constants.O_WRONLY | constants.O_SYMLINK,
1122
1122
  mode,
@@ -1126,8 +1126,8 @@ var require_polyfills = __commonJS({
1126
1126
  callback(err);
1127
1127
  return;
1128
1128
  }
1129
- fs4.fchmod(fd, mode, function(err2) {
1130
- fs4.close(fd, function(err22) {
1129
+ fs5.fchmod(fd, mode, function(err2) {
1130
+ fs5.close(fd, function(err22) {
1131
1131
  if (callback)
1132
1132
  callback(err2 || err22);
1133
1133
  });
@@ -1135,68 +1135,68 @@ var require_polyfills = __commonJS({
1135
1135
  }
1136
1136
  );
1137
1137
  };
1138
- fs4.lchmodSync = function(path3, mode) {
1139
- var fd = fs4.openSync(path3, constants.O_WRONLY | constants.O_SYMLINK, mode);
1138
+ fs5.lchmodSync = function(path3, mode) {
1139
+ var fd = fs5.openSync(path3, constants.O_WRONLY | constants.O_SYMLINK, mode);
1140
1140
  var threw = true;
1141
1141
  var ret;
1142
1142
  try {
1143
- ret = fs4.fchmodSync(fd, mode);
1143
+ ret = fs5.fchmodSync(fd, mode);
1144
1144
  threw = false;
1145
1145
  } finally {
1146
1146
  if (threw) {
1147
1147
  try {
1148
- fs4.closeSync(fd);
1148
+ fs5.closeSync(fd);
1149
1149
  } catch (er) {
1150
1150
  }
1151
1151
  } else {
1152
- fs4.closeSync(fd);
1152
+ fs5.closeSync(fd);
1153
1153
  }
1154
1154
  }
1155
1155
  return ret;
1156
1156
  };
1157
1157
  }
1158
- function patchLutimes(fs4) {
1159
- if (constants.hasOwnProperty("O_SYMLINK") && fs4.futimes) {
1160
- fs4.lutimes = function(path3, at, mt, cb) {
1161
- fs4.open(path3, constants.O_SYMLINK, function(er, fd) {
1158
+ function patchLutimes(fs5) {
1159
+ if (constants.hasOwnProperty("O_SYMLINK") && fs5.futimes) {
1160
+ fs5.lutimes = function(path3, at, mt, cb) {
1161
+ fs5.open(path3, constants.O_SYMLINK, function(er, fd) {
1162
1162
  if (er) {
1163
1163
  if (cb)
1164
1164
  cb(er);
1165
1165
  return;
1166
1166
  }
1167
- fs4.futimes(fd, at, mt, function(er2) {
1168
- fs4.close(fd, function(er22) {
1167
+ fs5.futimes(fd, at, mt, function(er2) {
1168
+ fs5.close(fd, function(er22) {
1169
1169
  if (cb)
1170
1170
  cb(er2 || er22);
1171
1171
  });
1172
1172
  });
1173
1173
  });
1174
1174
  };
1175
- fs4.lutimesSync = function(path3, at, mt) {
1176
- var fd = fs4.openSync(path3, constants.O_SYMLINK);
1175
+ fs5.lutimesSync = function(path3, at, mt) {
1176
+ var fd = fs5.openSync(path3, constants.O_SYMLINK);
1177
1177
  var ret;
1178
1178
  var threw = true;
1179
1179
  try {
1180
- ret = fs4.futimesSync(fd, at, mt);
1180
+ ret = fs5.futimesSync(fd, at, mt);
1181
1181
  threw = false;
1182
1182
  } finally {
1183
1183
  if (threw) {
1184
1184
  try {
1185
- fs4.closeSync(fd);
1185
+ fs5.closeSync(fd);
1186
1186
  } catch (er) {
1187
1187
  }
1188
1188
  } else {
1189
- fs4.closeSync(fd);
1189
+ fs5.closeSync(fd);
1190
1190
  }
1191
1191
  }
1192
1192
  return ret;
1193
1193
  };
1194
- } else if (fs4.futimes) {
1195
- fs4.lutimes = function(_a, _b, _c, cb) {
1194
+ } else if (fs5.futimes) {
1195
+ fs5.lutimes = function(_a, _b, _c, cb) {
1196
1196
  if (cb)
1197
1197
  process.nextTick(cb);
1198
1198
  };
1199
- fs4.lutimesSync = function() {
1199
+ fs5.lutimesSync = function() {
1200
1200
  };
1201
1201
  }
1202
1202
  }
@@ -1204,7 +1204,7 @@ var require_polyfills = __commonJS({
1204
1204
  if (!orig)
1205
1205
  return orig;
1206
1206
  return function(target, mode, cb) {
1207
- return orig.call(fs3, target, mode, function(er) {
1207
+ return orig.call(fs4, target, mode, function(er) {
1208
1208
  if (chownErOk(er))
1209
1209
  er = null;
1210
1210
  if (cb)
@@ -1217,7 +1217,7 @@ var require_polyfills = __commonJS({
1217
1217
  return orig;
1218
1218
  return function(target, mode) {
1219
1219
  try {
1220
- return orig.call(fs3, target, mode);
1220
+ return orig.call(fs4, target, mode);
1221
1221
  } catch (er) {
1222
1222
  if (!chownErOk(er))
1223
1223
  throw er;
@@ -1228,7 +1228,7 @@ var require_polyfills = __commonJS({
1228
1228
  if (!orig)
1229
1229
  return orig;
1230
1230
  return function(target, uid, gid, cb) {
1231
- return orig.call(fs3, target, uid, gid, function(er) {
1231
+ return orig.call(fs4, target, uid, gid, function(er) {
1232
1232
  if (chownErOk(er))
1233
1233
  er = null;
1234
1234
  if (cb)
@@ -1241,7 +1241,7 @@ var require_polyfills = __commonJS({
1241
1241
  return orig;
1242
1242
  return function(target, uid, gid) {
1243
1243
  try {
1244
- return orig.call(fs3, target, uid, gid);
1244
+ return orig.call(fs4, target, uid, gid);
1245
1245
  } catch (er) {
1246
1246
  if (!chownErOk(er))
1247
1247
  throw er;
@@ -1266,14 +1266,14 @@ var require_polyfills = __commonJS({
1266
1266
  if (cb)
1267
1267
  cb.apply(this, arguments);
1268
1268
  }
1269
- return options ? orig.call(fs3, target, options, callback) : orig.call(fs3, target, callback);
1269
+ return options ? orig.call(fs4, target, options, callback) : orig.call(fs4, target, callback);
1270
1270
  };
1271
1271
  }
1272
1272
  function statFixSync(orig) {
1273
1273
  if (!orig)
1274
1274
  return orig;
1275
1275
  return function(target, options) {
1276
- var stats = options ? orig.call(fs3, target, options) : orig.call(fs3, target);
1276
+ var stats = options ? orig.call(fs4, target, options) : orig.call(fs4, target);
1277
1277
  if (stats) {
1278
1278
  if (stats.uid < 0)
1279
1279
  stats.uid += 4294967296;
@@ -1304,7 +1304,7 @@ var require_legacy_streams = __commonJS({
1304
1304
  "node_modules/graceful-fs/legacy-streams.js"(exports, module2) {
1305
1305
  var Stream = require("stream").Stream;
1306
1306
  module2.exports = legacy;
1307
- function legacy(fs3) {
1307
+ function legacy(fs4) {
1308
1308
  return {
1309
1309
  ReadStream,
1310
1310
  WriteStream
@@ -1349,7 +1349,7 @@ var require_legacy_streams = __commonJS({
1349
1349
  });
1350
1350
  return;
1351
1351
  }
1352
- fs3.open(this.path, this.flags, this.mode, function(err, fd) {
1352
+ fs4.open(this.path, this.flags, this.mode, function(err, fd) {
1353
1353
  if (err) {
1354
1354
  self.emit("error", err);
1355
1355
  self.readable = false;
@@ -1389,7 +1389,7 @@ var require_legacy_streams = __commonJS({
1389
1389
  this.busy = false;
1390
1390
  this._queue = [];
1391
1391
  if (this.fd === null) {
1392
- this._open = fs3.open;
1392
+ this._open = fs4.open;
1393
1393
  this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
1394
1394
  this.flush();
1395
1395
  }
@@ -1424,7 +1424,7 @@ var require_clone = __commonJS({
1424
1424
  // node_modules/graceful-fs/graceful-fs.js
1425
1425
  var require_graceful_fs = __commonJS({
1426
1426
  "node_modules/graceful-fs/graceful-fs.js"(exports, module2) {
1427
- var fs3 = require("fs");
1427
+ var fs4 = require("fs");
1428
1428
  var polyfills = require_polyfills();
1429
1429
  var legacy = require_legacy_streams();
1430
1430
  var clone = require_clone();
@@ -1456,12 +1456,12 @@ var require_graceful_fs = __commonJS({
1456
1456
  m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
1457
1457
  console.error(m);
1458
1458
  };
1459
- if (!fs3[gracefulQueue]) {
1459
+ if (!fs4[gracefulQueue]) {
1460
1460
  queue = global[gracefulQueue] || [];
1461
- publishQueue(fs3, queue);
1462
- fs3.close = function(fs$close) {
1461
+ publishQueue(fs4, queue);
1462
+ fs4.close = function(fs$close) {
1463
1463
  function close(fd, cb) {
1464
- return fs$close.call(fs3, fd, function(err) {
1464
+ return fs$close.call(fs4, fd, function(err) {
1465
1465
  if (!err) {
1466
1466
  resetQueue();
1467
1467
  }
@@ -1473,40 +1473,40 @@ var require_graceful_fs = __commonJS({
1473
1473
  value: fs$close
1474
1474
  });
1475
1475
  return close;
1476
- }(fs3.close);
1477
- fs3.closeSync = function(fs$closeSync) {
1476
+ }(fs4.close);
1477
+ fs4.closeSync = function(fs$closeSync) {
1478
1478
  function closeSync(fd) {
1479
- fs$closeSync.apply(fs3, arguments);
1479
+ fs$closeSync.apply(fs4, arguments);
1480
1480
  resetQueue();
1481
1481
  }
1482
1482
  Object.defineProperty(closeSync, previousSymbol, {
1483
1483
  value: fs$closeSync
1484
1484
  });
1485
1485
  return closeSync;
1486
- }(fs3.closeSync);
1486
+ }(fs4.closeSync);
1487
1487
  if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
1488
1488
  process.on("exit", function() {
1489
- debug(fs3[gracefulQueue]);
1490
- require("assert").equal(fs3[gracefulQueue].length, 0);
1489
+ debug(fs4[gracefulQueue]);
1490
+ require("assert").equal(fs4[gracefulQueue].length, 0);
1491
1491
  });
1492
1492
  }
1493
1493
  }
1494
1494
  var queue;
1495
1495
  if (!global[gracefulQueue]) {
1496
- publishQueue(global, fs3[gracefulQueue]);
1497
- }
1498
- module2.exports = patch(clone(fs3));
1499
- if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs3.__patched) {
1500
- module2.exports = patch(fs3);
1501
- fs3.__patched = true;
1502
- }
1503
- function patch(fs4) {
1504
- polyfills(fs4);
1505
- fs4.gracefulify = patch;
1506
- fs4.createReadStream = createReadStream;
1507
- fs4.createWriteStream = createWriteStream;
1508
- var fs$readFile = fs4.readFile;
1509
- fs4.readFile = readFile;
1496
+ publishQueue(global, fs4[gracefulQueue]);
1497
+ }
1498
+ module2.exports = patch(clone(fs4));
1499
+ if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs4.__patched) {
1500
+ module2.exports = patch(fs4);
1501
+ fs4.__patched = true;
1502
+ }
1503
+ function patch(fs5) {
1504
+ polyfills(fs5);
1505
+ fs5.gracefulify = patch;
1506
+ fs5.createReadStream = createReadStream;
1507
+ fs5.createWriteStream = createWriteStream;
1508
+ var fs$readFile = fs5.readFile;
1509
+ fs5.readFile = readFile;
1510
1510
  function readFile(path3, options, cb) {
1511
1511
  if (typeof options === "function")
1512
1512
  cb = options, options = null;
@@ -1522,8 +1522,8 @@ var require_graceful_fs = __commonJS({
1522
1522
  });
1523
1523
  }
1524
1524
  }
1525
- var fs$writeFile = fs4.writeFile;
1526
- fs4.writeFile = writeFile;
1525
+ var fs$writeFile = fs5.writeFile;
1526
+ fs5.writeFile = writeFile;
1527
1527
  function writeFile(path3, data, options, cb) {
1528
1528
  if (typeof options === "function")
1529
1529
  cb = options, options = null;
@@ -1539,9 +1539,9 @@ var require_graceful_fs = __commonJS({
1539
1539
  });
1540
1540
  }
1541
1541
  }
1542
- var fs$appendFile = fs4.appendFile;
1542
+ var fs$appendFile = fs5.appendFile;
1543
1543
  if (fs$appendFile)
1544
- fs4.appendFile = appendFile;
1544
+ fs5.appendFile = appendFile;
1545
1545
  function appendFile(path3, data, options, cb) {
1546
1546
  if (typeof options === "function")
1547
1547
  cb = options, options = null;
@@ -1557,9 +1557,9 @@ var require_graceful_fs = __commonJS({
1557
1557
  });
1558
1558
  }
1559
1559
  }
1560
- var fs$copyFile = fs4.copyFile;
1560
+ var fs$copyFile = fs5.copyFile;
1561
1561
  if (fs$copyFile)
1562
- fs4.copyFile = copyFile;
1562
+ fs5.copyFile = copyFile;
1563
1563
  function copyFile(src, dest, flags, cb) {
1564
1564
  if (typeof flags === "function") {
1565
1565
  cb = flags;
@@ -1577,8 +1577,8 @@ var require_graceful_fs = __commonJS({
1577
1577
  });
1578
1578
  }
1579
1579
  }
1580
- var fs$readdir = fs4.readdir;
1581
- fs4.readdir = readdir;
1580
+ var fs$readdir = fs5.readdir;
1581
+ fs5.readdir = readdir;
1582
1582
  var noReaddirOptionVersions = /^v[0-5]\./;
1583
1583
  function readdir(path3, options, cb) {
1584
1584
  if (typeof options === "function")
@@ -1619,21 +1619,21 @@ var require_graceful_fs = __commonJS({
1619
1619
  }
1620
1620
  }
1621
1621
  if (process.version.substr(0, 4) === "v0.8") {
1622
- var legStreams = legacy(fs4);
1622
+ var legStreams = legacy(fs5);
1623
1623
  ReadStream = legStreams.ReadStream;
1624
1624
  WriteStream = legStreams.WriteStream;
1625
1625
  }
1626
- var fs$ReadStream = fs4.ReadStream;
1626
+ var fs$ReadStream = fs5.ReadStream;
1627
1627
  if (fs$ReadStream) {
1628
1628
  ReadStream.prototype = Object.create(fs$ReadStream.prototype);
1629
1629
  ReadStream.prototype.open = ReadStream$open;
1630
1630
  }
1631
- var fs$WriteStream = fs4.WriteStream;
1631
+ var fs$WriteStream = fs5.WriteStream;
1632
1632
  if (fs$WriteStream) {
1633
1633
  WriteStream.prototype = Object.create(fs$WriteStream.prototype);
1634
1634
  WriteStream.prototype.open = WriteStream$open;
1635
1635
  }
1636
- Object.defineProperty(fs4, "ReadStream", {
1636
+ Object.defineProperty(fs5, "ReadStream", {
1637
1637
  get: function() {
1638
1638
  return ReadStream;
1639
1639
  },
@@ -1643,7 +1643,7 @@ var require_graceful_fs = __commonJS({
1643
1643
  enumerable: true,
1644
1644
  configurable: true
1645
1645
  });
1646
- Object.defineProperty(fs4, "WriteStream", {
1646
+ Object.defineProperty(fs5, "WriteStream", {
1647
1647
  get: function() {
1648
1648
  return WriteStream;
1649
1649
  },
@@ -1654,7 +1654,7 @@ var require_graceful_fs = __commonJS({
1654
1654
  configurable: true
1655
1655
  });
1656
1656
  var FileReadStream = ReadStream;
1657
- Object.defineProperty(fs4, "FileReadStream", {
1657
+ Object.defineProperty(fs5, "FileReadStream", {
1658
1658
  get: function() {
1659
1659
  return FileReadStream;
1660
1660
  },
@@ -1665,7 +1665,7 @@ var require_graceful_fs = __commonJS({
1665
1665
  configurable: true
1666
1666
  });
1667
1667
  var FileWriteStream = WriteStream;
1668
- Object.defineProperty(fs4, "FileWriteStream", {
1668
+ Object.defineProperty(fs5, "FileWriteStream", {
1669
1669
  get: function() {
1670
1670
  return FileWriteStream;
1671
1671
  },
@@ -1714,13 +1714,13 @@ var require_graceful_fs = __commonJS({
1714
1714
  });
1715
1715
  }
1716
1716
  function createReadStream(path3, options) {
1717
- return new fs4.ReadStream(path3, options);
1717
+ return new fs5.ReadStream(path3, options);
1718
1718
  }
1719
1719
  function createWriteStream(path3, options) {
1720
- return new fs4.WriteStream(path3, options);
1720
+ return new fs5.WriteStream(path3, options);
1721
1721
  }
1722
- var fs$open = fs4.open;
1723
- fs4.open = open;
1722
+ var fs$open = fs5.open;
1723
+ fs5.open = open;
1724
1724
  function open(path3, flags, mode, cb) {
1725
1725
  if (typeof mode === "function")
1726
1726
  cb = mode, mode = null;
@@ -1736,20 +1736,20 @@ var require_graceful_fs = __commonJS({
1736
1736
  });
1737
1737
  }
1738
1738
  }
1739
- return fs4;
1739
+ return fs5;
1740
1740
  }
1741
1741
  function enqueue(elem) {
1742
1742
  debug("ENQUEUE", elem[0].name, elem[1]);
1743
- fs3[gracefulQueue].push(elem);
1743
+ fs4[gracefulQueue].push(elem);
1744
1744
  retry();
1745
1745
  }
1746
1746
  var retryTimer;
1747
1747
  function resetQueue() {
1748
1748
  var now = Date.now();
1749
- for (var i = 0; i < fs3[gracefulQueue].length; ++i) {
1750
- if (fs3[gracefulQueue][i].length > 2) {
1751
- fs3[gracefulQueue][i][3] = now;
1752
- fs3[gracefulQueue][i][4] = now;
1749
+ for (var i = 0; i < fs4[gracefulQueue].length; ++i) {
1750
+ if (fs4[gracefulQueue][i].length > 2) {
1751
+ fs4[gracefulQueue][i][3] = now;
1752
+ fs4[gracefulQueue][i][4] = now;
1753
1753
  }
1754
1754
  }
1755
1755
  retry();
@@ -1757,9 +1757,9 @@ var require_graceful_fs = __commonJS({
1757
1757
  function retry() {
1758
1758
  clearTimeout(retryTimer);
1759
1759
  retryTimer = void 0;
1760
- if (fs3[gracefulQueue].length === 0)
1760
+ if (fs4[gracefulQueue].length === 0)
1761
1761
  return;
1762
- var elem = fs3[gracefulQueue].shift();
1762
+ var elem = fs4[gracefulQueue].shift();
1763
1763
  var fn = elem[0];
1764
1764
  var args = elem[1];
1765
1765
  var err = elem[2];
@@ -1781,7 +1781,7 @@ var require_graceful_fs = __commonJS({
1781
1781
  debug("RETRY", fn.name, args);
1782
1782
  fn.apply(null, args.concat([startTime]));
1783
1783
  } else {
1784
- fs3[gracefulQueue].push(elem);
1784
+ fs4[gracefulQueue].push(elem);
1785
1785
  }
1786
1786
  }
1787
1787
  if (retryTimer === void 0) {
@@ -1796,7 +1796,7 @@ var require_fs = __commonJS({
1796
1796
  "node_modules/fs-extra/lib/fs/index.js"(exports) {
1797
1797
  "use strict";
1798
1798
  var u = require_universalify().fromCallback;
1799
- var fs3 = require_graceful_fs();
1799
+ var fs4 = require_graceful_fs();
1800
1800
  var api = [
1801
1801
  "access",
1802
1802
  "appendFile",
@@ -1831,31 +1831,31 @@ var require_fs = __commonJS({
1831
1831
  "utimes",
1832
1832
  "writeFile"
1833
1833
  ].filter((key) => {
1834
- return typeof fs3[key] === "function";
1834
+ return typeof fs4[key] === "function";
1835
1835
  });
1836
- Object.keys(fs3).forEach((key) => {
1836
+ Object.keys(fs4).forEach((key) => {
1837
1837
  if (key === "promises") {
1838
1838
  return;
1839
1839
  }
1840
- exports[key] = fs3[key];
1840
+ exports[key] = fs4[key];
1841
1841
  });
1842
1842
  api.forEach((method) => {
1843
- exports[method] = u(fs3[method]);
1843
+ exports[method] = u(fs4[method]);
1844
1844
  });
1845
1845
  exports.exists = function(filename, callback) {
1846
1846
  if (typeof callback === "function") {
1847
- return fs3.exists(filename, callback);
1847
+ return fs4.exists(filename, callback);
1848
1848
  }
1849
1849
  return new Promise((resolve3) => {
1850
- return fs3.exists(filename, resolve3);
1850
+ return fs4.exists(filename, resolve3);
1851
1851
  });
1852
1852
  };
1853
1853
  exports.read = function(fd, buffer, offset, length, position, callback) {
1854
1854
  if (typeof callback === "function") {
1855
- return fs3.read(fd, buffer, offset, length, position, callback);
1855
+ return fs4.read(fd, buffer, offset, length, position, callback);
1856
1856
  }
1857
1857
  return new Promise((resolve3, reject) => {
1858
- fs3.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
1858
+ fs4.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
1859
1859
  if (err)
1860
1860
  return reject(err);
1861
1861
  resolve3({ bytesRead, buffer: buffer2 });
@@ -1864,18 +1864,18 @@ var require_fs = __commonJS({
1864
1864
  };
1865
1865
  exports.write = function(fd, buffer, ...args) {
1866
1866
  if (typeof args[args.length - 1] === "function") {
1867
- return fs3.write(fd, buffer, ...args);
1867
+ return fs4.write(fd, buffer, ...args);
1868
1868
  }
1869
1869
  return new Promise((resolve3, reject) => {
1870
- fs3.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
1870
+ fs4.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
1871
1871
  if (err)
1872
1872
  return reject(err);
1873
1873
  resolve3({ bytesWritten, buffer: buffer2 });
1874
1874
  });
1875
1875
  });
1876
1876
  };
1877
- if (typeof fs3.realpath.native === "function") {
1878
- exports.realpath.native = u(fs3.realpath.native);
1877
+ if (typeof fs4.realpath.native === "function") {
1878
+ exports.realpath.native = u(fs4.realpath.native);
1879
1879
  }
1880
1880
  }
1881
1881
  });
@@ -1908,7 +1908,7 @@ var require_win32 = __commonJS({
1908
1908
  var require_mkdirs = __commonJS({
1909
1909
  "node_modules/fs-extra/lib/mkdirs/mkdirs.js"(exports, module2) {
1910
1910
  "use strict";
1911
- var fs3 = require_graceful_fs();
1911
+ var fs4 = require_graceful_fs();
1912
1912
  var path3 = require("path");
1913
1913
  var invalidWin32Path = require_win32().invalidWin32Path;
1914
1914
  var o777 = parseInt("0777", 8);
@@ -1925,7 +1925,7 @@ var require_mkdirs = __commonJS({
1925
1925
  return callback(errInval);
1926
1926
  }
1927
1927
  let mode = opts.mode;
1928
- const xfs = opts.fs || fs3;
1928
+ const xfs = opts.fs || fs4;
1929
1929
  if (mode === void 0) {
1930
1930
  mode = o777 & ~process.umask();
1931
1931
  }
@@ -1969,7 +1969,7 @@ var require_mkdirs = __commonJS({
1969
1969
  var require_mkdirs_sync = __commonJS({
1970
1970
  "node_modules/fs-extra/lib/mkdirs/mkdirs-sync.js"(exports, module2) {
1971
1971
  "use strict";
1972
- var fs3 = require_graceful_fs();
1972
+ var fs4 = require_graceful_fs();
1973
1973
  var path3 = require("path");
1974
1974
  var invalidWin32Path = require_win32().invalidWin32Path;
1975
1975
  var o777 = parseInt("0777", 8);
@@ -1978,7 +1978,7 @@ var require_mkdirs_sync = __commonJS({
1978
1978
  opts = { mode: opts };
1979
1979
  }
1980
1980
  let mode = opts.mode;
1981
- const xfs = opts.fs || fs3;
1981
+ const xfs = opts.fs || fs4;
1982
1982
  if (process.platform === "win32" && invalidWin32Path(p)) {
1983
1983
  const errInval = new Error(p + " contains invalid WIN32 path characters.");
1984
1984
  errInval.code = "EINVAL";
@@ -2038,36 +2038,36 @@ var require_mkdirs2 = __commonJS({
2038
2038
  var require_utimes = __commonJS({
2039
2039
  "node_modules/fs-extra/lib/util/utimes.js"(exports, module2) {
2040
2040
  "use strict";
2041
- var fs3 = require_graceful_fs();
2041
+ var fs4 = require_graceful_fs();
2042
2042
  var os = require("os");
2043
2043
  var path3 = require("path");
2044
2044
  function hasMillisResSync() {
2045
2045
  let tmpfile = path3.join("millis-test-sync" + Date.now().toString() + Math.random().toString().slice(2));
2046
2046
  tmpfile = path3.join(os.tmpdir(), tmpfile);
2047
2047
  const d = new Date(1435410243862);
2048
- fs3.writeFileSync(tmpfile, "https://github.com/jprichardson/node-fs-extra/pull/141");
2049
- const fd = fs3.openSync(tmpfile, "r+");
2050
- fs3.futimesSync(fd, d, d);
2051
- fs3.closeSync(fd);
2052
- return fs3.statSync(tmpfile).mtime > 1435410243e3;
2048
+ fs4.writeFileSync(tmpfile, "https://github.com/jprichardson/node-fs-extra/pull/141");
2049
+ const fd = fs4.openSync(tmpfile, "r+");
2050
+ fs4.futimesSync(fd, d, d);
2051
+ fs4.closeSync(fd);
2052
+ return fs4.statSync(tmpfile).mtime > 1435410243e3;
2053
2053
  }
2054
2054
  function hasMillisRes(callback) {
2055
2055
  let tmpfile = path3.join("millis-test" + Date.now().toString() + Math.random().toString().slice(2));
2056
2056
  tmpfile = path3.join(os.tmpdir(), tmpfile);
2057
2057
  const d = new Date(1435410243862);
2058
- fs3.writeFile(tmpfile, "https://github.com/jprichardson/node-fs-extra/pull/141", (err) => {
2058
+ fs4.writeFile(tmpfile, "https://github.com/jprichardson/node-fs-extra/pull/141", (err) => {
2059
2059
  if (err)
2060
2060
  return callback(err);
2061
- fs3.open(tmpfile, "r+", (err2, fd) => {
2061
+ fs4.open(tmpfile, "r+", (err2, fd) => {
2062
2062
  if (err2)
2063
2063
  return callback(err2);
2064
- fs3.futimes(fd, d, d, (err3) => {
2064
+ fs4.futimes(fd, d, d, (err3) => {
2065
2065
  if (err3)
2066
2066
  return callback(err3);
2067
- fs3.close(fd, (err4) => {
2067
+ fs4.close(fd, (err4) => {
2068
2068
  if (err4)
2069
2069
  return callback(err4);
2070
- fs3.stat(tmpfile, (err5, stats) => {
2070
+ fs4.stat(tmpfile, (err5, stats) => {
2071
2071
  if (err5)
2072
2072
  return callback(err5);
2073
2073
  callback(null, stats.mtime > 1435410243e3);
@@ -2087,11 +2087,11 @@ var require_utimes = __commonJS({
2087
2087
  }
2088
2088
  }
2089
2089
  function utimesMillis(path4, atime, mtime, callback) {
2090
- fs3.open(path4, "r+", (err, fd) => {
2090
+ fs4.open(path4, "r+", (err, fd) => {
2091
2091
  if (err)
2092
2092
  return callback(err);
2093
- fs3.futimes(fd, atime, mtime, (futimesErr) => {
2094
- fs3.close(fd, (closeErr) => {
2093
+ fs4.futimes(fd, atime, mtime, (futimesErr) => {
2094
+ fs4.close(fd, (closeErr) => {
2095
2095
  if (callback)
2096
2096
  callback(futimesErr || closeErr);
2097
2097
  });
@@ -2099,9 +2099,9 @@ var require_utimes = __commonJS({
2099
2099
  });
2100
2100
  }
2101
2101
  function utimesMillisSync(path4, atime, mtime) {
2102
- const fd = fs3.openSync(path4, "r+");
2103
- fs3.futimesSync(fd, atime, mtime);
2104
- return fs3.closeSync(fd);
2102
+ const fd = fs4.openSync(path4, "r+");
2103
+ fs4.futimesSync(fd, atime, mtime);
2104
+ return fs4.closeSync(fd);
2105
2105
  }
2106
2106
  module2.exports = {
2107
2107
  hasMillisRes,
@@ -2117,7 +2117,7 @@ var require_utimes = __commonJS({
2117
2117
  var require_stat = __commonJS({
2118
2118
  "node_modules/fs-extra/lib/util/stat.js"(exports, module2) {
2119
2119
  "use strict";
2120
- var fs3 = require_graceful_fs();
2120
+ var fs4 = require_graceful_fs();
2121
2121
  var path3 = require("path");
2122
2122
  var NODE_VERSION_MAJOR_WITH_BIGINT = 10;
2123
2123
  var NODE_VERSION_MINOR_WITH_BIGINT = 5;
@@ -2142,10 +2142,10 @@ var require_stat = __commonJS({
2142
2142
  }
2143
2143
  function getStats(src, dest, cb) {
2144
2144
  if (nodeSupportsBigInt()) {
2145
- fs3.stat(src, { bigint: true }, (err, srcStat) => {
2145
+ fs4.stat(src, { bigint: true }, (err, srcStat) => {
2146
2146
  if (err)
2147
2147
  return cb(err);
2148
- fs3.stat(dest, { bigint: true }, (err2, destStat) => {
2148
+ fs4.stat(dest, { bigint: true }, (err2, destStat) => {
2149
2149
  if (err2) {
2150
2150
  if (err2.code === "ENOENT")
2151
2151
  return cb(null, { srcStat, destStat: null });
@@ -2155,10 +2155,10 @@ var require_stat = __commonJS({
2155
2155
  });
2156
2156
  });
2157
2157
  } else {
2158
- fs3.stat(src, (err, srcStat) => {
2158
+ fs4.stat(src, (err, srcStat) => {
2159
2159
  if (err)
2160
2160
  return cb(err);
2161
- fs3.stat(dest, (err2, destStat) => {
2161
+ fs4.stat(dest, (err2, destStat) => {
2162
2162
  if (err2) {
2163
2163
  if (err2.code === "ENOENT")
2164
2164
  return cb(null, { srcStat, destStat: null });
@@ -2172,15 +2172,15 @@ var require_stat = __commonJS({
2172
2172
  function getStatsSync(src, dest) {
2173
2173
  let srcStat, destStat;
2174
2174
  if (nodeSupportsBigInt()) {
2175
- srcStat = fs3.statSync(src, { bigint: true });
2175
+ srcStat = fs4.statSync(src, { bigint: true });
2176
2176
  } else {
2177
- srcStat = fs3.statSync(src);
2177
+ srcStat = fs4.statSync(src);
2178
2178
  }
2179
2179
  try {
2180
2180
  if (nodeSupportsBigInt()) {
2181
- destStat = fs3.statSync(dest, { bigint: true });
2181
+ destStat = fs4.statSync(dest, { bigint: true });
2182
2182
  } else {
2183
- destStat = fs3.statSync(dest);
2183
+ destStat = fs4.statSync(dest);
2184
2184
  }
2185
2185
  } catch (err) {
2186
2186
  if (err.code === "ENOENT")
@@ -2219,7 +2219,7 @@ var require_stat = __commonJS({
2219
2219
  if (destParent === srcParent || destParent === path3.parse(destParent).root)
2220
2220
  return cb();
2221
2221
  if (nodeSupportsBigInt()) {
2222
- fs3.stat(destParent, { bigint: true }, (err, destStat) => {
2222
+ fs4.stat(destParent, { bigint: true }, (err, destStat) => {
2223
2223
  if (err) {
2224
2224
  if (err.code === "ENOENT")
2225
2225
  return cb();
@@ -2231,7 +2231,7 @@ var require_stat = __commonJS({
2231
2231
  return checkParentPaths(src, srcStat, destParent, funcName, cb);
2232
2232
  });
2233
2233
  } else {
2234
- fs3.stat(destParent, (err, destStat) => {
2234
+ fs4.stat(destParent, (err, destStat) => {
2235
2235
  if (err) {
2236
2236
  if (err.code === "ENOENT")
2237
2237
  return cb();
@@ -2252,9 +2252,9 @@ var require_stat = __commonJS({
2252
2252
  let destStat;
2253
2253
  try {
2254
2254
  if (nodeSupportsBigInt()) {
2255
- destStat = fs3.statSync(destParent, { bigint: true });
2255
+ destStat = fs4.statSync(destParent, { bigint: true });
2256
2256
  } else {
2257
- destStat = fs3.statSync(destParent);
2257
+ destStat = fs4.statSync(destParent);
2258
2258
  }
2259
2259
  } catch (err) {
2260
2260
  if (err.code === "ENOENT")
@@ -2305,7 +2305,7 @@ var require_buffer = __commonJS({
2305
2305
  var require_copy_sync = __commonJS({
2306
2306
  "node_modules/fs-extra/lib/copy-sync/copy-sync.js"(exports, module2) {
2307
2307
  "use strict";
2308
- var fs3 = require_graceful_fs();
2308
+ var fs4 = require_graceful_fs();
2309
2309
  var path3 = require("path");
2310
2310
  var mkdirpSync = require_mkdirs2().mkdirsSync;
2311
2311
  var utimesSync = require_utimes().utimesMillisSync;
@@ -2330,7 +2330,7 @@ var require_copy_sync = __commonJS({
2330
2330
  if (opts.filter && !opts.filter(src, dest))
2331
2331
  return;
2332
2332
  const destParent = path3.dirname(dest);
2333
- if (!fs3.existsSync(destParent))
2333
+ if (!fs4.existsSync(destParent))
2334
2334
  mkdirpSync(destParent);
2335
2335
  return startCopy(destStat, src, dest, opts);
2336
2336
  }
@@ -2340,7 +2340,7 @@ var require_copy_sync = __commonJS({
2340
2340
  return getStats(destStat, src, dest, opts);
2341
2341
  }
2342
2342
  function getStats(destStat, src, dest, opts) {
2343
- const statSync2 = opts.dereference ? fs3.statSync : fs3.lstatSync;
2343
+ const statSync2 = opts.dereference ? fs4.statSync : fs4.lstatSync;
2344
2344
  const srcStat = statSync2(src);
2345
2345
  if (srcStat.isDirectory())
2346
2346
  return onDir(srcStat, destStat, src, dest, opts);
@@ -2356,16 +2356,16 @@ var require_copy_sync = __commonJS({
2356
2356
  }
2357
2357
  function mayCopyFile(srcStat, src, dest, opts) {
2358
2358
  if (opts.overwrite) {
2359
- fs3.unlinkSync(dest);
2359
+ fs4.unlinkSync(dest);
2360
2360
  return copyFile(srcStat, src, dest, opts);
2361
2361
  } else if (opts.errorOnExist) {
2362
2362
  throw new Error(`'${dest}' already exists`);
2363
2363
  }
2364
2364
  }
2365
2365
  function copyFile(srcStat, src, dest, opts) {
2366
- if (typeof fs3.copyFileSync === "function") {
2367
- fs3.copyFileSync(src, dest);
2368
- fs3.chmodSync(dest, srcStat.mode);
2366
+ if (typeof fs4.copyFileSync === "function") {
2367
+ fs4.copyFileSync(src, dest);
2368
+ fs4.chmodSync(dest, srcStat.mode);
2369
2369
  if (opts.preserveTimestamps) {
2370
2370
  return utimesSync(dest, srcStat.atime, srcStat.mtime);
2371
2371
  }
@@ -2376,18 +2376,18 @@ var require_copy_sync = __commonJS({
2376
2376
  function copyFileFallback(srcStat, src, dest, opts) {
2377
2377
  const BUF_LENGTH = 64 * 1024;
2378
2378
  const _buff = require_buffer()(BUF_LENGTH);
2379
- const fdr = fs3.openSync(src, "r");
2380
- const fdw = fs3.openSync(dest, "w", srcStat.mode);
2379
+ const fdr = fs4.openSync(src, "r");
2380
+ const fdw = fs4.openSync(dest, "w", srcStat.mode);
2381
2381
  let pos = 0;
2382
2382
  while (pos < srcStat.size) {
2383
- const bytesRead = fs3.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
2384
- fs3.writeSync(fdw, _buff, 0, bytesRead);
2383
+ const bytesRead = fs4.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
2384
+ fs4.writeSync(fdw, _buff, 0, bytesRead);
2385
2385
  pos += bytesRead;
2386
2386
  }
2387
2387
  if (opts.preserveTimestamps)
2388
- fs3.futimesSync(fdw, srcStat.atime, srcStat.mtime);
2389
- fs3.closeSync(fdr);
2390
- fs3.closeSync(fdw);
2388
+ fs4.futimesSync(fdw, srcStat.atime, srcStat.mtime);
2389
+ fs4.closeSync(fdr);
2390
+ fs4.closeSync(fdw);
2391
2391
  }
2392
2392
  function onDir(srcStat, destStat, src, dest, opts) {
2393
2393
  if (!destStat)
@@ -2398,12 +2398,12 @@ var require_copy_sync = __commonJS({
2398
2398
  return copyDir(src, dest, opts);
2399
2399
  }
2400
2400
  function mkDirAndCopy(srcStat, src, dest, opts) {
2401
- fs3.mkdirSync(dest);
2401
+ fs4.mkdirSync(dest);
2402
2402
  copyDir(src, dest, opts);
2403
- return fs3.chmodSync(dest, srcStat.mode);
2403
+ return fs4.chmodSync(dest, srcStat.mode);
2404
2404
  }
2405
2405
  function copyDir(src, dest, opts) {
2406
- fs3.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
2406
+ fs4.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
2407
2407
  }
2408
2408
  function copyDirItem(item, src, dest, opts) {
2409
2409
  const srcItem = path3.join(src, item);
@@ -2412,19 +2412,19 @@ var require_copy_sync = __commonJS({
2412
2412
  return startCopy(destStat, srcItem, destItem, opts);
2413
2413
  }
2414
2414
  function onLink(destStat, src, dest, opts) {
2415
- let resolvedSrc = fs3.readlinkSync(src);
2415
+ let resolvedSrc = fs4.readlinkSync(src);
2416
2416
  if (opts.dereference) {
2417
2417
  resolvedSrc = path3.resolve(process.cwd(), resolvedSrc);
2418
2418
  }
2419
2419
  if (!destStat) {
2420
- return fs3.symlinkSync(resolvedSrc, dest);
2420
+ return fs4.symlinkSync(resolvedSrc, dest);
2421
2421
  } else {
2422
2422
  let resolvedDest;
2423
2423
  try {
2424
- resolvedDest = fs3.readlinkSync(dest);
2424
+ resolvedDest = fs4.readlinkSync(dest);
2425
2425
  } catch (err) {
2426
2426
  if (err.code === "EINVAL" || err.code === "UNKNOWN")
2427
- return fs3.symlinkSync(resolvedSrc, dest);
2427
+ return fs4.symlinkSync(resolvedSrc, dest);
2428
2428
  throw err;
2429
2429
  }
2430
2430
  if (opts.dereference) {
@@ -2433,15 +2433,15 @@ var require_copy_sync = __commonJS({
2433
2433
  if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
2434
2434
  throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
2435
2435
  }
2436
- if (fs3.statSync(dest).isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
2436
+ if (fs4.statSync(dest).isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
2437
2437
  throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
2438
2438
  }
2439
2439
  return copyLink(resolvedSrc, dest);
2440
2440
  }
2441
2441
  }
2442
2442
  function copyLink(resolvedSrc, dest) {
2443
- fs3.unlinkSync(dest);
2444
- return fs3.symlinkSync(resolvedSrc, dest);
2443
+ fs4.unlinkSync(dest);
2444
+ return fs4.symlinkSync(resolvedSrc, dest);
2445
2445
  }
2446
2446
  module2.exports = copySync;
2447
2447
  }
@@ -2462,13 +2462,13 @@ var require_path_exists = __commonJS({
2462
2462
  "node_modules/fs-extra/lib/path-exists/index.js"(exports, module2) {
2463
2463
  "use strict";
2464
2464
  var u = require_universalify().fromPromise;
2465
- var fs3 = require_fs();
2465
+ var fs4 = require_fs();
2466
2466
  function pathExists2(path3) {
2467
- return fs3.access(path3).then(() => true).catch(() => false);
2467
+ return fs4.access(path3).then(() => true).catch(() => false);
2468
2468
  }
2469
2469
  module2.exports = {
2470
2470
  pathExists: u(pathExists2),
2471
- pathExistsSync: fs3.existsSync
2471
+ pathExistsSync: fs4.existsSync
2472
2472
  };
2473
2473
  }
2474
2474
  });
@@ -2477,7 +2477,7 @@ var require_path_exists = __commonJS({
2477
2477
  var require_copy = __commonJS({
2478
2478
  "node_modules/fs-extra/lib/copy/copy.js"(exports, module2) {
2479
2479
  "use strict";
2480
- var fs3 = require_graceful_fs();
2480
+ var fs4 = require_graceful_fs();
2481
2481
  var path3 = require("path");
2482
2482
  var mkdirp = require_mkdirs2().mkdirs;
2483
2483
  var pathExists2 = require_path_exists().pathExists;
@@ -2540,7 +2540,7 @@ var require_copy = __commonJS({
2540
2540
  return getStats(destStat, src, dest, opts, cb);
2541
2541
  }
2542
2542
  function getStats(destStat, src, dest, opts, cb) {
2543
- const stat2 = opts.dereference ? fs3.stat : fs3.lstat;
2543
+ const stat2 = opts.dereference ? fs4.stat : fs4.lstat;
2544
2544
  stat2(src, (err, srcStat) => {
2545
2545
  if (err)
2546
2546
  return cb(err);
@@ -2559,7 +2559,7 @@ var require_copy = __commonJS({
2559
2559
  }
2560
2560
  function mayCopyFile(srcStat, src, dest, opts, cb) {
2561
2561
  if (opts.overwrite) {
2562
- fs3.unlink(dest, (err) => {
2562
+ fs4.unlink(dest, (err) => {
2563
2563
  if (err)
2564
2564
  return cb(err);
2565
2565
  return copyFile(srcStat, src, dest, opts, cb);
@@ -2570,8 +2570,8 @@ var require_copy = __commonJS({
2570
2570
  return cb();
2571
2571
  }
2572
2572
  function copyFile(srcStat, src, dest, opts, cb) {
2573
- if (typeof fs3.copyFile === "function") {
2574
- return fs3.copyFile(src, dest, (err) => {
2573
+ if (typeof fs4.copyFile === "function") {
2574
+ return fs4.copyFile(src, dest, (err) => {
2575
2575
  if (err)
2576
2576
  return cb(err);
2577
2577
  return setDestModeAndTimestamps(srcStat, dest, opts, cb);
@@ -2580,14 +2580,14 @@ var require_copy = __commonJS({
2580
2580
  return copyFileFallback(srcStat, src, dest, opts, cb);
2581
2581
  }
2582
2582
  function copyFileFallback(srcStat, src, dest, opts, cb) {
2583
- const rs = fs3.createReadStream(src);
2583
+ const rs = fs4.createReadStream(src);
2584
2584
  rs.on("error", (err) => cb(err)).once("open", () => {
2585
- const ws = fs3.createWriteStream(dest, { mode: srcStat.mode });
2585
+ const ws = fs4.createWriteStream(dest, { mode: srcStat.mode });
2586
2586
  ws.on("error", (err) => cb(err)).on("open", () => rs.pipe(ws)).once("close", () => setDestModeAndTimestamps(srcStat, dest, opts, cb));
2587
2587
  });
2588
2588
  }
2589
2589
  function setDestModeAndTimestamps(srcStat, dest, opts, cb) {
2590
- fs3.chmod(dest, srcStat.mode, (err) => {
2590
+ fs4.chmod(dest, srcStat.mode, (err) => {
2591
2591
  if (err)
2592
2592
  return cb(err);
2593
2593
  if (opts.preserveTimestamps) {
@@ -2605,18 +2605,18 @@ var require_copy = __commonJS({
2605
2605
  return copyDir(src, dest, opts, cb);
2606
2606
  }
2607
2607
  function mkDirAndCopy(srcStat, src, dest, opts, cb) {
2608
- fs3.mkdir(dest, (err) => {
2608
+ fs4.mkdir(dest, (err) => {
2609
2609
  if (err)
2610
2610
  return cb(err);
2611
2611
  copyDir(src, dest, opts, (err2) => {
2612
2612
  if (err2)
2613
2613
  return cb(err2);
2614
- return fs3.chmod(dest, srcStat.mode, cb);
2614
+ return fs4.chmod(dest, srcStat.mode, cb);
2615
2615
  });
2616
2616
  });
2617
2617
  }
2618
2618
  function copyDir(src, dest, opts, cb) {
2619
- fs3.readdir(src, (err, items) => {
2619
+ fs4.readdir(src, (err, items) => {
2620
2620
  if (err)
2621
2621
  return cb(err);
2622
2622
  return copyDirItems(items, src, dest, opts, cb);
@@ -2643,19 +2643,19 @@ var require_copy = __commonJS({
2643
2643
  });
2644
2644
  }
2645
2645
  function onLink(destStat, src, dest, opts, cb) {
2646
- fs3.readlink(src, (err, resolvedSrc) => {
2646
+ fs4.readlink(src, (err, resolvedSrc) => {
2647
2647
  if (err)
2648
2648
  return cb(err);
2649
2649
  if (opts.dereference) {
2650
2650
  resolvedSrc = path3.resolve(process.cwd(), resolvedSrc);
2651
2651
  }
2652
2652
  if (!destStat) {
2653
- return fs3.symlink(resolvedSrc, dest, cb);
2653
+ return fs4.symlink(resolvedSrc, dest, cb);
2654
2654
  } else {
2655
- fs3.readlink(dest, (err2, resolvedDest) => {
2655
+ fs4.readlink(dest, (err2, resolvedDest) => {
2656
2656
  if (err2) {
2657
2657
  if (err2.code === "EINVAL" || err2.code === "UNKNOWN")
2658
- return fs3.symlink(resolvedSrc, dest, cb);
2658
+ return fs4.symlink(resolvedSrc, dest, cb);
2659
2659
  return cb(err2);
2660
2660
  }
2661
2661
  if (opts.dereference) {
@@ -2673,10 +2673,10 @@ var require_copy = __commonJS({
2673
2673
  });
2674
2674
  }
2675
2675
  function copyLink(resolvedSrc, dest, cb) {
2676
- fs3.unlink(dest, (err) => {
2676
+ fs4.unlink(dest, (err) => {
2677
2677
  if (err)
2678
2678
  return cb(err);
2679
- return fs3.symlink(resolvedSrc, dest, cb);
2679
+ return fs4.symlink(resolvedSrc, dest, cb);
2680
2680
  });
2681
2681
  }
2682
2682
  module2.exports = copy;
@@ -2698,7 +2698,7 @@ var require_copy2 = __commonJS({
2698
2698
  var require_rimraf = __commonJS({
2699
2699
  "node_modules/fs-extra/lib/remove/rimraf.js"(exports, module2) {
2700
2700
  "use strict";
2701
- var fs3 = require_graceful_fs();
2701
+ var fs4 = require_graceful_fs();
2702
2702
  var path3 = require("path");
2703
2703
  var assert = require("assert");
2704
2704
  var isWindows2 = process.platform === "win32";
@@ -2712,9 +2712,9 @@ var require_rimraf = __commonJS({
2712
2712
  "readdir"
2713
2713
  ];
2714
2714
  methods.forEach((m) => {
2715
- options[m] = options[m] || fs3[m];
2715
+ options[m] = options[m] || fs4[m];
2716
2716
  m = m + "Sync";
2717
- options[m] = options[m] || fs3[m];
2717
+ options[m] = options[m] || fs4[m];
2718
2718
  });
2719
2719
  options.maxBusyTries = options.maxBusyTries || 3;
2720
2720
  }
@@ -2963,14 +2963,14 @@ var require_empty = __commonJS({
2963
2963
  "node_modules/fs-extra/lib/empty/index.js"(exports, module2) {
2964
2964
  "use strict";
2965
2965
  var u = require_universalify().fromCallback;
2966
- var fs3 = require_graceful_fs();
2966
+ var fs4 = require_graceful_fs();
2967
2967
  var path3 = require("path");
2968
2968
  var mkdir = require_mkdirs2();
2969
2969
  var remove = require_remove();
2970
2970
  var emptyDir = u(function emptyDir2(dir, callback) {
2971
2971
  callback = callback || function() {
2972
2972
  };
2973
- fs3.readdir(dir, (err, items) => {
2973
+ fs4.readdir(dir, (err, items) => {
2974
2974
  if (err)
2975
2975
  return mkdir.mkdirs(dir, callback);
2976
2976
  items = items.map((item) => path3.join(dir, item));
@@ -2990,7 +2990,7 @@ var require_empty = __commonJS({
2990
2990
  function emptyDirSync(dir) {
2991
2991
  let items;
2992
2992
  try {
2993
- items = fs3.readdirSync(dir);
2993
+ items = fs4.readdirSync(dir);
2994
2994
  } catch (err) {
2995
2995
  return mkdir.mkdirsSync(dir);
2996
2996
  }
@@ -3014,18 +3014,18 @@ var require_file = __commonJS({
3014
3014
  "use strict";
3015
3015
  var u = require_universalify().fromCallback;
3016
3016
  var path3 = require("path");
3017
- var fs3 = require_graceful_fs();
3017
+ var fs4 = require_graceful_fs();
3018
3018
  var mkdir = require_mkdirs2();
3019
3019
  var pathExists2 = require_path_exists().pathExists;
3020
3020
  function createFile(file, callback) {
3021
3021
  function makeFile() {
3022
- fs3.writeFile(file, "", (err) => {
3022
+ fs4.writeFile(file, "", (err) => {
3023
3023
  if (err)
3024
3024
  return callback(err);
3025
3025
  callback();
3026
3026
  });
3027
3027
  }
3028
- fs3.stat(file, (err, stats) => {
3028
+ fs4.stat(file, (err, stats) => {
3029
3029
  if (!err && stats.isFile())
3030
3030
  return callback();
3031
3031
  const dir = path3.dirname(file);
@@ -3045,16 +3045,16 @@ var require_file = __commonJS({
3045
3045
  function createFileSync(file) {
3046
3046
  let stats;
3047
3047
  try {
3048
- stats = fs3.statSync(file);
3048
+ stats = fs4.statSync(file);
3049
3049
  } catch (e) {
3050
3050
  }
3051
3051
  if (stats && stats.isFile())
3052
3052
  return;
3053
3053
  const dir = path3.dirname(file);
3054
- if (!fs3.existsSync(dir)) {
3054
+ if (!fs4.existsSync(dir)) {
3055
3055
  mkdir.mkdirsSync(dir);
3056
3056
  }
3057
- fs3.writeFileSync(file, "");
3057
+ fs4.writeFileSync(file, "");
3058
3058
  }
3059
3059
  module2.exports = {
3060
3060
  createFile: u(createFile),
@@ -3069,12 +3069,12 @@ var require_link = __commonJS({
3069
3069
  "use strict";
3070
3070
  var u = require_universalify().fromCallback;
3071
3071
  var path3 = require("path");
3072
- var fs3 = require_graceful_fs();
3072
+ var fs4 = require_graceful_fs();
3073
3073
  var mkdir = require_mkdirs2();
3074
3074
  var pathExists2 = require_path_exists().pathExists;
3075
3075
  function createLink(srcpath, dstpath, callback) {
3076
3076
  function makeLink(srcpath2, dstpath2) {
3077
- fs3.link(srcpath2, dstpath2, (err) => {
3077
+ fs4.link(srcpath2, dstpath2, (err) => {
3078
3078
  if (err)
3079
3079
  return callback(err);
3080
3080
  callback(null);
@@ -3085,7 +3085,7 @@ var require_link = __commonJS({
3085
3085
  return callback(err);
3086
3086
  if (destinationExists)
3087
3087
  return callback(null);
3088
- fs3.lstat(srcpath, (err2) => {
3088
+ fs4.lstat(srcpath, (err2) => {
3089
3089
  if (err2) {
3090
3090
  err2.message = err2.message.replace("lstat", "ensureLink");
3091
3091
  return callback(err2);
@@ -3106,21 +3106,21 @@ var require_link = __commonJS({
3106
3106
  });
3107
3107
  }
3108
3108
  function createLinkSync(srcpath, dstpath) {
3109
- const destinationExists = fs3.existsSync(dstpath);
3109
+ const destinationExists = fs4.existsSync(dstpath);
3110
3110
  if (destinationExists)
3111
3111
  return void 0;
3112
3112
  try {
3113
- fs3.lstatSync(srcpath);
3113
+ fs4.lstatSync(srcpath);
3114
3114
  } catch (err) {
3115
3115
  err.message = err.message.replace("lstat", "ensureLink");
3116
3116
  throw err;
3117
3117
  }
3118
3118
  const dir = path3.dirname(dstpath);
3119
- const dirExists = fs3.existsSync(dir);
3119
+ const dirExists = fs4.existsSync(dir);
3120
3120
  if (dirExists)
3121
- return fs3.linkSync(srcpath, dstpath);
3121
+ return fs4.linkSync(srcpath, dstpath);
3122
3122
  mkdir.mkdirsSync(dir);
3123
- return fs3.linkSync(srcpath, dstpath);
3123
+ return fs4.linkSync(srcpath, dstpath);
3124
3124
  }
3125
3125
  module2.exports = {
3126
3126
  createLink: u(createLink),
@@ -3134,11 +3134,11 @@ var require_symlink_paths = __commonJS({
3134
3134
  "node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports, module2) {
3135
3135
  "use strict";
3136
3136
  var path3 = require("path");
3137
- var fs3 = require_graceful_fs();
3137
+ var fs4 = require_graceful_fs();
3138
3138
  var pathExists2 = require_path_exists().pathExists;
3139
3139
  function symlinkPaths(srcpath, dstpath, callback) {
3140
3140
  if (path3.isAbsolute(srcpath)) {
3141
- return fs3.lstat(srcpath, (err) => {
3141
+ return fs4.lstat(srcpath, (err) => {
3142
3142
  if (err) {
3143
3143
  err.message = err.message.replace("lstat", "ensureSymlink");
3144
3144
  return callback(err);
@@ -3160,7 +3160,7 @@ var require_symlink_paths = __commonJS({
3160
3160
  "toDst": srcpath
3161
3161
  });
3162
3162
  } else {
3163
- return fs3.lstat(srcpath, (err2) => {
3163
+ return fs4.lstat(srcpath, (err2) => {
3164
3164
  if (err2) {
3165
3165
  err2.message = err2.message.replace("lstat", "ensureSymlink");
3166
3166
  return callback(err2);
@@ -3177,7 +3177,7 @@ var require_symlink_paths = __commonJS({
3177
3177
  function symlinkPathsSync(srcpath, dstpath) {
3178
3178
  let exists;
3179
3179
  if (path3.isAbsolute(srcpath)) {
3180
- exists = fs3.existsSync(srcpath);
3180
+ exists = fs4.existsSync(srcpath);
3181
3181
  if (!exists)
3182
3182
  throw new Error("absolute srcpath does not exist");
3183
3183
  return {
@@ -3187,14 +3187,14 @@ var require_symlink_paths = __commonJS({
3187
3187
  } else {
3188
3188
  const dstdir = path3.dirname(dstpath);
3189
3189
  const relativeToDst = path3.join(dstdir, srcpath);
3190
- exists = fs3.existsSync(relativeToDst);
3190
+ exists = fs4.existsSync(relativeToDst);
3191
3191
  if (exists) {
3192
3192
  return {
3193
3193
  "toCwd": relativeToDst,
3194
3194
  "toDst": srcpath
3195
3195
  };
3196
3196
  } else {
3197
- exists = fs3.existsSync(srcpath);
3197
+ exists = fs4.existsSync(srcpath);
3198
3198
  if (!exists)
3199
3199
  throw new Error("relative srcpath does not exist");
3200
3200
  return {
@@ -3215,13 +3215,13 @@ var require_symlink_paths = __commonJS({
3215
3215
  var require_symlink_type = __commonJS({
3216
3216
  "node_modules/fs-extra/lib/ensure/symlink-type.js"(exports, module2) {
3217
3217
  "use strict";
3218
- var fs3 = require_graceful_fs();
3218
+ var fs4 = require_graceful_fs();
3219
3219
  function symlinkType(srcpath, type, callback) {
3220
3220
  callback = typeof type === "function" ? type : callback;
3221
3221
  type = typeof type === "function" ? false : type;
3222
3222
  if (type)
3223
3223
  return callback(null, type);
3224
- fs3.lstat(srcpath, (err, stats) => {
3224
+ fs4.lstat(srcpath, (err, stats) => {
3225
3225
  if (err)
3226
3226
  return callback(null, "file");
3227
3227
  type = stats && stats.isDirectory() ? "dir" : "file";
@@ -3233,7 +3233,7 @@ var require_symlink_type = __commonJS({
3233
3233
  if (type)
3234
3234
  return type;
3235
3235
  try {
3236
- stats = fs3.lstatSync(srcpath);
3236
+ stats = fs4.lstatSync(srcpath);
3237
3237
  } catch (e) {
3238
3238
  return "file";
3239
3239
  }
@@ -3252,7 +3252,7 @@ var require_symlink = __commonJS({
3252
3252
  "use strict";
3253
3253
  var u = require_universalify().fromCallback;
3254
3254
  var path3 = require("path");
3255
- var fs3 = require_graceful_fs();
3255
+ var fs4 = require_graceful_fs();
3256
3256
  var _mkdirs = require_mkdirs2();
3257
3257
  var mkdirs = _mkdirs.mkdirs;
3258
3258
  var mkdirsSync = _mkdirs.mkdirsSync;
@@ -3283,11 +3283,11 @@ var require_symlink = __commonJS({
3283
3283
  if (err4)
3284
3284
  return callback(err4);
3285
3285
  if (dirExists)
3286
- return fs3.symlink(srcpath, dstpath, type2, callback);
3286
+ return fs4.symlink(srcpath, dstpath, type2, callback);
3287
3287
  mkdirs(dir, (err5) => {
3288
3288
  if (err5)
3289
3289
  return callback(err5);
3290
- fs3.symlink(srcpath, dstpath, type2, callback);
3290
+ fs4.symlink(srcpath, dstpath, type2, callback);
3291
3291
  });
3292
3292
  });
3293
3293
  });
@@ -3295,18 +3295,18 @@ var require_symlink = __commonJS({
3295
3295
  });
3296
3296
  }
3297
3297
  function createSymlinkSync(srcpath, dstpath, type) {
3298
- const destinationExists = fs3.existsSync(dstpath);
3298
+ const destinationExists = fs4.existsSync(dstpath);
3299
3299
  if (destinationExists)
3300
3300
  return void 0;
3301
3301
  const relative = symlinkPathsSync(srcpath, dstpath);
3302
3302
  srcpath = relative.toDst;
3303
3303
  type = symlinkTypeSync(relative.toCwd, type);
3304
3304
  const dir = path3.dirname(dstpath);
3305
- const exists = fs3.existsSync(dir);
3305
+ const exists = fs4.existsSync(dir);
3306
3306
  if (exists)
3307
- return fs3.symlinkSync(srcpath, dstpath, type);
3307
+ return fs4.symlinkSync(srcpath, dstpath, type);
3308
3308
  mkdirsSync(dir);
3309
- return fs3.symlinkSync(srcpath, dstpath, type);
3309
+ return fs4.symlinkSync(srcpath, dstpath, type);
3310
3310
  }
3311
3311
  module2.exports = {
3312
3312
  createSymlink: u(createSymlink),
@@ -3357,12 +3357,12 @@ var require_jsonfile = __commonJS({
3357
3357
  options = { encoding: options };
3358
3358
  }
3359
3359
  options = options || {};
3360
- var fs3 = options.fs || _fs;
3360
+ var fs4 = options.fs || _fs;
3361
3361
  var shouldThrow = true;
3362
3362
  if ("throws" in options) {
3363
3363
  shouldThrow = options.throws;
3364
3364
  }
3365
- fs3.readFile(file, options, function(err, data) {
3365
+ fs4.readFile(file, options, function(err, data) {
3366
3366
  if (err)
3367
3367
  return callback(err);
3368
3368
  data = stripBom(data);
@@ -3385,13 +3385,13 @@ var require_jsonfile = __commonJS({
3385
3385
  if (typeof options === "string") {
3386
3386
  options = { encoding: options };
3387
3387
  }
3388
- var fs3 = options.fs || _fs;
3388
+ var fs4 = options.fs || _fs;
3389
3389
  var shouldThrow = true;
3390
3390
  if ("throws" in options) {
3391
3391
  shouldThrow = options.throws;
3392
3392
  }
3393
3393
  try {
3394
- var content = fs3.readFileSync(file, options);
3394
+ var content = fs4.readFileSync(file, options);
3395
3395
  content = stripBom(content);
3396
3396
  return JSON.parse(content, options.reviver);
3397
3397
  } catch (err) {
@@ -3423,7 +3423,7 @@ var require_jsonfile = __commonJS({
3423
3423
  options = {};
3424
3424
  }
3425
3425
  options = options || {};
3426
- var fs3 = options.fs || _fs;
3426
+ var fs4 = options.fs || _fs;
3427
3427
  var str = "";
3428
3428
  try {
3429
3429
  str = stringify(obj, options);
@@ -3432,13 +3432,13 @@ var require_jsonfile = __commonJS({
3432
3432
  callback(err, null);
3433
3433
  return;
3434
3434
  }
3435
- fs3.writeFile(file, str, options, callback);
3435
+ fs4.writeFile(file, str, options, callback);
3436
3436
  }
3437
3437
  function writeFileSync(file, obj, options) {
3438
3438
  options = options || {};
3439
- var fs3 = options.fs || _fs;
3439
+ var fs4 = options.fs || _fs;
3440
3440
  var str = stringify(obj, options);
3441
- return fs3.writeFileSync(file, str, options);
3441
+ return fs4.writeFileSync(file, str, options);
3442
3442
  }
3443
3443
  function stripBom(content) {
3444
3444
  if (Buffer.isBuffer(content))
@@ -3505,13 +3505,13 @@ var require_output_json = __commonJS({
3505
3505
  var require_output_json_sync = __commonJS({
3506
3506
  "node_modules/fs-extra/lib/json/output-json-sync.js"(exports, module2) {
3507
3507
  "use strict";
3508
- var fs3 = require_graceful_fs();
3508
+ var fs4 = require_graceful_fs();
3509
3509
  var path3 = require("path");
3510
3510
  var mkdir = require_mkdirs2();
3511
3511
  var jsonFile = require_jsonfile2();
3512
3512
  function outputJsonSync(file, data, options) {
3513
3513
  const dir = path3.dirname(file);
3514
- if (!fs3.existsSync(dir)) {
3514
+ if (!fs4.existsSync(dir)) {
3515
3515
  mkdir.mkdirsSync(dir);
3516
3516
  }
3517
3517
  jsonFile.writeJsonSync(file, data, options);
@@ -3542,7 +3542,7 @@ var require_json = __commonJS({
3542
3542
  var require_move_sync = __commonJS({
3543
3543
  "node_modules/fs-extra/lib/move-sync/move-sync.js"(exports, module2) {
3544
3544
  "use strict";
3545
- var fs3 = require_graceful_fs();
3545
+ var fs4 = require_graceful_fs();
3546
3546
  var path3 = require("path");
3547
3547
  var copySync = require_copy_sync2().copySync;
3548
3548
  var removeSync = require_remove().removeSync;
@@ -3561,13 +3561,13 @@ var require_move_sync = __commonJS({
3561
3561
  removeSync(dest);
3562
3562
  return rename(src, dest, overwrite);
3563
3563
  }
3564
- if (fs3.existsSync(dest))
3564
+ if (fs4.existsSync(dest))
3565
3565
  throw new Error("dest already exists.");
3566
3566
  return rename(src, dest, overwrite);
3567
3567
  }
3568
3568
  function rename(src, dest, overwrite) {
3569
3569
  try {
3570
- fs3.renameSync(src, dest);
3570
+ fs4.renameSync(src, dest);
3571
3571
  } catch (err) {
3572
3572
  if (err.code !== "EXDEV")
3573
3573
  throw err;
@@ -3600,7 +3600,7 @@ var require_move_sync2 = __commonJS({
3600
3600
  var require_move = __commonJS({
3601
3601
  "node_modules/fs-extra/lib/move/move.js"(exports, module2) {
3602
3602
  "use strict";
3603
- var fs3 = require_graceful_fs();
3603
+ var fs4 = require_graceful_fs();
3604
3604
  var path3 = require("path");
3605
3605
  var copy = require_copy2().copy;
3606
3606
  var remove = require_remove().remove;
@@ -3645,7 +3645,7 @@ var require_move = __commonJS({
3645
3645
  });
3646
3646
  }
3647
3647
  function rename(src, dest, overwrite, cb) {
3648
- fs3.rename(src, dest, (err) => {
3648
+ fs4.rename(src, dest, (err) => {
3649
3649
  if (!err)
3650
3650
  return cb();
3651
3651
  if (err.code !== "EXDEV")
@@ -3684,7 +3684,7 @@ var require_output = __commonJS({
3684
3684
  "node_modules/fs-extra/lib/output/index.js"(exports, module2) {
3685
3685
  "use strict";
3686
3686
  var u = require_universalify().fromCallback;
3687
- var fs3 = require_graceful_fs();
3687
+ var fs4 = require_graceful_fs();
3688
3688
  var path3 = require("path");
3689
3689
  var mkdir = require_mkdirs2();
3690
3690
  var pathExists2 = require_path_exists().pathExists;
@@ -3698,21 +3698,21 @@ var require_output = __commonJS({
3698
3698
  if (err)
3699
3699
  return callback(err);
3700
3700
  if (itDoes)
3701
- return fs3.writeFile(file, data, encoding, callback);
3701
+ return fs4.writeFile(file, data, encoding, callback);
3702
3702
  mkdir.mkdirs(dir, (err2) => {
3703
3703
  if (err2)
3704
3704
  return callback(err2);
3705
- fs3.writeFile(file, data, encoding, callback);
3705
+ fs4.writeFile(file, data, encoding, callback);
3706
3706
  });
3707
3707
  });
3708
3708
  }
3709
3709
  function outputFileSync(file, ...args) {
3710
3710
  const dir = path3.dirname(file);
3711
- if (fs3.existsSync(dir)) {
3712
- return fs3.writeFileSync(file, ...args);
3711
+ if (fs4.existsSync(dir)) {
3712
+ return fs4.writeFileSync(file, ...args);
3713
3713
  }
3714
3714
  mkdir.mkdirsSync(dir);
3715
- fs3.writeFileSync(file, ...args);
3715
+ fs4.writeFileSync(file, ...args);
3716
3716
  }
3717
3717
  module2.exports = {
3718
3718
  outputFile: u(outputFile),
@@ -3740,11 +3740,11 @@ var require_lib = __commonJS({
3740
3740
  require_path_exists(),
3741
3741
  require_remove()
3742
3742
  );
3743
- var fs3 = require("fs");
3744
- if (Object.getOwnPropertyDescriptor(fs3, "promises")) {
3743
+ var fs4 = require("fs");
3744
+ if (Object.getOwnPropertyDescriptor(fs4, "promises")) {
3745
3745
  Object.defineProperty(module2.exports, "promises", {
3746
3746
  get() {
3747
- return fs3.promises;
3747
+ return fs4.promises;
3748
3748
  }
3749
3749
  });
3750
3750
  }
@@ -3755,9 +3755,9 @@ var require_lib = __commonJS({
3755
3755
  var require_path_exists2 = __commonJS({
3756
3756
  "node_modules/path-exists/index.js"(exports, module2) {
3757
3757
  "use strict";
3758
- var fs3 = require("fs");
3758
+ var fs4 = require("fs");
3759
3759
  var { promisify } = require("util");
3760
- var pAccess = promisify(fs3.access);
3760
+ var pAccess = promisify(fs4.access);
3761
3761
  module2.exports = async (path3) => {
3762
3762
  try {
3763
3763
  await pAccess(path3);
@@ -3768,7 +3768,7 @@ var require_path_exists2 = __commonJS({
3768
3768
  };
3769
3769
  module2.exports.sync = (path3) => {
3770
3770
  try {
3771
- fs3.accessSync(path3);
3771
+ fs4.accessSync(path3);
3772
3772
  return true;
3773
3773
  } catch (_) {
3774
3774
  return false;
@@ -4240,11 +4240,26 @@ function showLogOutput() {
4240
4240
  }
4241
4241
 
4242
4242
  // src/lsp/server.ts
4243
+ var fs = __toESM(require("fs"));
4243
4244
  var Path = __toESM(require("path"));
4244
4245
  var coc3 = __toESM(require("coc.nvim"));
4245
4246
  var DEBUG = typeof v8debug === "object" || startedInDebugMode(process);
4246
4247
  function languageServerCommand(context, requirements) {
4247
- const location = getSonarLintConfiguration().get("ls.directory", context.extensionPath);
4248
+ let location = getSonarLintConfiguration().get("ls.directory");
4249
+ location = !location ? Path.resolve(__dirname, "../") : location;
4250
+ if (location) {
4251
+ location = coc3.workspace.expand(location);
4252
+ if (!fs.existsSync(location)) {
4253
+ logToSonarLintOutput(
4254
+ `Sonar can not start, invalid or non existent path was detected ${location}`
4255
+ );
4256
+ coc3.window.showWarningMessage(`Sonar binaries were not found, check SonarLint output`);
4257
+ return void 0;
4258
+ }
4259
+ } else {
4260
+ coc3.window.showWarningMessage(`Sonar binaries directory could not be resolved at all`);
4261
+ return void 0;
4262
+ }
4248
4263
  const serverJar = Path.resolve(
4249
4264
  location,
4250
4265
  "server",
@@ -4703,7 +4718,7 @@ var SonarLintExtendedLanguageClient = class extends coc6.LanguageClient {
4703
4718
  };
4704
4719
 
4705
4720
  // src/util/platform.ts
4706
- var fs = __toESM(require("fs"));
4721
+ var fs2 = __toESM(require("fs"));
4707
4722
  function getPlatform() {
4708
4723
  const platform = process.platform;
4709
4724
  if (platform === "linux" && isAlpineLinux()) {
@@ -4714,10 +4729,10 @@ function getPlatform() {
4714
4729
  function isAlpineLinux() {
4715
4730
  let fileContent;
4716
4731
  try {
4717
- fileContent = fs.readFileSync("/etc/os-release", "utf-8");
4732
+ fileContent = fs2.readFileSync("/etc/os-release", "utf-8");
4718
4733
  } catch (error1) {
4719
4734
  try {
4720
- fileContent = fs.readFileSync("/usr/lib/os-release", "utf-8");
4735
+ fileContent = fs2.readFileSync("/usr/lib/os-release", "utf-8");
4721
4736
  } catch (error2) {
4722
4737
  return false;
4723
4738
  }
@@ -5172,7 +5187,7 @@ function renderRuleParam(param, config) {
5172
5187
 
5173
5188
  // src/cfamily/cfamily.ts
5174
5189
  var coc10 = __toESM(require("coc.nvim"));
5175
- var fs2 = __toESM(require("fs"));
5190
+ var fs3 = __toESM(require("fs"));
5176
5191
  var path2 = __toESM(require("path"));
5177
5192
 
5178
5193
  // src/commons.ts
@@ -5226,7 +5241,7 @@ function tryRelativizeToWorkspaceFolder(filePath) {
5226
5241
  return [filePath, void 0];
5227
5242
  }
5228
5243
  async function configureCompilationDatabase() {
5229
- const paths = (await coc10.workspace.findFiles(`**/compile_commands.json`)).filter((path3) => fs2.existsSync(path3.fsPath));
5244
+ const paths = (await coc10.workspace.findFiles(`**/compile_commands.json`)).filter((path3) => fs3.existsSync(path3.fsPath));
5230
5245
  if (paths.length === 0) {
5231
5246
  coc10.window.showWarningMessage(`No compilation databases were found in the workspace
5232
5247
 
@@ -5314,10 +5329,14 @@ async function runJavaServer(context) {
5314
5329
  });
5315
5330
  throw error;
5316
5331
  }).then((requirements) => {
5317
- return new Promise((resolve3, _) => {
5332
+ return new Promise((resolve3, reject) => {
5318
5333
  const { command, args } = languageServerCommand(context, requirements);
5334
+ if (!command) {
5335
+ reject(void 0);
5336
+ return;
5337
+ }
5319
5338
  logToSonarLintOutput(`Executing ${command} ${args.join(" ")}`);
5320
- import_coc2.window.showInformationMessage("Sonarlint is starting...");
5339
+ import_coc2.window.showInformationMessage("Sonarlint server is starting...");
5321
5340
  const process2 = ChildProcess.spawn(command, args);
5322
5341
  process2.stderr.on("data", function(data) {
5323
5342
  logWithPrefix(data, "[stderr]");