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