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.
- package/lib/index.js +315 -296
- 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
|
|
52
|
+
var fs4;
|
|
53
53
|
var COLON = process.platform === "win32" ? ";" : ":";
|
|
54
54
|
var isExe;
|
|
55
|
-
var
|
|
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
|
-
|
|
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 =
|
|
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
|
|
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 =
|
|
855
|
+
proposed = fs4.realpathSync(proposed);
|
|
856
856
|
proposed = path3.dirname(proposed);
|
|
857
857
|
var macUtility = path3.resolve(proposed, "java_home");
|
|
858
|
-
if (
|
|
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
|
|
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(
|
|
1013
|
+
function patch(fs4) {
|
|
1014
1014
|
if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
|
|
1015
|
-
patchLchmod(
|
|
1016
|
-
}
|
|
1017
|
-
if (!
|
|
1018
|
-
patchLutimes(
|
|
1019
|
-
}
|
|
1020
|
-
|
|
1021
|
-
|
|
1022
|
-
|
|
1023
|
-
|
|
1024
|
-
|
|
1025
|
-
|
|
1026
|
-
|
|
1027
|
-
|
|
1028
|
-
|
|
1029
|
-
|
|
1030
|
-
|
|
1031
|
-
|
|
1032
|
-
|
|
1033
|
-
|
|
1034
|
-
|
|
1035
|
-
|
|
1036
|
-
|
|
1037
|
-
|
|
1038
|
-
if (
|
|
1039
|
-
|
|
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
|
-
|
|
1043
|
+
fs4.lchmodSync = function() {
|
|
1044
1044
|
};
|
|
1045
1045
|
}
|
|
1046
|
-
if (
|
|
1047
|
-
|
|
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
|
-
|
|
1051
|
+
fs4.lchownSync = function() {
|
|
1052
1052
|
};
|
|
1053
1053
|
}
|
|
1054
1054
|
if (platform === "win32") {
|
|
1055
|
-
|
|
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
|
-
|
|
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
|
-
}(
|
|
1080
|
+
}(fs4.rename);
|
|
1081
1081
|
}
|
|
1082
|
-
|
|
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(
|
|
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(
|
|
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
|
-
}(
|
|
1101
|
-
|
|
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(
|
|
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
|
-
}(
|
|
1117
|
-
function patchLchmod(
|
|
1118
|
-
|
|
1119
|
-
|
|
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
|
-
|
|
1130
|
-
|
|
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
|
-
|
|
1139
|
-
var fd =
|
|
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 =
|
|
1143
|
+
ret = fs5.fchmodSync(fd, mode);
|
|
1144
1144
|
threw = false;
|
|
1145
1145
|
} finally {
|
|
1146
1146
|
if (threw) {
|
|
1147
1147
|
try {
|
|
1148
|
-
|
|
1148
|
+
fs5.closeSync(fd);
|
|
1149
1149
|
} catch (er) {
|
|
1150
1150
|
}
|
|
1151
1151
|
} else {
|
|
1152
|
-
|
|
1152
|
+
fs5.closeSync(fd);
|
|
1153
1153
|
}
|
|
1154
1154
|
}
|
|
1155
1155
|
return ret;
|
|
1156
1156
|
};
|
|
1157
1157
|
}
|
|
1158
|
-
function patchLutimes(
|
|
1159
|
-
if (constants.hasOwnProperty("O_SYMLINK") &&
|
|
1160
|
-
|
|
1161
|
-
|
|
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
|
-
|
|
1168
|
-
|
|
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
|
-
|
|
1176
|
-
var fd =
|
|
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 =
|
|
1180
|
+
ret = fs5.futimesSync(fd, at, mt);
|
|
1181
1181
|
threw = false;
|
|
1182
1182
|
} finally {
|
|
1183
1183
|
if (threw) {
|
|
1184
1184
|
try {
|
|
1185
|
-
|
|
1185
|
+
fs5.closeSync(fd);
|
|
1186
1186
|
} catch (er) {
|
|
1187
1187
|
}
|
|
1188
1188
|
} else {
|
|
1189
|
-
|
|
1189
|
+
fs5.closeSync(fd);
|
|
1190
1190
|
}
|
|
1191
1191
|
}
|
|
1192
1192
|
return ret;
|
|
1193
1193
|
};
|
|
1194
|
-
} else if (
|
|
1195
|
-
|
|
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
|
-
|
|
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(
|
|
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(
|
|
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(
|
|
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(
|
|
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(
|
|
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(
|
|
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(
|
|
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
|
-
|
|
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 =
|
|
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
|
|
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 (!
|
|
1459
|
+
if (!fs4[gracefulQueue]) {
|
|
1460
1460
|
queue = global[gracefulQueue] || [];
|
|
1461
|
-
publishQueue(
|
|
1462
|
-
|
|
1461
|
+
publishQueue(fs4, queue);
|
|
1462
|
+
fs4.close = function(fs$close) {
|
|
1463
1463
|
function close(fd, cb) {
|
|
1464
|
-
return fs$close.call(
|
|
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
|
-
}(
|
|
1477
|
-
|
|
1476
|
+
}(fs4.close);
|
|
1477
|
+
fs4.closeSync = function(fs$closeSync) {
|
|
1478
1478
|
function closeSync(fd) {
|
|
1479
|
-
fs$closeSync.apply(
|
|
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
|
-
}(
|
|
1486
|
+
}(fs4.closeSync);
|
|
1487
1487
|
if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
|
|
1488
1488
|
process.on("exit", function() {
|
|
1489
|
-
debug(
|
|
1490
|
-
require("assert").equal(
|
|
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,
|
|
1497
|
-
}
|
|
1498
|
-
module2.exports = patch(clone(
|
|
1499
|
-
if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !
|
|
1500
|
-
module2.exports = patch(
|
|
1501
|
-
|
|
1502
|
-
}
|
|
1503
|
-
function patch(
|
|
1504
|
-
polyfills(
|
|
1505
|
-
|
|
1506
|
-
|
|
1507
|
-
|
|
1508
|
-
var fs$readFile =
|
|
1509
|
-
|
|
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 =
|
|
1526
|
-
|
|
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 =
|
|
1542
|
+
var fs$appendFile = fs5.appendFile;
|
|
1543
1543
|
if (fs$appendFile)
|
|
1544
|
-
|
|
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 =
|
|
1560
|
+
var fs$copyFile = fs5.copyFile;
|
|
1561
1561
|
if (fs$copyFile)
|
|
1562
|
-
|
|
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 =
|
|
1581
|
-
|
|
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(
|
|
1622
|
+
var legStreams = legacy(fs5);
|
|
1623
1623
|
ReadStream = legStreams.ReadStream;
|
|
1624
1624
|
WriteStream = legStreams.WriteStream;
|
|
1625
1625
|
}
|
|
1626
|
-
var fs$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 =
|
|
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(
|
|
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(
|
|
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(
|
|
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(
|
|
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
|
|
1717
|
+
return new fs5.ReadStream(path3, options);
|
|
1718
1718
|
}
|
|
1719
1719
|
function createWriteStream(path3, options) {
|
|
1720
|
-
return new
|
|
1720
|
+
return new fs5.WriteStream(path3, options);
|
|
1721
1721
|
}
|
|
1722
|
-
var fs$open =
|
|
1723
|
-
|
|
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
|
|
1739
|
+
return fs5;
|
|
1740
1740
|
}
|
|
1741
1741
|
function enqueue(elem) {
|
|
1742
1742
|
debug("ENQUEUE", elem[0].name, elem[1]);
|
|
1743
|
-
|
|
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 <
|
|
1750
|
-
if (
|
|
1751
|
-
|
|
1752
|
-
|
|
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 (
|
|
1760
|
+
if (fs4[gracefulQueue].length === 0)
|
|
1761
1761
|
return;
|
|
1762
|
-
var elem =
|
|
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
|
-
|
|
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
|
|
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
|
|
1834
|
+
return typeof fs4[key] === "function";
|
|
1835
1835
|
});
|
|
1836
|
-
Object.keys(
|
|
1836
|
+
Object.keys(fs4).forEach((key) => {
|
|
1837
1837
|
if (key === "promises") {
|
|
1838
1838
|
return;
|
|
1839
1839
|
}
|
|
1840
|
-
exports[key] =
|
|
1840
|
+
exports[key] = fs4[key];
|
|
1841
1841
|
});
|
|
1842
1842
|
api.forEach((method) => {
|
|
1843
|
-
exports[method] = u(
|
|
1843
|
+
exports[method] = u(fs4[method]);
|
|
1844
1844
|
});
|
|
1845
1845
|
exports.exists = function(filename, callback) {
|
|
1846
1846
|
if (typeof callback === "function") {
|
|
1847
|
-
return
|
|
1847
|
+
return fs4.exists(filename, callback);
|
|
1848
1848
|
}
|
|
1849
1849
|
return new Promise((resolve3) => {
|
|
1850
|
-
return
|
|
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
|
|
1855
|
+
return fs4.read(fd, buffer, offset, length, position, callback);
|
|
1856
1856
|
}
|
|
1857
1857
|
return new Promise((resolve3, reject) => {
|
|
1858
|
-
|
|
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
|
|
1867
|
+
return fs4.write(fd, buffer, ...args);
|
|
1868
1868
|
}
|
|
1869
1869
|
return new Promise((resolve3, reject) => {
|
|
1870
|
-
|
|
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
|
|
1878
|
-
exports.realpath.native = u(
|
|
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
|
|
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 ||
|
|
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
|
|
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 ||
|
|
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
|
|
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
|
-
|
|
2049
|
-
const fd =
|
|
2050
|
-
|
|
2051
|
-
|
|
2052
|
-
return
|
|
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
|
-
|
|
2058
|
+
fs4.writeFile(tmpfile, "https://github.com/jprichardson/node-fs-extra/pull/141", (err) => {
|
|
2059
2059
|
if (err)
|
|
2060
2060
|
return callback(err);
|
|
2061
|
-
|
|
2061
|
+
fs4.open(tmpfile, "r+", (err2, fd) => {
|
|
2062
2062
|
if (err2)
|
|
2063
2063
|
return callback(err2);
|
|
2064
|
-
|
|
2064
|
+
fs4.futimes(fd, d, d, (err3) => {
|
|
2065
2065
|
if (err3)
|
|
2066
2066
|
return callback(err3);
|
|
2067
|
-
|
|
2067
|
+
fs4.close(fd, (err4) => {
|
|
2068
2068
|
if (err4)
|
|
2069
2069
|
return callback(err4);
|
|
2070
|
-
|
|
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
|
-
|
|
2090
|
+
fs4.open(path4, "r+", (err, fd) => {
|
|
2091
2091
|
if (err)
|
|
2092
2092
|
return callback(err);
|
|
2093
|
-
|
|
2094
|
-
|
|
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 =
|
|
2103
|
-
|
|
2104
|
-
return
|
|
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
|
|
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
|
-
|
|
2145
|
+
fs4.stat(src, { bigint: true }, (err, srcStat) => {
|
|
2146
2146
|
if (err)
|
|
2147
2147
|
return cb(err);
|
|
2148
|
-
|
|
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
|
-
|
|
2158
|
+
fs4.stat(src, (err, srcStat) => {
|
|
2159
2159
|
if (err)
|
|
2160
2160
|
return cb(err);
|
|
2161
|
-
|
|
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 =
|
|
2175
|
+
srcStat = fs4.statSync(src, { bigint: true });
|
|
2176
2176
|
} else {
|
|
2177
|
-
srcStat =
|
|
2177
|
+
srcStat = fs4.statSync(src);
|
|
2178
2178
|
}
|
|
2179
2179
|
try {
|
|
2180
2180
|
if (nodeSupportsBigInt()) {
|
|
2181
|
-
destStat =
|
|
2181
|
+
destStat = fs4.statSync(dest, { bigint: true });
|
|
2182
2182
|
} else {
|
|
2183
|
-
destStat =
|
|
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
|
-
|
|
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
|
-
|
|
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 =
|
|
2255
|
+
destStat = fs4.statSync(destParent, { bigint: true });
|
|
2256
2256
|
} else {
|
|
2257
|
-
destStat =
|
|
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
|
|
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 (!
|
|
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 ?
|
|
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
|
-
|
|
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
|
|
2367
|
-
|
|
2368
|
-
|
|
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 =
|
|
2380
|
-
const fdw =
|
|
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 =
|
|
2384
|
-
|
|
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
|
-
|
|
2389
|
-
|
|
2390
|
-
|
|
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
|
-
|
|
2401
|
+
fs4.mkdirSync(dest);
|
|
2402
2402
|
copyDir(src, dest, opts);
|
|
2403
|
-
return
|
|
2403
|
+
return fs4.chmodSync(dest, srcStat.mode);
|
|
2404
2404
|
}
|
|
2405
2405
|
function copyDir(src, dest, opts) {
|
|
2406
|
-
|
|
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 =
|
|
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
|
|
2420
|
+
return fs4.symlinkSync(resolvedSrc, dest);
|
|
2421
2421
|
} else {
|
|
2422
2422
|
let resolvedDest;
|
|
2423
2423
|
try {
|
|
2424
|
-
resolvedDest =
|
|
2424
|
+
resolvedDest = fs4.readlinkSync(dest);
|
|
2425
2425
|
} catch (err) {
|
|
2426
2426
|
if (err.code === "EINVAL" || err.code === "UNKNOWN")
|
|
2427
|
-
return
|
|
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 (
|
|
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
|
-
|
|
2444
|
-
return
|
|
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
|
|
2465
|
+
var fs4 = require_fs();
|
|
2466
2466
|
function pathExists2(path3) {
|
|
2467
|
-
return
|
|
2467
|
+
return fs4.access(path3).then(() => true).catch(() => false);
|
|
2468
2468
|
}
|
|
2469
2469
|
module2.exports = {
|
|
2470
2470
|
pathExists: u(pathExists2),
|
|
2471
|
-
pathExistsSync:
|
|
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
|
|
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 ?
|
|
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
|
-
|
|
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
|
|
2574
|
-
return
|
|
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 =
|
|
2583
|
+
const rs = fs4.createReadStream(src);
|
|
2584
2584
|
rs.on("error", (err) => cb(err)).once("open", () => {
|
|
2585
|
-
const ws =
|
|
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
|
-
|
|
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
|
-
|
|
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
|
|
2614
|
+
return fs4.chmod(dest, srcStat.mode, cb);
|
|
2615
2615
|
});
|
|
2616
2616
|
});
|
|
2617
2617
|
}
|
|
2618
2618
|
function copyDir(src, dest, opts, cb) {
|
|
2619
|
-
|
|
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
|
-
|
|
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
|
|
2653
|
+
return fs4.symlink(resolvedSrc, dest, cb);
|
|
2654
2654
|
} else {
|
|
2655
|
-
|
|
2655
|
+
fs4.readlink(dest, (err2, resolvedDest) => {
|
|
2656
2656
|
if (err2) {
|
|
2657
2657
|
if (err2.code === "EINVAL" || err2.code === "UNKNOWN")
|
|
2658
|
-
return
|
|
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
|
-
|
|
2676
|
+
fs4.unlink(dest, (err) => {
|
|
2677
2677
|
if (err)
|
|
2678
2678
|
return cb(err);
|
|
2679
|
-
return
|
|
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
|
|
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] ||
|
|
2715
|
+
options[m] = options[m] || fs4[m];
|
|
2716
2716
|
m = m + "Sync";
|
|
2717
|
-
options[m] = options[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
|
|
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
|
-
|
|
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 =
|
|
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
|
|
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
|
-
|
|
3022
|
+
fs4.writeFile(file, "", (err) => {
|
|
3023
3023
|
if (err)
|
|
3024
3024
|
return callback(err);
|
|
3025
3025
|
callback();
|
|
3026
3026
|
});
|
|
3027
3027
|
}
|
|
3028
|
-
|
|
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 =
|
|
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 (!
|
|
3054
|
+
if (!fs4.existsSync(dir)) {
|
|
3055
3055
|
mkdir.mkdirsSync(dir);
|
|
3056
3056
|
}
|
|
3057
|
-
|
|
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
|
|
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
|
-
|
|
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
|
-
|
|
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 =
|
|
3109
|
+
const destinationExists = fs4.existsSync(dstpath);
|
|
3110
3110
|
if (destinationExists)
|
|
3111
3111
|
return void 0;
|
|
3112
3112
|
try {
|
|
3113
|
-
|
|
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 =
|
|
3119
|
+
const dirExists = fs4.existsSync(dir);
|
|
3120
3120
|
if (dirExists)
|
|
3121
|
-
return
|
|
3121
|
+
return fs4.linkSync(srcpath, dstpath);
|
|
3122
3122
|
mkdir.mkdirsSync(dir);
|
|
3123
|
-
return
|
|
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
|
|
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
|
|
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
|
|
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 =
|
|
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 =
|
|
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 =
|
|
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
|
|
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
|
-
|
|
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 =
|
|
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
|
|
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
|
|
3286
|
+
return fs4.symlink(srcpath, dstpath, type2, callback);
|
|
3287
3287
|
mkdirs(dir, (err5) => {
|
|
3288
3288
|
if (err5)
|
|
3289
3289
|
return callback(err5);
|
|
3290
|
-
|
|
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 =
|
|
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 =
|
|
3305
|
+
const exists = fs4.existsSync(dir);
|
|
3306
3306
|
if (exists)
|
|
3307
|
-
return
|
|
3307
|
+
return fs4.symlinkSync(srcpath, dstpath, type);
|
|
3308
3308
|
mkdirsSync(dir);
|
|
3309
|
-
return
|
|
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
|
|
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
|
-
|
|
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
|
|
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 =
|
|
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
|
|
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
|
-
|
|
3435
|
+
fs4.writeFile(file, str, options, callback);
|
|
3436
3436
|
}
|
|
3437
3437
|
function writeFileSync(file, obj, options) {
|
|
3438
3438
|
options = options || {};
|
|
3439
|
-
var
|
|
3439
|
+
var fs4 = options.fs || _fs;
|
|
3440
3440
|
var str = stringify(obj, options);
|
|
3441
|
-
return
|
|
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
|
|
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 (!
|
|
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
|
|
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 (
|
|
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
|
-
|
|
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
|
|
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
|
-
|
|
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
|
|
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
|
|
3701
|
+
return fs4.writeFile(file, data, encoding, callback);
|
|
3702
3702
|
mkdir.mkdirs(dir, (err2) => {
|
|
3703
3703
|
if (err2)
|
|
3704
3704
|
return callback(err2);
|
|
3705
|
-
|
|
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 (
|
|
3712
|
-
return
|
|
3711
|
+
if (fs4.existsSync(dir)) {
|
|
3712
|
+
return fs4.writeFileSync(file, ...args);
|
|
3713
3713
|
}
|
|
3714
3714
|
mkdir.mkdirsSync(dir);
|
|
3715
|
-
|
|
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
|
|
3744
|
-
if (Object.getOwnPropertyDescriptor(
|
|
3743
|
+
var fs4 = require("fs");
|
|
3744
|
+
if (Object.getOwnPropertyDescriptor(fs4, "promises")) {
|
|
3745
3745
|
Object.defineProperty(module2.exports, "promises", {
|
|
3746
3746
|
get() {
|
|
3747
|
-
return
|
|
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
|
|
3758
|
+
var fs4 = require("fs");
|
|
3759
3759
|
var { promisify } = require("util");
|
|
3760
|
-
var pAccess = promisify(
|
|
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
|
-
|
|
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
|
-
|
|
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
|
|
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 =
|
|
4732
|
+
fileContent = fs2.readFileSync("/etc/os-release", "utf-8");
|
|
4718
4733
|
} catch (error1) {
|
|
4719
4734
|
try {
|
|
4720
|
-
fileContent =
|
|
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
|
|
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) =>
|
|
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]");
|